Microsoft/TypeScript
1
0
Fork 0
mirror of https://github.com/microsoft/TypeScript.git synced 2025-11-18 17:21:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into emitCleanup

Browse Source
This commit is contained in:
Cyrus Najmabadi
2015-01-27 17:10:33 -08:00
parent 34b342ac97 a43bb47d7b
commit 71de2de6ed
310 changed files with 5733 additions and 586 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/compiler/binder.ts
+23 -17
View File
@@ -50,12 +50,13 @@ module ts {
}
/**
* Returns false if any of the following are true:
* 1. declaration has no name
* 2. declaration has a literal name (not computed)
* 3. declaration has a computed property name that is a known symbol
* A declaration has a dynamic name if both of the following are true:
* 1. The declaration has a computed property name
* 2. The computed name is *not* expressed as Symbol.<name>, where name
* is a property of the Symbol constructor that denotes a built in
* Symbol.
*/
export function hasComputedNameButNotSymbol(declaration: Declaration): boolean {
export function hasDynamicName(declaration: Declaration): boolean {
return declaration.name && declaration.name.kind === SyntaxKind.ComputedPropertyName;
}
@@ -96,7 +97,7 @@ module ts {
if (node.kind === SyntaxKind.ModuleDeclaration && node.name.kind === SyntaxKind.StringLiteral) {
return '"' + (<LiteralExpression>node.name).text + '"';
}
Debug.assert(!hasComputedNameButNotSymbol(node));
Debug.assert(!hasDynamicName(node));
return (<Identifier | LiteralExpression>node.name).text;
}
switch (node.kind) {
@@ -118,11 +119,7 @@ module ts {
}
function declareSymbol(symbols: SymbolTable, parent: Symbol, node: Declaration, includes: SymbolFlags, excludes: SymbolFlags): Symbol {
// Nodes with computed property names will not get symbols, because the type checker
// does not make properties for them.
if (hasComputedNameButNotSymbol(node)) {
return undefined;
}
Debug.assert(!hasDynamicName(node));
var name = getDeclarationName(node);
if (name !== undefined) {
@@ -395,14 +392,14 @@ module ts {
break;
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.PropertySignature:
bindDeclaration(<Declaration>node, SymbolFlags.Property | ((<PropertyDeclaration>node).questionToken ? SymbolFlags.Optional : 0), SymbolFlags.PropertyExcludes, /*isBlockScopeContainer*/ false);
bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.Property | ((<PropertyDeclaration>node).questionToken ? SymbolFlags.Optional : 0), SymbolFlags.PropertyExcludes, /*isBlockScopeContainer*/ false);
break;
case SyntaxKind.PropertyAssignment:
case SyntaxKind.ShorthandPropertyAssignment:
bindDeclaration(<Declaration>node, SymbolFlags.Property, SymbolFlags.PropertyExcludes, /*isBlockScopeContainer*/ false);
bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.Property, SymbolFlags.PropertyExcludes, /*isBlockScopeContainer*/ false);
break;
case SyntaxKind.EnumMember:
bindDeclaration(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes, /*isBlockScopeContainer*/ false);
bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.EnumMember, SymbolFlags.EnumMemberExcludes, /*isBlockScopeContainer*/ false);
break;
case SyntaxKind.CallSignature:
case SyntaxKind.ConstructSignature:
@@ -415,7 +412,7 @@ module ts {
// as other properties in the object literal. So we use SymbolFlags.PropertyExcludes
// so that it will conflict with any other object literal members with the same
// name.
bindDeclaration(<Declaration>node, SymbolFlags.Method | ((<MethodDeclaration>node).questionToken ? SymbolFlags.Optional : 0),
bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.Method | ((<MethodDeclaration>node).questionToken ? SymbolFlags.Optional : 0),
isObjectLiteralMethod(node) ? SymbolFlags.PropertyExcludes : SymbolFlags.MethodExcludes, /*isBlockScopeContainer*/ true);
break;
case SyntaxKind.FunctionDeclaration:
@@ -425,10 +422,10 @@ module ts {
bindDeclaration(<Declaration>node, SymbolFlags.Constructor, /*symbolExcludes:*/ 0, /*isBlockScopeContainer:*/ true);
break;
case SyntaxKind.GetAccessor:
bindDeclaration(<Declaration>node, SymbolFlags.GetAccessor, SymbolFlags.GetAccessorExcludes, /*isBlockScopeContainer*/ true);
bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.GetAccessor, SymbolFlags.GetAccessorExcludes, /*isBlockScopeContainer*/ true);
break;
case SyntaxKind.SetAccessor:
bindDeclaration(<Declaration>node, SymbolFlags.SetAccessor, SymbolFlags.SetAccessorExcludes, /*isBlockScopeContainer*/ true);
bindPropertyOrMethodOrAccessor(<Declaration>node, SymbolFlags.SetAccessor, SymbolFlags.SetAccessorExcludes, /*isBlockScopeContainer*/ true);
break;
case SyntaxKind.FunctionType:
@@ -510,5 +507,14 @@ module ts {
declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, SymbolFlags.Property, SymbolFlags.PropertyExcludes);
}
}
function bindPropertyOrMethodOrAccessor(node: Declaration, symbolKind: SymbolFlags, symbolExcludes: SymbolFlags, isBlockScopeContainer: boolean) {
if (hasDynamicName(node)) {
bindAnonymousDeclaration(node, symbolKind, "__computed", isBlockScopeContainer);
}
else {
bindDeclaration(node, symbolKind, symbolExcludes, isBlockScopeContainer);
}
}
}
}
src/compiler/checker.ts
+301 -187
View File
@@ -66,8 +66,8 @@ module ts {
var numberType = createIntrinsicType(TypeFlags.Number, "number");
var booleanType = createIntrinsicType(TypeFlags.Boolean, "boolean");
var voidType = createIntrinsicType(TypeFlags.Void, "void");
var undefinedType = createIntrinsicType(TypeFlags.Undefined | TypeFlags.Unwidened, "undefined");
var nullType = createIntrinsicType(TypeFlags.Null | TypeFlags.Unwidened, "null");
var undefinedType = createIntrinsicType(TypeFlags.Undefined | TypeFlags.ContainsUndefinedOrNull, "undefined");
var nullType = createIntrinsicType(TypeFlags.Null | TypeFlags.ContainsUndefinedOrNull, "null");
var unknownType = createIntrinsicType(TypeFlags.Any, "unknown");
var resolvingType = createIntrinsicType(TypeFlags.Any, "__resolving__");
@@ -107,6 +107,21 @@ module ts {
var diagnostics: Diagnostic[] = [];
var diagnosticsModified: boolean = false;
var primitiveTypeInfo: Map<{ type: Type; flags: TypeFlags }> = {
"string": {
type: stringType,
flags: TypeFlags.StringLike
},
"number": {
type: numberType,
flags: TypeFlags.NumberLike
},
"boolean": {
type: booleanType,
flags: TypeFlags.Boolean
}
};
function addDiagnostic(diagnostic: Diagnostic) {
diagnostics.push(diagnostic);
diagnosticsModified = true;
@@ -337,6 +352,25 @@ module ts {
break loop;
}
break;
// It is not legal to reference a class's own type parameters from a computed property name that
// belongs to the class. For example:
//
// function foo<T>() { return '' }
// class C<T> { // <-- Class's own type parameter T
// [foo<T>()]() { } // <-- Reference to T from class's own computed property
// }
//
case SyntaxKind.ComputedPropertyName:
var grandparent = location.parent.parent;
if (grandparent.kind === SyntaxKind.ClassDeclaration || grandparent.kind === SyntaxKind.InterfaceDeclaration) {
// A reference to this grandparent's type parameters would be an error
if (result = getSymbol(getSymbolOfNode(grandparent).members, name, meaning & SymbolFlags.Type)) {
error(errorLocation, Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type);
return undefined;
}
}
break;
case SyntaxKind.MethodDeclaration:
case SyntaxKind.MethodSignature:
case SyntaxKind.Constructor:
@@ -1660,7 +1694,7 @@ module ts {
// Use type of the specified property, or otherwise, for a numeric name, the type of the numeric index signature,
// or otherwise the type of the string index signature.
var type = getTypeOfPropertyOfType(parentType, name.text) ||
isNumericName(name.text) && getIndexTypeOfType(parentType, IndexKind.Number) ||
isNumericLiteralName(name.text) && getIndexTypeOfType(parentType, IndexKind.Number) ||
getIndexTypeOfType(parentType, IndexKind.String);
if (!type) {
error(name, Diagnostics.Type_0_has_no_property_1_and_no_string_index_signature, typeToString(parentType), declarationNameToString(name));
@@ -1706,7 +1740,7 @@ module ts {
if (declaration.kind === SyntaxKind.Parameter) {
var func = <FunctionLikeDeclaration>declaration.parent;
// For a parameter of a set accessor, use the type of the get accessor if one is present
if (func.kind === SyntaxKind.SetAccessor && !hasComputedNameButNotSymbol(func)) {
if (func.kind === SyntaxKind.SetAccessor && !hasDynamicName(func)) {
var getter = <AccessorDeclaration>getDeclarationOfKind(declaration.parent.symbol, SyntaxKind.GetAccessor);
if (getter) {
return getReturnTypeOfSignature(getSignatureFromDeclaration(getter));
@@ -2622,7 +2656,7 @@ module ts {
else {
// TypeScript 1.0 spec (April 2014):
// If only one accessor includes a type annotation, the other behaves as if it had the same type annotation.
if (declaration.kind === SyntaxKind.GetAccessor && !hasComputedNameButNotSymbol(declaration)) {
if (declaration.kind === SyntaxKind.GetAccessor && !hasDynamicName(declaration)) {
var setter = <AccessorDeclaration>getDeclarationOfKind(declaration.symbol, SyntaxKind.SetAccessor);
returnType = getAnnotatedAccessorType(setter);
}
@@ -2807,15 +2841,22 @@ module ts {
}
}
function getUnwidenedFlagOfTypes(types: Type[]): TypeFlags {
return forEach(types, t => t.flags & TypeFlags.Unwidened) || 0;
// This function is used to propagate widening flags when creating new object types references and union types.
// It is only necessary to do so if a constituent type might be the undefined type, the null type, or the type
// of an object literal (since those types have widening related information we need to track).
function getWideningFlagsOfTypes(types: Type[]): TypeFlags {
var result: TypeFlags = 0;
for (var i = 0; i < types.length; i++) {
result |= types[i].flags;
}
return result & TypeFlags.RequiresWidening;
}
function createTypeReference(target: GenericType, typeArguments: Type[]): TypeReference {
var id = getTypeListId(typeArguments);
var type = target.instantiations[id];
if (!type) {
var flags = TypeFlags.Reference | getUnwidenedFlagOfTypes(typeArguments);
var flags = TypeFlags.Reference | getWideningFlagsOfTypes(typeArguments);
type = target.instantiations[id] = <TypeReference>createObjectType(flags, target.symbol);
type.target = target;
type.typeArguments = typeArguments;
@@ -3076,7 +3117,7 @@ module ts {
var id = getTypeListId(sortedTypes);
var type = unionTypes[id];
if (!type) {
type = unionTypes[id] = <UnionType>createObjectType(TypeFlags.Union | getUnwidenedFlagOfTypes(sortedTypes));
type = unionTypes[id] = <UnionType>createObjectType(TypeFlags.Union | getWideningFlagsOfTypes(sortedTypes));
type.types = sortedTypes;
}
return type;
@@ -3692,12 +3733,13 @@ module ts {
}
var result = Ternary.True;
var properties = getPropertiesOfObjectType(target);
var requireOptionalProperties = relation === subtypeRelation && !(source.flags & TypeFlags.ObjectLiteral);
for (var i = 0; i < properties.length; i++) {
var targetProp = properties[i];
var sourceProp = getPropertyOfType(source, targetProp.name);
if (sourceProp !== targetProp) {
if (!sourceProp) {
if (relation === subtypeRelation || !(targetProp.flags & SymbolFlags.Optional)) {
if (!(targetProp.flags & SymbolFlags.Optional) || requireOptionalProperties) {
if (reportErrors) {
reportError(Diagnostics.Property_0_is_missing_in_type_1, symbolToString(targetProp), typeToString(source));
}
@@ -4088,10 +4130,6 @@ module ts {
errorMessageChainHead);
}
function isTypeOfObjectLiteral(type: Type): boolean {
return (type.flags & TypeFlags.Anonymous) && type.symbol && (type.symbol.flags & SymbolFlags.ObjectLiteral) ? true : false;
}
function isArrayType(type: Type): boolean {
return type.flags & TypeFlags.Reference && (<TypeReference>type).target === globalArrayType;
}
@@ -4104,13 +4142,18 @@ module ts {
var properties = getPropertiesOfObjectType(type);
var members: SymbolTable = {};
forEach(properties, p => {
var symbol = <TransientSymbol>createSymbol(p.flags | SymbolFlags.Transient, p.name);
symbol.declarations = p.declarations;
symbol.parent = p.parent;
symbol.type = getWidenedType(getTypeOfSymbol(p));
symbol.target = p;
if (p.valueDeclaration) symbol.valueDeclaration = p.valueDeclaration;
members[symbol.name] = symbol;
var propType = getTypeOfSymbol(p);
var widenedType = getWidenedType(propType);
if (propType !== widenedType) {
var symbol = <TransientSymbol>createSymbol(p.flags | SymbolFlags.Transient, p.name);
symbol.declarations = p.declarations;
symbol.parent = p.parent;
symbol.type = widenedType;
symbol.target = p;
if (p.valueDeclaration) symbol.valueDeclaration = p.valueDeclaration;
p = symbol;
}
members[p.name] = p;
});
var stringIndexType = getIndexTypeOfType(type, IndexKind.String);
var numberIndexType = getIndexTypeOfType(type, IndexKind.Number);
@@ -4120,16 +4163,16 @@ module ts {
}
function getWidenedType(type: Type): Type {
if (type.flags & TypeFlags.Unwidened) {
if (type.flags & TypeFlags.RequiresWidening) {
if (type.flags & (TypeFlags.Undefined | TypeFlags.Null)) {
return anyType;
}
if (type.flags & TypeFlags.ObjectLiteral) {
return getWidenedTypeOfObjectLiteral(type);
}
if (type.flags & TypeFlags.Union) {
return getUnionType(map((<UnionType>type).types, getWidenedType));
}
if (isTypeOfObjectLiteral(type)) {
return getWidenedTypeOfObjectLiteral(type);
}
if (isArrayType(type)) {
return createArrayType(getWidenedType((<TypeReference>type).typeArguments[0]));
}
@@ -4150,11 +4193,11 @@ module ts {
if (isArrayType(type)) {
return reportWideningErrorsInType((<TypeReference>type).typeArguments[0]);
}
if (isTypeOfObjectLiteral(type)) {
if (type.flags & TypeFlags.ObjectLiteral) {
var errorReported = false;
forEach(getPropertiesOfObjectType(type), p => {
var t = getTypeOfSymbol(p);
if (t.flags & TypeFlags.Unwidened) {
if (t.flags & TypeFlags.ContainsUndefinedOrNull) {
if (!reportWideningErrorsInType(t)) {
error(p.valueDeclaration, Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, p.name, typeToString(getWidenedType(t)));
}
@@ -4198,7 +4241,7 @@ module ts {
}
function reportErrorsFromWidening(declaration: Declaration, type: Type) {
if (produceDiagnostics && compilerOptions.noImplicitAny && type.flags & TypeFlags.Unwidened) {
if (produceDiagnostics && compilerOptions.noImplicitAny && type.flags & TypeFlags.ContainsUndefinedOrNull) {
// Report implicit any error within type if possible, otherwise report error on declaration
if (!reportWideningErrorsInType(type)) {
reportImplicitAnyError(declaration, type);
@@ -4454,12 +4497,17 @@ module ts {
Debug.fail("should not get here");
}
// Remove one or more primitive types from a union type
function subtractPrimitiveTypes(type: Type, subtractMask: TypeFlags): Type {
// For a union type, remove all constituent types that are of the given type kind (when isOfTypeKind is true)
// or not of the given type kind (when isOfTypeKind is false)
function removeTypesFromUnionType(type: Type, typeKind: TypeFlags, isOfTypeKind: boolean): Type {
if (type.flags & TypeFlags.Union) {
var types = (<UnionType>type).types;
if (forEach(types, t => t.flags & subtractMask)) {
return getUnionType(filter(types, t => !(t.flags & subtractMask)));
if (forEach(types, t => !!(t.flags & typeKind) === isOfTypeKind)) {
// Above we checked if we have anything to remove, now use the opposite test to do the removal
var narrowedType = getUnionType(filter(types, t => !(t.flags & typeKind) === isOfTypeKind));
if (narrowedType !== emptyObjectType) {
return narrowedType;
}
}
}
return type;
@@ -4635,8 +4683,8 @@ module ts {
// Stop at the first containing function or module declaration
break loop;
}
// Use narrowed type if it is a subtype and construct contains no assignments to variable
if (narrowedType !== type && isTypeSubtypeOf(narrowedType, type)) {
// Use narrowed type if construct contains no assignments to variable
if (narrowedType !== type) {
if (isVariableAssignedWithin(symbol, node)) {
break;
}
@@ -4656,20 +4704,30 @@ module ts {
if (left.expression.kind !== SyntaxKind.Identifier || getResolvedSymbol(<Identifier>left.expression) !== symbol) {
return type;
}
var t = right.text;
var checkType: Type = t === "string" ? stringType : t === "number" ? numberType : t === "boolean" ? booleanType : emptyObjectType;
var typeInfo = primitiveTypeInfo[right.text];
if (expr.operator === SyntaxKind.ExclamationEqualsEqualsToken) {
assumeTrue = !assumeTrue;
}
if (assumeTrue) {
// The assumed result is true. If check was for a primitive type, that type is the narrowed type. Otherwise we can
// remove the primitive types from the narrowed type.
return checkType === emptyObjectType ? subtractPrimitiveTypes(type, TypeFlags.String | TypeFlags.Number | TypeFlags.Boolean) : checkType;
// Assumed result is true. If check was not for a primitive type, remove all primitive types
if (!typeInfo) {
return removeTypesFromUnionType(type, /*typeKind*/ TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.Boolean, /*isOfTypeKind*/ true);
}
// Check was for a primitive type, return that primitive type if it is a subtype
if (isTypeSubtypeOf(typeInfo.type, type)) {
return typeInfo.type;
}
// Otherwise, remove all types that aren't of the primitive type kind. This can happen when the type is
// union of enum types and other types.
return removeTypesFromUnionType(type, /*typeKind*/ typeInfo.flags, /*isOfTypeKind*/ false);
}
else {
// The assumed result is false. If check was for a primitive type we can remove that type from the narrowed type.
// Assumed result is false. If check was for a primitive type, remove that primitive type
if (typeInfo) {
return removeTypesFromUnionType(type, /*typeKind*/ typeInfo.flags, /*isOfTypeKind*/ true);
}
// Otherwise we don't have enough information to do anything.
return checkType === emptyObjectType ? type : subtractPrimitiveTypes(type, checkType.flags);
return type;
}
}
@@ -4730,7 +4788,8 @@ module ts {
return type;
}
// Narrow the given type based on the given expression having the assumed boolean value
// Narrow the given type based on the given expression having the assumed boolean value. The returned type
// will be a subtype or the same type as the argument.
function narrowType(type: Type, expr: Expression, assumeTrue: boolean): Type {
switch (expr.kind) {
case SyntaxKind.ParenthesizedExpression:
@@ -4759,6 +4818,7 @@ module ts {
return type;
}
}
/*Transitively mark all linked imports as referenced*/
function markLinkedImportsAsReferenced(node: ImportDeclaration): void {
var nodeLinks = getNodeLinks(node);
@@ -4855,6 +4915,9 @@ module ts {
// do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks
}
break;
case SyntaxKind.ComputedPropertyName:
error(node, Diagnostics.this_cannot_be_referenced_in_a_computed_property_name);
break;
}
if (needToCaptureLexicalThis) {
@@ -4869,26 +4932,6 @@ module ts {
return anyType;
}
function getSuperContainer(node: Node): Node {
while (true) {
node = node.parent;
if (!node) return node;
switch (node.kind) {
case SyntaxKind.FunctionDeclaration:
case SyntaxKind.FunctionExpression:
case SyntaxKind.ArrowFunction:
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.PropertySignature:
case SyntaxKind.MethodDeclaration:
case SyntaxKind.MethodSignature:
case SyntaxKind.Constructor:
case SyntaxKind.GetAccessor:
case SyntaxKind.SetAccessor:
return node;
}
}
}
function isInConstructorArgumentInitializer(node: Node, constructorDecl: Node): boolean {
for (var n = node; n && n !== constructorDecl; n = n.parent) {
if (n.kind === SyntaxKind.Parameter) {
@@ -4912,7 +4955,7 @@ module ts {
return unknownType;
}
var container = getSuperContainer(node);
var container = getSuperContainer(node, /*includeFunctions*/ true);
if (container) {
var canUseSuperExpression = false;
@@ -4930,7 +4973,7 @@ module ts {
// super property access might appear in arrow functions with arbitrary deep nesting
var needToCaptureLexicalThis = false;
while (container && container.kind === SyntaxKind.ArrowFunction) {
container = getSuperContainer(container);
container = getSuperContainer(container, /*includeFunctions*/ true);
needToCaptureLexicalThis = true;
}
@@ -4985,7 +5028,10 @@ module ts {
}
}
if (isCallExpression) {
if (container.kind === SyntaxKind.ComputedPropertyName) {
error(node, Diagnostics.super_cannot_be_referenced_in_a_computed_property_name);
}
else if (isCallExpression) {
error(node, Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors);
}
else {
@@ -5167,13 +5213,22 @@ module ts {
function getContextualTypeForObjectLiteralElement(element: ObjectLiteralElement) {
var objectLiteral = <ObjectLiteralExpression>element.parent;
var type = getContextualType(objectLiteral);
// TODO(jfreeman): Handle this case for computed names and symbols
var name = (<Identifier>element.name).text;
if (type && name) {
return getTypeOfPropertyOfContextualType(type, name) ||
isNumericName(name) && getIndexTypeOfContextualType(type, IndexKind.Number) ||
if (type) {
if (!hasDynamicName(element)) {
// For a (non-symbol) computed property, there is no reason to look up the name
// in the type. It will just be "__computed", which does not appear in any
// SymbolTable.
var symbolName = getSymbolOfNode(element).name;
var propertyType = getTypeOfPropertyOfContextualType(type, symbolName);
if (propertyType) {
return propertyType;
}
}
return isNumericName(element.name) && getIndexTypeOfContextualType(type, IndexKind.Number) ||
getIndexTypeOfContextualType(type, IndexKind.String);
}
return undefined;
}
@@ -5372,7 +5427,17 @@ module ts {
return createArrayType(getUnionType(elementTypes));
}
function isNumericName(name: string) {
function isNumericName(name: DeclarationName): boolean {
return name.kind === SyntaxKind.ComputedPropertyName ? isNumericComputedName(<ComputedPropertyName>name) : isNumericLiteralName((<Identifier>name).text);
}
function isNumericComputedName(name: ComputedPropertyName): boolean {
// It seems odd to consider an expression of type Any to result in a numeric name,
// but this behavior is consistent with checkIndexedAccess
return isTypeOfKind(checkComputedPropertyName(name), TypeFlags.Any | TypeFlags.NumberLike);
}
function isNumericLiteralName(name: string) {
// The intent of numeric names is that
// - they are names with text in a numeric form, and that
// - setting properties/indexing with them is always equivalent to doing so with the numeric literal 'numLit',
@@ -5397,84 +5462,101 @@ module ts {
return (+name).toString() === name;
}
function checkComputedPropertyName(node: ComputedPropertyName): Type {
var links = getNodeLinks(node.expression);
if (!links.resolvedType) {
links.resolvedType = checkExpression(node.expression);
// This will allow types number, string, or any. It will also allow enums, the unknown
// type, and any union of these types (like string | number).
if (!isTypeOfKind(links.resolvedType, TypeFlags.Any | TypeFlags.NumberLike | TypeFlags.StringLike)) {
error(node, Diagnostics.A_computed_property_name_must_be_of_type_string_number_or_any);
}
}
return links.resolvedType;
}
function checkObjectLiteral(node: ObjectLiteralExpression, contextualMapper?: TypeMapper): Type {
// Grammar checking
checkGrammarObjectLiteralExpression(node);
var members = node.symbol.members;
var properties: SymbolTable = {};
var propertiesTable: SymbolTable = {};
var propertiesArray: Symbol[] = [];
var contextualType = getContextualType(node);
var typeFlags: TypeFlags;
for (var id in members) {
if (hasProperty(members, id)) {
var member = members[id];
if (member.flags & SymbolFlags.Property || isObjectLiteralMethod(member.declarations[0])) {
var memberDecl = <ObjectLiteralElement>member.declarations[0];
if (memberDecl.kind === SyntaxKind.PropertyAssignment) {
var type = checkExpression((<PropertyAssignment>memberDecl).initializer, contextualMapper);
}
else if (memberDecl.kind === SyntaxKind.MethodDeclaration) {
var type = checkObjectLiteralMethod(<MethodDeclaration>memberDecl, contextualMapper);
}
else {
Debug.assert(memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment);
var type = memberDecl.name.kind === SyntaxKind.ComputedPropertyName
? unknownType
: checkExpression(<Identifier>memberDecl.name, contextualMapper);
}
typeFlags |= type.flags;
var prop = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.name);
prop.declarations = member.declarations;
prop.parent = member.parent;
if (member.valueDeclaration) {
prop.valueDeclaration = member.valueDeclaration;
}
prop.type = type;
prop.target = member;
member = prop;
for (var i = 0; i < node.properties.length; i++) {
var memberDecl = node.properties[i];
var member = memberDecl.symbol;
if (memberDecl.kind === SyntaxKind.PropertyAssignment ||
memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment ||
isObjectLiteralMethod(memberDecl)) {
if (memberDecl.kind === SyntaxKind.PropertyAssignment) {
var type = checkPropertyAssignment(<PropertyAssignment>memberDecl, contextualMapper);
}
else if (memberDecl.kind === SyntaxKind.MethodDeclaration) {
var type = checkObjectLiteralMethod(<MethodDeclaration>memberDecl, contextualMapper);
}
else {
// TypeScript 1.0 spec (April 2014)
// A get accessor declaration is processed in the same manner as
// an ordinary function declaration(section 6.1) with no parameters.
// A set accessor declaration is processed in the same manner
// as an ordinary function declaration with a single parameter and a Void return type.
var getAccessor = <AccessorDeclaration>getDeclarationOfKind(member, SyntaxKind.GetAccessor);
if (getAccessor) {
checkAccessorDeclaration(getAccessor);
}
var setAccessor = <AccessorDeclaration>getDeclarationOfKind(member, SyntaxKind.SetAccessor);
if (setAccessor) {
checkAccessorDeclaration(setAccessor);
}
Debug.assert(memberDecl.kind === SyntaxKind.ShorthandPropertyAssignment);
var type = memberDecl.name.kind === SyntaxKind.ComputedPropertyName
? unknownType
: checkExpression(<Identifier>memberDecl.name, contextualMapper);
}
properties[member.name] = member;
typeFlags |= type.flags;
var prop = <TransientSymbol>createSymbol(SymbolFlags.Property | SymbolFlags.Transient | member.flags, member.name);
prop.declarations = member.declarations;
prop.parent = member.parent;
if (member.valueDeclaration) {
prop.valueDeclaration = member.valueDeclaration;
}
prop.type = type;
prop.target = member;
member = prop;
}
else {
// TypeScript 1.0 spec (April 2014)
// A get accessor declaration is processed in the same manner as
// an ordinary function declaration(section 6.1) with no parameters.
// A set accessor declaration is processed in the same manner
// as an ordinary function declaration with a single parameter and a Void return type.
Debug.assert(memberDecl.kind === SyntaxKind.GetAccessor || memberDecl.kind === SyntaxKind.SetAccessor);
checkAccessorDeclaration(<AccessorDeclaration>memberDecl);
}
if (!hasDynamicName(memberDecl)) {
propertiesTable[member.name] = member;
}
propertiesArray.push(member);
}
var stringIndexType = getIndexType(IndexKind.String);
var numberIndexType = getIndexType(IndexKind.Number);
var result = createAnonymousType(node.symbol, properties, emptyArray, emptyArray, stringIndexType, numberIndexType);
result.flags |= (typeFlags & TypeFlags.Unwidened);
var result = createAnonymousType(node.symbol, propertiesTable, emptyArray, emptyArray, stringIndexType, numberIndexType);
result.flags |= TypeFlags.ObjectLiteral | TypeFlags.ContainsObjectLiteral | (typeFlags & TypeFlags.ContainsUndefinedOrNull);
return result;
function getIndexType(kind: IndexKind) {
if (contextualType && contextualTypeHasIndexSignature(contextualType, kind)) {
var propTypes: Type[] = [];
for (var id in properties) {
if (hasProperty(properties, id)) {
if (kind === IndexKind.String || isNumericName(id)) {
var type = getTypeOfSymbol(properties[id]);
if (!contains(propTypes, type)) {
propTypes.push(type);
}
for (var i = 0; i < propertiesArray.length; i++) {
var propertyDecl = node.properties[i];
if (kind === IndexKind.String || isNumericName(propertyDecl.name)) {
// Do not call getSymbolOfNode(propertyDecl), as that will get the
// original symbol for the node. We actually want to get the symbol
// created by checkObjectLiteral, since that will be appropriately
// contextually typed and resolved.
var type = getTypeOfSymbol(propertiesArray[i]);
if (!contains(propTypes, type)) {
propTypes.push(type);
}
}
}
return propTypes.length ? getUnionType(propTypes) : undefinedType;
var result = propTypes.length ? getUnionType(propTypes) : undefinedType;
typeFlags |= result.flags;
return result;
}
return undefined;
}
@@ -6738,7 +6820,7 @@ module ts {
// and the right operand to be of type Any or a subtype of the 'Function' interface type.
// The result is always of the Boolean primitive type.
// NOTE: do not raise error if leftType is unknown as related error was already reported
if (!isTypeOfKind(leftType, TypeFlags.Any | TypeFlags.ObjectType | TypeFlags.TypeParameter)) {
if (isTypeOfKind(leftType, TypeFlags.Primitive)) {
error(node.left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
}
// NOTE: do not raise error if right is unknown as related error was already reported
@@ -6771,7 +6853,7 @@ module ts {
var name = <Identifier>(<PropertyAssignment>p).name;
var type = sourceType.flags & TypeFlags.Any ? sourceType :
getTypeOfPropertyOfType(sourceType, name.text) ||
isNumericName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) ||
isNumericLiteralName(name.text) && getIndexTypeOfType(sourceType, IndexKind.Number) ||
getIndexTypeOfType(sourceType, IndexKind.String);
if (type) {
checkDestructuringAssignment((<PropertyAssignment>p).initializer || name, type);
@@ -7052,10 +7134,22 @@ module ts {
return links.resolvedType;
}
function checkPropertyAssignment(node: PropertyAssignment, contextualMapper?: TypeMapper): Type {
if (hasDynamicName(node)) {
checkComputedPropertyName(<ComputedPropertyName>node.name);
}
return checkExpression((<PropertyAssignment>node).initializer, contextualMapper);
}
function checkObjectLiteralMethod(node: MethodDeclaration, contextualMapper?: TypeMapper): Type {
// Grammar checking
checkGrammarMethod(node);
if (hasDynamicName(node)) {
checkComputedPropertyName(<ComputedPropertyName>node.name);
}
var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, contextualMapper);
return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, contextualMapper);
}
@@ -7426,7 +7520,7 @@ module ts {
}
}
if (!hasComputedNameButNotSymbol(node)) {
if (!hasDynamicName(node)) {
// TypeScript 1.0 spec (April 2014): 8.4.3
// Accessors for the same member name must specify the same accessibility.
var otherKind = node.kind === SyntaxKind.GetAccessor ? SyntaxKind.SetAccessor : SyntaxKind.GetAccessor;
@@ -7446,9 +7540,9 @@ module ts {
}
}
}
checkAndStoreTypeOfAccessors(getSymbolOfNode(node));
}
checkAndStoreTypeOfAccessors(getSymbolOfNode(node));
}
checkFunctionLikeDeclaration(node);
@@ -7864,7 +7958,12 @@ module ts {
function checkFunctionLikeDeclaration(node: FunctionLikeDeclaration): void {
checkSignatureDeclaration(node);
if (!hasComputedNameButNotSymbol(node)) {
if (hasDynamicName(node)) {
// This check will account for methods in class/interface declarations,
// as well as accessors in classes/object literals
checkComputedPropertyName(<ComputedPropertyName>node.name);
}
else {
// first we want to check the local symbol that contain this declaration
// - if node.localSymbol !== undefined - this is current declaration is exported and localSymbol points to the local symbol
// - if node.localSymbol === undefined - this node is non-exported so we can just pick the result of getSymbolOfNode
@@ -8093,7 +8192,8 @@ module ts {
function checkVariableLikeDeclaration(node: VariableLikeDeclaration) {
checkSourceElement(node.type);
// For a computed property, just check the initializer and exit
if (hasComputedNameButNotSymbol(node)) {
if (hasDynamicName(node)) {
checkComputedPropertyName(<ComputedPropertyName>node.name);
if (node.initializer) {
checkExpressionCached(node.initializer);
}
@@ -8436,45 +8536,7 @@ module ts {
if (node.finallyBlock) checkBlock(node.finallyBlock);
}
function checkIndexConstraints(type: Type) {
function checkIndexConstraintForProperty(prop: Symbol, propertyType: Type, indexDeclaration: Declaration, indexType: Type, indexKind: IndexKind): void {
if (!indexType) {
return;
}
// index is numeric and property name is not valid numeric literal
if (indexKind === IndexKind.Number && !isNumericName(prop.name)) {
return;
}
// perform property check if property or indexer is declared in 'type'
// this allows to rule out cases when both property and indexer are inherited from the base class
var errorNode: Node;
if (prop.parent === type.symbol) {
errorNode = prop.valueDeclaration;
}
else if (indexDeclaration) {
errorNode = indexDeclaration;
}
else if (type.flags & TypeFlags.Interface) {
// for interfaces property and indexer might be inherited from different bases
// check if any base class already has both property and indexer.
// check should be performed only if 'type' is the first type that brings property\indexer together
var someBaseClassHasBothPropertyAndIndexer = forEach((<InterfaceType>type).baseTypes, base => getPropertyOfObjectType(base, prop.name) && getIndexTypeOfType(base, indexKind));
errorNode = someBaseClassHasBothPropertyAndIndexer ? undefined : type.symbol.declarations[0];
}
if (errorNode && !isTypeAssignableTo(propertyType, indexType)) {
var errorMessage =
indexKind === IndexKind.String
? Diagnostics.Property_0_of_type_1_is_not_assignable_to_string_index_type_2
: Diagnostics.Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2;
error(errorNode, errorMessage, symbolToString(prop), typeToString(propertyType), typeToString(indexType));
}
}
function checkIndexConstraints(type: Type) {
var declaredNumberIndexer = getIndexDeclarationOfSymbol(type.symbol, IndexKind.Number);
var declaredStringIndexer = getIndexDeclarationOfSymbol(type.symbol, IndexKind.String);
@@ -8484,9 +8546,24 @@ module ts {
if (stringIndexType || numberIndexType) {
forEach(getPropertiesOfObjectType(type), prop => {
var propType = getTypeOfSymbol(prop);
checkIndexConstraintForProperty(prop, propType, declaredStringIndexer, stringIndexType, IndexKind.String);
checkIndexConstraintForProperty(prop, propType, declaredNumberIndexer, numberIndexType, IndexKind.Number);
checkIndexConstraintForProperty(prop, propType, type, declaredStringIndexer, stringIndexType, IndexKind.String);
checkIndexConstraintForProperty(prop, propType, type, declaredNumberIndexer, numberIndexType, IndexKind.Number);
});
if (type.flags & TypeFlags.Class && type.symbol.valueDeclaration.kind === SyntaxKind.ClassDeclaration) {
var classDeclaration = <ClassDeclaration>type.symbol.valueDeclaration;
for (var i = 0; i < classDeclaration.members.length; i++) {
var member = classDeclaration.members[i];
// Only process instance properties with computed names here.
// Static properties cannot be in conflict with indexers,
// and properties with literal names were already checked.
if (!(member.flags & NodeFlags.Static) && hasDynamicName(member)) {
var propType = getTypeOfSymbol(member.symbol);
checkIndexConstraintForProperty(member.symbol, propType, type, declaredStringIndexer, stringIndexType, IndexKind.String);
checkIndexConstraintForProperty(member.symbol, propType, type, declaredNumberIndexer, numberIndexType, IndexKind.Number);
}
}
}
}
var errorNode: Node;
@@ -8503,9 +8580,51 @@ module ts {
error(errorNode, Diagnostics.Numeric_index_type_0_is_not_assignable_to_string_index_type_1,
typeToString(numberIndexType), typeToString(stringIndexType));
}
function checkIndexConstraintForProperty(
prop: Symbol,
propertyType: Type,
containingType: Type,
indexDeclaration: Declaration,
indexType: Type,
indexKind: IndexKind): void {
if (!indexType) {
return;
}
// index is numeric and property name is not valid numeric literal
if (indexKind === IndexKind.Number && !isNumericName(prop.valueDeclaration.name)) {
return;
}
// perform property check if property or indexer is declared in 'type'
// this allows to rule out cases when both property and indexer are inherited from the base class
var errorNode: Node;
if (prop.valueDeclaration.name.kind === SyntaxKind.ComputedPropertyName || prop.parent === containingType.symbol) {
errorNode = prop.valueDeclaration;
}
else if (indexDeclaration) {
errorNode = indexDeclaration;
}
else if (containingType.flags & TypeFlags.Interface) {
// for interfaces property and indexer might be inherited from different bases
// check if any base class already has both property and indexer.
// check should be performed only if 'type' is the first type that brings property\indexer together
var someBaseClassHasBothPropertyAndIndexer = forEach((<InterfaceType>containingType).baseTypes, base => getPropertyOfObjectType(base, prop.name) && getIndexTypeOfType(base, indexKind));
errorNode = someBaseClassHasBothPropertyAndIndexer ? undefined : containingType.symbol.declarations[0];
}
if (errorNode && !isTypeAssignableTo(propertyType, indexType)) {
var errorMessage =
indexKind === IndexKind.String
? Diagnostics.Property_0_of_type_1_is_not_assignable_to_string_index_type_2
: Diagnostics.Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2;
error(errorNode, errorMessage, symbolToString(prop), typeToString(propertyType), typeToString(indexType));
}
}
}
// TODO(jfreeman): Decide what to do for computed properties
function checkTypeNameIsReserved(name: DeclarationName, message: DiagnosticMessage): void {
// TS 1.0 spec (April 2014): 3.6.1
// The predefined type keywords are reserved and cannot be used as names of user defined types.
@@ -8799,8 +8918,7 @@ module ts {
var enumIsConst = isConst(node);
forEach(node.members, member => {
// TODO(jfreeman): Check that it is not a computed name
if(isNumericName((<Identifier>member.name).text)) {
if (member.name.kind !== SyntaxKind.ComputedPropertyName && isNumericLiteralName((<Identifier>member.name).text)) {
error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
}
var initializer = member.initializer;
@@ -9990,8 +10108,8 @@ module ts {
if (symbol && (symbol.flags & SymbolFlags.EnumMember)) {
var declaration = symbol.valueDeclaration;
var constantValue: number;
if (declaration.kind === SyntaxKind.EnumMember && (constantValue = getNodeLinks(declaration).enumMemberValue) !== undefined) {
return constantValue;
if (declaration.kind === SyntaxKind.EnumMember) {
return getEnumMemberValue(<EnumMember>declaration);
}
}
@@ -10427,22 +10545,18 @@ module ts {
return false;
}
function checkGrammarComputedPropertyName(node: Node): void {
function checkGrammarComputedPropertyName(node: Node): boolean {
// If node is not a computedPropertyName, just skip the grammar checking
if (node.kind !== SyntaxKind.ComputedPropertyName) {
return;
return false;
}
// Since computed properties are not supported in the type checker, disallow them in TypeScript 1.4
// Once full support is added, remove this error.
grammarErrorOnNode(node, Diagnostics.Computed_property_names_are_not_currently_supported);
return;
var computedPropertyName = <ComputedPropertyName>node;
if (languageVersion < ScriptTarget.ES6) {
grammarErrorOnNode(node, Diagnostics.Computed_property_names_are_only_available_when_targeting_ECMAScript_6_and_higher);
return grammarErrorOnNode(node, Diagnostics.Computed_property_names_are_only_available_when_targeting_ECMAScript_6_and_higher);
}
else if (computedPropertyName.expression.kind === SyntaxKind.BinaryExpression && (<BinaryExpression>computedPropertyName.expression).operator === SyntaxKind.CommaToken) {
grammarErrorOnNode(computedPropertyName.expression, Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name);
return grammarErrorOnNode(computedPropertyName.expression, Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name);
}
}
src/compiler/diagnosticInformationMap.generated.ts
+4 -1
View File
@@ -299,6 +299,10 @@ module ts {
Type_0_is_not_an_array_type: { code: 2461, category: DiagnosticCategory.Error, key: "Type '{0}' is not an array type." },
A_rest_element_must_be_last_in_an_array_destructuring_pattern: { code: 2462, category: DiagnosticCategory.Error, key: "A rest element must be last in an array destructuring pattern" },
A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: { code: 2463, category: DiagnosticCategory.Error, key: "A binding pattern parameter cannot be optional in an implementation signature." },
A_computed_property_name_must_be_of_type_string_number_or_any: { code: 2464, category: DiagnosticCategory.Error, key: "A computed property name must be of type 'string', 'number', or 'any'." },
this_cannot_be_referenced_in_a_computed_property_name: { code: 2465, category: DiagnosticCategory.Error, key: "'this' cannot be referenced in a computed property name." },
super_cannot_be_referenced_in_a_computed_property_name: { code: 2466, category: DiagnosticCategory.Error, key: "'super' cannot be referenced in a computed property name." },
A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: { code: 2466, category: DiagnosticCategory.Error, key: "A computed property name cannot reference a type parameter from its containing type." },
Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },
@@ -448,6 +452,5 @@ module ts {
You_cannot_rename_this_element: { code: 8000, category: DiagnosticCategory.Error, key: "You cannot rename this element." },
yield_expressions_are_not_currently_supported: { code: 9000, category: DiagnosticCategory.Error, key: "'yield' expressions are not currently supported.", isEarly: true },
Generators_are_not_currently_supported: { code: 9001, category: DiagnosticCategory.Error, key: "Generators are not currently supported.", isEarly: true },
Computed_property_names_are_not_currently_supported: { code: 9002, category: DiagnosticCategory.Error, key: "Computed property names are not currently supported.", isEarly: true },
};
}
src/compiler/diagnosticMessages.json
+18 -7
View File
@@ -675,7 +675,7 @@
},
"A parameter property may not be a binding pattern.": {
"category": "Error",
"code": 1187
"code": 1187
},
"Duplicate identifier '{0}'.": {
@@ -1288,7 +1288,23 @@
},
"A binding pattern parameter cannot be optional in an implementation signature.": {
"category": "Error",
"code": 2463
"code": 2463
},
"A computed property name must be of type 'string', 'number', or 'any'.": {
"category": "Error",
"code": 2464
},
"'this' cannot be referenced in a computed property name.": {
"category": "Error",
"code": 2465
},
"'super' cannot be referenced in a computed property name.": {
"category": "Error",
"code": 2466
},
"A computed property name cannot reference a type parameter from its containing type.": {
"category": "Error",
"code": 2466
},
"Import declaration '{0}' is using private name '{1}'.": {
@@ -1892,10 +1908,5 @@
"category": "Error",
"code": 9001,
"isEarly": true
},
"Computed property names are not currently supported.": {
"category": "Error",
"code": 9002,
"isEarly": true
}
}
src/compiler/emitter.ts
+28 -4
View File
@@ -932,6 +932,10 @@ module ts {
}
function emitPropertyDeclaration(node: Declaration) {
if (hasDynamicName(node)) {
return;
}
emitJsDocComments(node);
emitClassMemberDeclarationFlags(node);
emitVariableDeclaration(<VariableDeclaration>node);
@@ -939,11 +943,13 @@ module ts {
writeLine();
}
// TODO(jfreeman): Factor out common part of property definition, but treat name differently
function emitVariableDeclaration(node: VariableDeclaration) {
// If we are emitting property it isn't moduleElement and hence we already know it needs to be emitted
// so there is no check needed to see if declaration is visible
if (node.kind !== SyntaxKind.VariableDeclaration || resolver.isDeclarationVisible(node)) {
// If this node is a computed name, it can only be a symbol, because we've already skipped
// it if it's not a well known symbol. In that case, the text of the name will be exactly
// what we want, namely the name expression enclosed in brackets.
writeTextOfNode(currentSourceFile, node.name);
// If optional property emit ?
if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature) && hasQuestionToken(node)) {
@@ -1030,6 +1036,10 @@ module ts {
}
function emitAccessorDeclaration(node: AccessorDeclaration) {
if (hasDynamicName(node)) {
return;
}
var accessors = getAllAccessorDeclarations(<ClassDeclaration>node.parent, node);
if (node === accessors.firstAccessor) {
emitJsDocComments(accessors.getAccessor);
@@ -1107,6 +1117,10 @@ module ts {
}
function emitFunctionDeclaration(node: FunctionLikeDeclaration) {
if (hasDynamicName(node)) {
return;
}
// If we are emitting Method/Constructor it isn't moduleElement and hence already determined to be emitting
// so no need to verify if the declaration is visible
if ((node.kind !== SyntaxKind.FunctionDeclaration || resolver.isDeclarationVisible(node)) &&
@@ -1723,7 +1737,14 @@ module ts {
if (scopeName) {
var parentIndex = getSourceMapNameIndex();
if (parentIndex !== -1) {
scopeName = sourceMapData.sourceMapNames[parentIndex] + "." + scopeName;
// Child scopes are always shown with a dot (even if they have no name),
// unless it is a computed property. Then it is shown with brackets,
// but the brackets are included in the name.
var name = (<Declaration>node).name;
if (!name || name.kind !== SyntaxKind.ComputedPropertyName) {
scopeName = "." + scopeName;
}
scopeName = sourceMapData.sourceMapNames[parentIndex] + scopeName;
}
scopeNameIndex = getProperty(sourceMapNameIndexMap, scopeName);
@@ -1751,8 +1772,11 @@ module ts {
node.kind === SyntaxKind.EnumDeclaration) {
// Declaration and has associated name use it
if ((<Declaration>node).name) {
// TODO(jfreeman): Ask shkamat about what this name should be for source maps
scopeName = (<Identifier>(<Declaration>node).name).text;
var name = (<Declaration>node).name;
// For computed property names, the text will include the brackets
scopeName = name.kind === SyntaxKind.ComputedPropertyName
? getTextOfNode(name)
: (<Identifier>(<Declaration>node).name).text;
}
recordScopeNameStart(scopeName);
}
src/compiler/types.ts
+22 -18
View File
@@ -1266,29 +1266,33 @@ module ts {
}
export const enum TypeFlags {
Any = 0x00000001,
String = 0x00000002,
Number = 0x00000004,
Boolean = 0x00000008,
Void = 0x00000010,
Undefined = 0x00000020,
Null = 0x00000040,
Enum = 0x00000080, // Enum type
StringLiteral = 0x00000100, // String literal type
TypeParameter = 0x00000200, // Type parameter
Class = 0x00000400, // Class
Interface = 0x00000800, // Interface
Reference = 0x00001000, // Generic type reference
Tuple = 0x00002000, // Tuple
Union = 0x00004000, // Union
Anonymous = 0x00008000, // Anonymous
FromSignature = 0x00010000, // Created for signature assignment check
Unwidened = 0x00020000, // Unwidened type (is or contains Undefined or Null type)
Any = 0x00000001,
String = 0x00000002,
Number = 0x00000004,
Boolean = 0x00000008,
Void = 0x00000010,
Undefined = 0x00000020,
Null = 0x00000040,
Enum = 0x00000080, // Enum type
StringLiteral = 0x00000100, // String literal type
TypeParameter = 0x00000200, // Type parameter
Class = 0x00000400, // Class
Interface = 0x00000800, // Interface
Reference = 0x00001000, // Generic type reference
Tuple = 0x00002000, // Tuple
Union = 0x00004000, // Union
Anonymous = 0x00008000, // Anonymous
FromSignature = 0x00010000, // Created for signature assignment check
ObjectLiteral = 0x00020000, // Originates in an object literal
ContainsUndefinedOrNull = 0x00040000, // Type is or contains Undefined or Null type
ContainsObjectLiteral = 0x00080000, // Type is or contains object literal type
Intrinsic = Any | String | Number | Boolean | Void | Undefined | Null,
Primitive = String | Number | Boolean | Void | Undefined | Null | StringLiteral | Enum,
StringLike = String | StringLiteral,
NumberLike = Number | Enum,
ObjectType = Class | Interface | Reference | Tuple | Anonymous,
RequiresWidening = ContainsUndefinedOrNull | ContainsObjectLiteral
}
// Properties common to all types
src/compiler/utilities.ts
+40 -4
View File
@@ -399,6 +399,21 @@ module ts {
return undefined;
}
switch (node.kind) {
case SyntaxKind.ComputedPropertyName:
// If the grandparent node is an object literal (as opposed to a class),
// then the computed property is not a 'this' container.
// A computed property name in a class needs to be a this container
// so that we can error on it.
if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
return node;
}
// If this is a computed property, then the parent should not
// make it a this container. The parent might be a property
// in an object literal, like a method or accessor. But in order for
// such a parent to be a this container, the reference must be in
// the *body* of the container.
node = node.parent;
break;
case SyntaxKind.ArrowFunction:
if (!includeArrowFunctions) {
continue;
@@ -421,13 +436,32 @@ module ts {
}
}
export function getSuperContainer(node: Node): Node {
export function getSuperContainer(node: Node, includeFunctions: boolean): Node {
while (true) {
node = node.parent;
if (!node) {
return undefined;
}
if (!node) return node;
switch (node.kind) {
case SyntaxKind.ComputedPropertyName:
// If the grandparent node is an object literal (as opposed to a class),
// then the computed property is not a 'super' container.
// A computed property name in a class needs to be a super container
// so that we can error on it.
if (node.parent.parent.kind === SyntaxKind.ClassDeclaration) {
return node;
}
// If this is a computed property, then the parent should not
// make it a super container. The parent might be a property
// in an object literal, like a method or accessor. But in order for
// such a parent to be a super container, the reference must be in
// the *body* of the container.
node = node.parent;
break;
case SyntaxKind.FunctionDeclaration:
case SyntaxKind.FunctionExpression:
case SyntaxKind.ArrowFunction:
if (!includeFunctions) {
continue;
}
case SyntaxKind.PropertyDeclaration:
case SyntaxKind.PropertySignature:
case SyntaxKind.MethodDeclaration:
@@ -527,6 +561,8 @@ module ts {
return node === (<TypeAssertion>parent).expression;
case SyntaxKind.TemplateSpan:
return node === (<TemplateSpan>parent).expression;
case SyntaxKind.ComputedPropertyName:
return node === (<ComputedPropertyName>parent).expression;
default:
if (isExpression(parent)) {
return true;
src/harness/fourslash.ts
+12
View File
@@ -548,6 +548,18 @@ module FourSlash {
}
}
public verifyGetEmitOutputForCurrentFile(expected: string): void {
var emit = this.languageService.getEmitOutput(this.activeFile.fileName);
if (emit.outputFiles.length !== 1) {
throw new Error("Expected exactly one output from emit of " + this.activeFile.fileName);
}
this.taoInvalidReason = 'verifyGetEmitOutputForCurrentFile impossible';
var actual = emit.outputFiles[0].text;
if (actual !== expected) {
this.raiseError("Expected emit output to be '" + expected + "', but got '" + actual + "'");
}
}
public verifyMemberListContains(symbol: string, text?: string, documentation?: string, kind?: string) {
this.scenarioActions.push('<ShowCompletionList />');
this.scenarioActions.push('<VerifyCompletionContainsItem ItemName="' + symbol + '"/>');
src/services/services.ts
+95 -44
View File
@@ -59,7 +59,7 @@ module ts {
isOpen: boolean;
version: string;
scriptSnapshot: IScriptSnapshot;
nameTable: Map<string>;
getNamedDeclarations(): Declaration[];
}
@@ -335,36 +335,44 @@ module ts {
var paramTag = "@param";
var jsDocCommentParts: SymbolDisplayPart[] = [];
ts.forEach(declarations, declaration => {
var sourceFileOfDeclaration = getSourceFileOfNode(declaration);
// If it is parameter - try and get the jsDoc comment with @param tag from function declaration's jsDoc comments
if (canUseParsedParamTagComments && declaration.kind === SyntaxKind.Parameter) {
ts.forEach(getJsDocCommentTextRange(declaration.parent, sourceFileOfDeclaration), jsDocCommentTextRange => {
var cleanedParamJsDocComment = getCleanedParamJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration);
if (cleanedParamJsDocComment) {
jsDocCommentParts.push.apply(jsDocCommentParts, cleanedParamJsDocComment);
}
});
ts.forEach(declarations, (declaration, indexOfDeclaration) => {
// Make sure we are collecting doc comment from declaration once,
// In case of union property there might be same declaration multiple times
// which only varies in type parameter
// Eg. var a: Array<string> | Array<number>; a.length
// The property length will have two declarations of property length coming
// from Array<T> - Array<string> and Array<number>
if (indexOf(declarations, declaration) === indexOfDeclaration) {
var sourceFileOfDeclaration = getSourceFileOfNode(declaration);
// If it is parameter - try and get the jsDoc comment with @param tag from function declaration's jsDoc comments
if (canUseParsedParamTagComments && declaration.kind === SyntaxKind.Parameter) {
ts.forEach(getJsDocCommentTextRange(declaration.parent, sourceFileOfDeclaration), jsDocCommentTextRange => {
var cleanedParamJsDocComment = getCleanedParamJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration);
if (cleanedParamJsDocComment) {
jsDocCommentParts.push.apply(jsDocCommentParts, cleanedParamJsDocComment);
}
});
}
// If this is left side of dotted module declaration, there is no doc comments associated with this node
if (declaration.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>declaration).body.kind === SyntaxKind.ModuleDeclaration) {
return;
}
// If this is dotted module name, get the doc comments from the parent
while (declaration.kind === SyntaxKind.ModuleDeclaration && declaration.parent.kind === SyntaxKind.ModuleDeclaration) {
declaration = <ModuleDeclaration>declaration.parent;
}
// Get the cleaned js doc comment text from the declaration
ts.forEach(getJsDocCommentTextRange(
declaration.kind === SyntaxKind.VariableDeclaration ? declaration.parent.parent : declaration, sourceFileOfDeclaration), jsDocCommentTextRange => {
var cleanedJsDocComment = getCleanedJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration);
if (cleanedJsDocComment) {
jsDocCommentParts.push.apply(jsDocCommentParts, cleanedJsDocComment);
}
});
}
// If this is left side of dotted module declaration, there is no doc comments associated with this node
if (declaration.kind === SyntaxKind.ModuleDeclaration && (<ModuleDeclaration>declaration).body.kind === SyntaxKind.ModuleDeclaration) {
return;
}
// If this is dotted module name, get the doc comments from the parent
while (declaration.kind === SyntaxKind.ModuleDeclaration && declaration.parent.kind === SyntaxKind.ModuleDeclaration) {
declaration = <ModuleDeclaration>declaration.parent;
}
// Get the cleaned js doc comment text from the declaration
ts.forEach(getJsDocCommentTextRange(
declaration.kind === SyntaxKind.VariableDeclaration ? declaration.parent.parent : declaration, sourceFileOfDeclaration), jsDocCommentTextRange => {
var cleanedJsDocComment = getCleanedJsDocComment(jsDocCommentTextRange.pos, jsDocCommentTextRange.end, sourceFileOfDeclaration);
if (cleanedJsDocComment) {
jsDocCommentParts.push.apply(jsDocCommentParts, cleanedJsDocComment);
}
});
});
return jsDocCommentParts;
@@ -750,6 +758,7 @@ module ts {
public isOpen: boolean;
public languageVersion: ScriptTarget;
public identifiers: Map<string>;
public nameTable: Map<string>;
private namedDeclarations: Declaration[];
@@ -1546,6 +1555,8 @@ module ts {
export function createLanguageServiceSourceFile(filename: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, isOpen: boolean, setNodeParents: boolean): SourceFile {
var sourceFile = createSourceFile(filename, scriptSnapshot.getText(0, scriptSnapshot.getLength()), scriptTarget, setNodeParents);
setSourceFileFields(sourceFile, scriptSnapshot, version, isOpen);
// after full parsing we can use table with interned strings as name table
sourceFile.nameTable = sourceFile.identifiers;
return sourceFile;
}
@@ -1577,6 +1588,9 @@ module ts {
if (!disableIncrementalParsing) {
var newSourceFile = sourceFile.update(scriptSnapshot.getText(0, scriptSnapshot.getLength()), textChangeRange);
setSourceFileFields(newSourceFile, scriptSnapshot, version, isOpen);
// after incremental parsing nameTable might not be up-to-date
// drop it so it can be lazily recreated later
newSourceFile.nameTable = undefined;
return newSourceFile;
}
}
@@ -3235,7 +3249,7 @@ module ts {
if (node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.ThisKeyword || node.kind === SyntaxKind.SuperKeyword ||
isLiteralNameOfPropertyDeclarationOrIndexAccess(node) || isNameOfExternalModuleImportOrDeclaration(node)) {
return getReferencesForNode(node, [sourceFile], /*findInStrings:*/ false, /*findInComments:*/ false);
return getReferencesForNode(node, [sourceFile], /*searchOnlyInCurrentFile*/ true, /*findInStrings:*/ false, /*findInComments:*/ false);
}
switch (node.kind) {
@@ -3788,10 +3802,31 @@ module ts {
}
Debug.assert(node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.NumericLiteral || node.kind === SyntaxKind.StringLiteral);
return getReferencesForNode(node, program.getSourceFiles(), findInStrings, findInComments);
return getReferencesForNode(node, program.getSourceFiles(), /*searchOnlyInCurrentFile*/ false, findInStrings, findInComments);
}
function getReferencesForNode(node: Node, sourceFiles: SourceFile[], findInStrings: boolean, findInComments: boolean): ReferenceEntry[] {
function initializeNameTable(sourceFile: SourceFile): void {
var nameTable: Map<string> = {};
walk(sourceFile);
sourceFile.nameTable = nameTable;
function walk(node: Node) {
switch (node.kind) {
case SyntaxKind.Identifier:
nameTable[(<Identifier>node).text] = (<Identifier>node).text;
break;
case SyntaxKind.StringLiteral:
case SyntaxKind.NumericLiteral:
nameTable[(<LiteralExpression>node).text] = (<LiteralExpression>node).text;
break;
default:
forEachChild(node, walk);
}
}
}
function getReferencesForNode(node: Node, sourceFiles: SourceFile[], searchOnlyInCurrentFile: boolean, findInStrings: boolean, findInComments: boolean): ReferenceEntry[] {
// Labels
if (isLabelName(node)) {
if (isJumpStatementTarget(node)) {
@@ -3847,15 +3882,28 @@ module ts {
getReferencesInNode(scope, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result);
}
else {
var internedName = getInternedName(symbol, declarations)
forEach(sourceFiles, sourceFile => {
cancellationToken.throwIfCancellationRequested();
if (searchOnlyInCurrentFile) {
Debug.assert(sourceFiles.length === 1);
result = [];
getReferencesInNode(sourceFiles[0], symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result);
}
else {
var internedName = getInternedName(symbol, declarations)
forEach(sourceFiles, sourceFile => {
cancellationToken.throwIfCancellationRequested();
if (lookUp(sourceFile.identifiers, internedName)) {
result = result || [];
getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result);
}
});
if (!sourceFile.nameTable) {
initializeNameTable(sourceFile)
}
Debug.assert(sourceFile.nameTable !== undefined);
if (lookUp(sourceFile.nameTable, internedName)) {
result = result || [];
getReferencesInNode(sourceFile, symbol, declaredName, node, searchMeaning, findInStrings, findInComments, result);
}
});
}
}
return result;
@@ -3903,7 +3951,8 @@ module ts {
}
// if this symbol is visible from its parent container, e.g. exported, then bail out
if (symbol.parent) {
// if symbol correspond to the union property - bail out
if (symbol.parent || (symbol.getFlags() & SymbolFlags.UnionProperty)) {
return undefined;
}
@@ -4114,7 +4163,7 @@ module ts {
}
function getReferencesForSuperKeyword(superKeyword: Node): ReferenceEntry[] {
var searchSpaceNode = getSuperContainer(superKeyword);
var searchSpaceNode = getSuperContainer(superKeyword, /*includeFunctions*/ false);
if (!searchSpaceNode) {
return undefined;
}
@@ -4149,7 +4198,7 @@ module ts {
return;
}
var container = getSuperContainer(node);
var container = getSuperContainer(node, /*includeFunctions*/ false);
// If we have a 'super' container, we must have an enclosing class.
// Now make sure the owning class is the same as the search-space
@@ -4191,6 +4240,8 @@ module ts {
case SyntaxKind.FunctionDeclaration:
case SyntaxKind.FunctionExpression:
break;
// Computed properties in classes are not handled here because references to this are illegal,
// so there is no point finding references to them.
default:
return undefined;
}
tests/baselines/reference/FunctionDeclaration8_es6.errors.txt
+9 -3
View File
@@ -1,7 +1,13 @@
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration8_es6.ts(1,11): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration8_es6.ts(1,11): error TS1167: Computed property names are only available when targeting ECMAScript 6 and higher.
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration8_es6.ts(1,12): error TS2304: Cannot find name 'yield'.
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration8_es6.ts(1,20): error TS2304: Cannot find name 'foo'.
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration8_es6.ts (1 errors) ====
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration8_es6.ts (3 errors) ====
var v = { [yield]: foo }
~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
!!! error TS1167: Computed property names are only available when targeting ECMAScript 6 and higher.
~~~~~
!!! error TS2304: Cannot find name 'yield'.
~~~
!!! error TS2304: Cannot find name 'foo'.
tests/baselines/reference/FunctionDeclaration9_es6.errors.txt
+6 -3
View File
@@ -1,12 +1,15 @@
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(1,10): error TS9001: Generators are not currently supported.
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(2,13): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(2,13): error TS1167: Computed property names are only available when targeting ECMAScript 6 and higher.
tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts(2,14): error TS9000: 'yield' expressions are not currently supported.
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts (2 errors) ====
==== tests/cases/conformance/es6/functionDeclarations/FunctionDeclaration9_es6.ts (3 errors) ====
function * foo() {
~
!!! error TS9001: Generators are not currently supported.
var v = { [yield]: foo }
~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
!!! error TS1167: Computed property names are only available when targeting ECMAScript 6 and higher.
~~~~~
!!! error TS9000: 'yield' expressions are not currently supported.
}
tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
+9 -3
View File
@@ -1,7 +1,13 @@
tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,12): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,11): error TS9001: Generators are not currently supported.
tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,12): error TS1167: Computed property names are only available when targeting ECMAScript 6 and higher.
tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts(1,13): error TS2304: Cannot find name 'foo'.
==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (1 errors) ====
==== tests/cases/conformance/es6/functionPropertyAssignments/FunctionPropertyAssignments5_es6.ts (3 errors) ====
var v = { *[foo()]() { } }
~
!!! error TS9001: Generators are not currently supported.
~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
!!! error TS1167: Computed property names are only available when targeting ECMAScript 6 and higher.
~~~
!!! error TS2304: Cannot find name 'foo'.
tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt
+4 -1
View File
@@ -1,9 +1,12 @@
tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,4): error TS9001: Generators are not currently supported.
tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts(2,6): error TS2304: Cannot find name 'foo'.
==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts (1 errors) ====
==== tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration3_es6.ts (2 errors) ====
class C {
*[foo]() { }
~
!!! error TS9001: Generators are not currently supported.
~~~
!!! error TS2304: Cannot find name 'foo'.
}
tests/baselines/reference/TypeGuardWithEnumUnion.js
+77
View File
@@ -0,0 +1,77 @@
//// [TypeGuardWithEnumUnion.ts]
enum Color { R, G, B }
function f1(x: Color | string) {
if (typeof x === "number") {
var y = x;
var y: Color;
}
else {
var z = x;
var z: string;
}
}
function f2(x: Color | string | string[]) {
if (typeof x === "object") {
var y = x;
var y: string[];
}
if (typeof x === "number") {
var z = x;
var z: Color;
}
else {
var w = x;
var w: string | string[];
}
if (typeof x === "string") {
var a = x;
var a: string;
}
else {
var b = x;
var b: Color | string[];
}
}
//// [TypeGuardWithEnumUnion.js]
var Color;
(function (Color) {
Color[Color["R"] = 0] = "R";
Color[Color["G"] = 1] = "G";
Color[Color["B"] = 2] = "B";
})(Color || (Color = {}));
function f1(x) {
if (typeof x === "number") {
var y = x;
var y;
}
else {
var z = x;
var z;
}
}
function f2(x) {
if (typeof x === "object") {
var y = x;
var y;
}
if (typeof x === "number") {
var z = x;
var z;
}
else {
var w = x;
var w;
}
if (typeof x === "string") {
var a = x;
var a;
}
else {
var b = x;
var b;
}
}
tests/baselines/reference/TypeGuardWithEnumUnion.types
+96
View File
@@ -0,0 +1,96 @@
=== tests/cases/conformance/expressions/typeGuards/TypeGuardWithEnumUnion.ts ===
enum Color { R, G, B }
>Color : Color
>R : Color
>G : Color
>B : Color
function f1(x: Color | string) {
>f1 : (x: string | Color) => void
>x : string | Color
>Color : Color
if (typeof x === "number") {
>typeof x === "number" : boolean
>typeof x : string
>x : string | Color
var y = x;
>y : Color
>x : Color
var y: Color;
>y : Color
>Color : Color
}
else {
var z = x;
>z : string
>x : string
var z: string;
>z : string
}
}
function f2(x: Color | string | string[]) {
>f2 : (x: string | string[] | Color) => void
>x : string | string[] | Color
>Color : Color
if (typeof x === "object") {
>typeof x === "object" : boolean
>typeof x : string
>x : string | string[] | Color
var y = x;
>y : string[]
>x : string[]
var y: string[];
>y : string[]
}
if (typeof x === "number") {
>typeof x === "number" : boolean
>typeof x : string
>x : string | string[] | Color
var z = x;
>z : Color
>x : Color
var z: Color;
>z : Color
>Color : Color
}
else {
var w = x;
>w : string | string[]
>x : string | string[]
var w: string | string[];
>w : string | string[]
}
if (typeof x === "string") {
>typeof x === "string" : boolean
>typeof x : string
>x : string | string[] | Color
var a = x;
>a : string
>x : string
var a: string;
>a : string
}
else {
var b = x;
>b : string[] | Color
>x : string[] | Color
var b: Color | string[];
>b : string[] | Color
>Color : Color
}
}
tests/baselines/reference/arrayCast.errors.txt
+2
View File
@@ -1,5 +1,6 @@
tests/cases/compiler/arrayCast.ts(3,1): error TS2352: Neither type '{ foo: string; }[]' nor type '{ id: number; }[]' is assignable to the other.
Type '{ foo: string; }' is not assignable to type '{ id: number; }'.
Property 'id' is missing in type '{ foo: string; }'.
==== tests/cases/compiler/arrayCast.ts (1 errors) ====
@@ -9,6 +10,7 @@ tests/cases/compiler/arrayCast.ts(3,1): error TS2352: Neither type '{ foo: strin
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2352: Neither type '{ foo: string; }[]' nor type '{ id: number; }[]' is assignable to the other.
!!! error TS2352: Type '{ foo: string; }' is not assignable to type '{ id: number; }'.
!!! error TS2352: Property 'id' is missing in type '{ foo: string; }'.
// Should succeed, as the {} element causes the type of the array to be {}[]
<{ id: number; }[]>[{ foo: "s" }, {}];
tests/baselines/reference/complicatedPrivacy.errors.txt
+5 -2
View File
@@ -1,8 +1,9 @@
tests/cases/compiler/complicatedPrivacy.ts(24,38): error TS1005: ';' expected.
tests/cases/compiler/complicatedPrivacy.ts(35,6): error TS2304: Cannot find name 'number'.
tests/cases/compiler/complicatedPrivacy.ts(73,49): error TS2305: Module 'mglo5' has no exported member 'i6'.
==== tests/cases/compiler/complicatedPrivacy.ts (2 errors) ====
==== tests/cases/compiler/complicatedPrivacy.ts (3 errors) ====
module m1 {
export module m2 {
@@ -39,7 +40,9 @@ tests/cases/compiler/complicatedPrivacy.ts(73,49): error TS2305: Module 'mglo5'
export function f4(arg1:
{
[number]: C1;
[number]: C1; // Used to be indexer, now it is a computed property
~~~~~~
!!! error TS2304: Cannot find name 'number'.
}) {
}
tests/baselines/reference/computedPropertyNames1.errors.txt
-13
View File
@@ -1,13 +0,0 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames1.ts(2,9): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames1.ts(3,9): error TS9002: Computed property names are not currently supported.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames1.ts (2 errors) ====
var v = {
get [0 + 1]() { return 0 },
~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
set [0 + 1](v: string) { } //No error
~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
}
tests/baselines/reference/computedPropertyNames1.js
+14
View File
@@ -0,0 +1,14 @@
//// [computedPropertyNames1.ts]
var v = {
get [0 + 1]() { return 0 },
set [0 + 1](v: string) { } //No error
}
//// [computedPropertyNames1.js]
var v = {
get [0 + 1]() {
return 0;
},
set [0 + 1](v) {
} //No error
};
tests/baselines/reference/computedPropertyNames1.types
+12
View File
@@ -0,0 +1,12 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames1.ts ===
var v = {
>v : {}
>{ get [0 + 1]() { return 0 }, set [0 + 1](v: string) { } //No error} : {}
get [0 + 1]() { return 0 },
>0 + 1 : number
set [0 + 1](v: string) { } //No error
>0 + 1 : number
>v : string
}
tests/baselines/reference/computedPropertyNames10.js
+46
View File
@@ -0,0 +1,46 @@
//// [computedPropertyNames10.ts]
var s: string;
var n: number;
var a: any;
var v = {
[s]() { },
[n]() { },
[s + s]() { },
[s + n]() { },
[+s]() { },
[""]() { },
[0]() { },
[a]() { },
[<any>true]() { },
[`hello bye`]() { },
[`hello ${a} bye`]() { }
}
//// [computedPropertyNames10.js]
var s;
var n;
var a;
var v = {
[s]() {
},
[n]() {
},
[s + s]() {
},
[s + n]() {
},
[+s]() {
},
[""]() {
},
[0]() {
},
[a]() {
},
[true]() {
},
[`hello bye`]() {
},
[`hello ${a} bye`]() {
}
};
tests/baselines/reference/computedPropertyNames10.types
+46
View File
@@ -0,0 +1,46 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames10.ts ===
var s: string;
>s : string
var n: number;
>n : number
var a: any;
>a : any
var v = {
>v : {}
>{ [s]() { }, [n]() { }, [s + s]() { }, [s + n]() { }, [+s]() { }, [""]() { }, [0]() { }, [a]() { }, [<any>true]() { }, [`hello bye`]() { }, [`hello ${a} bye`]() { }} : {}
[s]() { },
>s : string
[n]() { },
>n : number
[s + s]() { },
>s + s : string
>s : string
>s : string
[s + n]() { },
>s + n : string
>s : string
>n : number
[+s]() { },
>+s : number
>s : string
[""]() { },
[0]() { },
[a]() { },
>a : any
[<any>true]() { },
><any>true : any
[`hello bye`]() { },
[`hello ${a} bye`]() { }
>a : any
}
tests/baselines/reference/computedPropertyNames11.js
+52
View File
@@ -0,0 +1,52 @@
//// [computedPropertyNames11.ts]
var s: string;
var n: number;
var a: any;
var v = {
get [s]() { return 0; },
set [n](v) { },
get [s + s]() { return 0; },
set [s + n](v) { },
get [+s]() { return 0; },
set [""](v) { },
get [0]() { return 0; },
set [a](v) { },
get [<any>true]() { return 0; },
set [`hello bye`](v) { },
get [`hello ${a} bye`]() { return 0; }
}
//// [computedPropertyNames11.js]
var s;
var n;
var a;
var v = {
get [s]() {
return 0;
},
set [n](v) {
},
get [s + s]() {
return 0;
},
set [s + n](v) {
},
get [+s]() {
return 0;
},
set [""](v) {
},
get [0]() {
return 0;
},
set [a](v) {
},
get [true]() {
return 0;
},
set [`hello bye`](v) {
},
get [`hello ${a} bye`]() {
return 0;
}
};
tests/baselines/reference/computedPropertyNames11.types
+53
View File
@@ -0,0 +1,53 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames11.ts ===
var s: string;
>s : string
var n: number;
>n : number
var a: any;
>a : any
var v = {
>v : {}
>{ get [s]() { return 0; }, set [n](v) { }, get [s + s]() { return 0; }, set [s + n](v) { }, get [+s]() { return 0; }, set [""](v) { }, get [0]() { return 0; }, set [a](v) { }, get [<any>true]() { return 0; }, set [`hello bye`](v) { }, get [`hello ${a} bye`]() { return 0; }} : {}
get [s]() { return 0; },
>s : string
set [n](v) { },
>n : number
>v : any
get [s + s]() { return 0; },
>s + s : string
>s : string
>s : string
set [s + n](v) { },
>s + n : string
>s : string
>n : number
>v : any
get [+s]() { return 0; },
>+s : number
>s : string
set [""](v) { },
>v : any
get [0]() { return 0; },
set [a](v) { },
>a : any
>v : any
get [<any>true]() { return 0; },
><any>true : any
set [`hello bye`](v) { },
>v : any
get [`hello ${a} bye`]() { return 0; }
>a : any
}
tests/baselines/reference/computedPropertyNames12.errors.txt
+52
View File
@@ -0,0 +1,52 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(5,5): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(6,5): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(7,12): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(8,5): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(9,5): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(10,12): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(11,5): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(12,5): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(13,12): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(14,5): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts(15,12): error TS1166: Computed property names are not allowed in class property declarations.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames12.ts (11 errors) ====
var s: string;
var n: number;
var a: any;
class C {
[s]: number;
~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
[n] = n;
~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
static [s + s]: string;
~~~~~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
[s + n] = 2;
~~~~~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
[+s]: typeof s;
~~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
static [""]: number;
~~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
[0]: number;
~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
[a]: number;
~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
static [<any>true]: number;
~~~~~~~~~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
[`hello bye`] = 0;
~~~~~~~~~~~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
static [`hello ${a} bye`] = 0
~~~~~~~~~~~~~~~~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
}
tests/baselines/reference/computedPropertyNames13.js
+49
View File
@@ -0,0 +1,49 @@
//// [computedPropertyNames13.ts]
var s: string;
var n: number;
var a: any;
class C {
[s]() {}
[n]() { }
static [s + s]() { }
[s + n]() { }
[+s]() { }
static [""]() { }
[0]() { }
[a]() { }
static [<any>true]() { }
[`hello bye`]() { }
static [`hello ${a} bye`]() { }
}
//// [computedPropertyNames13.js]
var s;
var n;
var a;
var C = (function () {
function C() {
}
C.prototype[s] = function () {
};
C.prototype[n] = function () {
};
C[s + s] = function () {
};
C.prototype[s + n] = function () {
};
C.prototype[+s] = function () {
};
C[""] = function () {
};
C.prototype[0] = function () {
};
C.prototype[a] = function () {
};
C[true] = function () {
};
C.prototype[`hello bye`] = function () {
};
C[`hello ${a} bye`] = function () {
};
return C;
})();
tests/baselines/reference/computedPropertyNames13.types
+45
View File
@@ -0,0 +1,45 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames13.ts ===
var s: string;
>s : string
var n: number;
>n : number
var a: any;
>a : any
class C {
>C : C
[s]() {}
>s : string
[n]() { }
>n : number
static [s + s]() { }
>s + s : string
>s : string
>s : string
[s + n]() { }
>s + n : string
>s : string
>n : number
[+s]() { }
>+s : number
>s : string
static [""]() { }
[0]() { }
[a]() { }
>a : any
static [<any>true]() { }
><any>true : any
[`hello bye`]() { }
static [`hello ${a} bye`]() { }
>a : any
}
tests/baselines/reference/computedPropertyNames14.errors.txt
+30
View File
@@ -0,0 +1,30 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames14.ts(3,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames14.ts(4,12): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames14.ts(5,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames14.ts(6,12): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames14.ts(7,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames14.ts(8,12): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames14.ts (6 errors) ====
var b: boolean;
class C {
[b]() {}
~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
static [true]() { }
~~~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
[[]]() { }
~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
static [{}]() { }
~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
[undefined]() { }
~~~~~~~~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
static [null]() { }
~~~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
}
tests/baselines/reference/computedPropertyNames14.js
+30
View File
@@ -0,0 +1,30 @@
//// [computedPropertyNames14.ts]
var b: boolean;
class C {
[b]() {}
static [true]() { }
[[]]() { }
static [{}]() { }
[undefined]() { }
static [null]() { }
}
//// [computedPropertyNames14.js]
var b;
var C = (function () {
function C() {
}
C.prototype[b] = function () {
};
C[true] = function () {
};
C.prototype[[]] = function () {
};
C[{}] = function () {
};
C.prototype[undefined] = function () {
};
C[null] = function () {
};
return C;
})();
tests/baselines/reference/computedPropertyNames15.errors.txt
+17
View File
@@ -0,0 +1,17 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames15.ts(6,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames15.ts(7,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames15.ts (2 errors) ====
var p1: number | string;
var p2: number | number[];
var p3: string | boolean;
class C {
[p1]() { }
[p2]() { }
~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
[p3]() { }
~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
}
tests/baselines/reference/computedPropertyNames15.js
+25
View File
@@ -0,0 +1,25 @@
//// [computedPropertyNames15.ts]
var p1: number | string;
var p2: number | number[];
var p3: string | boolean;
class C {
[p1]() { }
[p2]() { }
[p3]() { }
}
//// [computedPropertyNames15.js]
var p1;
var p2;
var p3;
var C = (function () {
function C() {
}
C.prototype[p1] = function () {
};
C.prototype[p2] = function () {
};
C.prototype[p3] = function () {
};
return C;
})();
tests/baselines/reference/computedPropertyNames16.js
+99
View File
@@ -0,0 +1,99 @@
//// [computedPropertyNames16.ts]
var s: string;
var n: number;
var a: any;
class C {
get [s]() { return 0;}
set [n](v) { }
static get [s + s]() { return 0; }
set [s + n](v) { }
get [+s]() { return 0; }
static set [""](v) { }
get [0]() { return 0; }
set [a](v) { }
static get [<any>true]() { return 0; }
set [`hello bye`](v) { }
get [`hello ${a} bye`]() { return 0; }
}
//// [computedPropertyNames16.js]
var s;
var n;
var a;
var C = (function () {
function C() {
}
Object.defineProperty(C.prototype, s, {
get: function () {
return 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, n, {
set: function (v) {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C, s + s, {
get: function () {
return 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, s + n, {
set: function (v) {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, +s, {
get: function () {
return 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C, "", {
set: function (v) {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, 0, {
get: function () {
return 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, a, {
set: function (v) {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C, true, {
get: function () {
return 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, `hello bye`, {
set: function (v) {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, `hello ${a} bye`, {
get: function () {
return 0;
},
enumerable: true,
configurable: true
});
return C;
})();
tests/baselines/reference/computedPropertyNames16.types
+52
View File
@@ -0,0 +1,52 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames16.ts ===
var s: string;
>s : string
var n: number;
>n : number
var a: any;
>a : any
class C {
>C : C
get [s]() { return 0;}
>s : string
set [n](v) { }
>n : number
>v : any
static get [s + s]() { return 0; }
>s + s : string
>s : string
>s : string
set [s + n](v) { }
>s + n : string
>s : string
>n : number
>v : any
get [+s]() { return 0; }
>+s : number
>s : string
static set [""](v) { }
>v : any
get [0]() { return 0; }
set [a](v) { }
>a : any
>v : any
static get [<any>true]() { return 0; }
><any>true : any
set [`hello bye`](v) { }
>v : any
get [`hello ${a} bye`]() { return 0; }
>a : any
}
tests/baselines/reference/computedPropertyNames17.errors.txt
+30
View File
@@ -0,0 +1,30 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames17.ts(3,9): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames17.ts(4,16): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames17.ts(5,9): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames17.ts(6,9): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames17.ts(7,16): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames17.ts(8,9): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames17.ts (6 errors) ====
var b: boolean;
class C {
get [b]() { return 0;}
~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
static set [true](v) { }
~~~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
get [[]]() { return 0; }
~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
set [{}](v) { }
~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
static get [undefined]() { return 0; }
~~~~~~~~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
set [null](v) { }
~~~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
}
tests/baselines/reference/computedPropertyNames17.js
+57
View File
@@ -0,0 +1,57 @@
//// [computedPropertyNames17.ts]
var b: boolean;
class C {
get [b]() { return 0;}
static set [true](v) { }
get [[]]() { return 0; }
set [{}](v) { }
static get [undefined]() { return 0; }
set [null](v) { }
}
//// [computedPropertyNames17.js]
var b;
var C = (function () {
function C() {
}
Object.defineProperty(C.prototype, b, {
get: function () {
return 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C, true, {
set: function (v) {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, [], {
get: function () {
return 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, {}, {
set: function (v) {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C, undefined, {
get: function () {
return 0;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, null, {
set: function (v) {
},
enumerable: true,
configurable: true
});
return C;
})();
tests/baselines/reference/computedPropertyNames18.js
+13
View File
@@ -0,0 +1,13 @@
//// [computedPropertyNames18.ts]
function foo() {
var obj = {
[this.bar]: 0
}
}
//// [computedPropertyNames18.js]
function foo() {
var obj = {
[this.bar]: 0
};
}
tests/baselines/reference/computedPropertyNames18.types
+14
View File
@@ -0,0 +1,14 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames18.ts ===
function foo() {
>foo : () => void
var obj = {
>obj : {}
>{ [this.bar]: 0 } : {}
[this.bar]: 0
>this.bar : any
>this : any
>bar : any
}
}
tests/baselines/reference/computedPropertyNames19.errors.txt
+11
View File
@@ -0,0 +1,11 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames19.ts(3,10): error TS2331: 'this' cannot be referenced in a module body.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames19.ts (1 errors) ====
module M {
var obj = {
[this.bar]: 0
~~~~
!!! error TS2331: 'this' cannot be referenced in a module body.
}
}
tests/baselines/reference/computedPropertyNames19.js
+14
View File
@@ -0,0 +1,14 @@
//// [computedPropertyNames19.ts]
module M {
var obj = {
[this.bar]: 0
}
}
//// [computedPropertyNames19.js]
var M;
(function (M) {
var obj = {
[this.bar]: 0
};
})(M || (M = {}));
tests/baselines/reference/computedPropertyNames2.errors.txt
+1 -19
View File
@@ -1,37 +1,19 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames2.ts(4,5): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames2.ts(5,12): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames2.ts(6,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
tests/cases/conformance/es6/computedProperties/computedPropertyNames2.ts(6,9): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames2.ts(7,9): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames2.ts(8,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
tests/cases/conformance/es6/computedProperties/computedPropertyNames2.ts(8,16): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames2.ts(9,16): error TS9002: Computed property names are not currently supported.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames2.ts (8 errors) ====
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames2.ts (2 errors) ====
var methodName = "method";
var accessorName = "accessor";
class C {
[methodName]() { }
~~~~~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
static [methodName]() { }
~~~~~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
get [accessorName]() { }
~~~~~~~~~~~~~~
!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
~~~~~~~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
set [accessorName](v) { }
~~~~~~~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
static get [accessorName]() { }
~~~~~~~~~~~~~~
!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
~~~~~~~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
static set [accessorName](v) { }
~~~~~~~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
}
tests/baselines/reference/computedPropertyNames2.js
+48
View File
@@ -0,0 +1,48 @@
//// [computedPropertyNames2.ts]
var methodName = "method";
var accessorName = "accessor";
class C {
[methodName]() { }
static [methodName]() { }
get [accessorName]() { }
set [accessorName](v) { }
static get [accessorName]() { }
static set [accessorName](v) { }
}
//// [computedPropertyNames2.js]
var methodName = "method";
var accessorName = "accessor";
var C = (function () {
function C() {
}
C.prototype[methodName] = function () {
};
C[methodName] = function () {
};
Object.defineProperty(C.prototype, accessorName, {
get: function () {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, accessorName, {
set: function (v) {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C, accessorName, {
get: function () {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C, accessorName, {
set: function (v) {
},
enumerable: true,
configurable: true
});
return C;
})();
tests/baselines/reference/computedPropertyNames20.js
+9
View File
@@ -0,0 +1,9 @@
//// [computedPropertyNames20.ts]
var obj = {
[this.bar]: 0
}
//// [computedPropertyNames20.js]
var obj = {
[this.bar]: 0
};
tests/baselines/reference/computedPropertyNames20.types
+10
View File
@@ -0,0 +1,10 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames20.ts ===
var obj = {
>obj : {}
>{ [this.bar]: 0} : {}
[this.bar]: 0
>this.bar : any
>this : any
>bar : any
}
tests/baselines/reference/computedPropertyNames21.errors.txt
+12
View File
@@ -0,0 +1,12 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames21.ts(5,6): error TS2465: 'this' cannot be referenced in a computed property name.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames21.ts (1 errors) ====
class C {
bar() {
return 0;
}
[this.bar()]() { }
~~~~
!!! error TS2465: 'this' cannot be referenced in a computed property name.
}
tests/baselines/reference/computedPropertyNames21.js
+19
View File
@@ -0,0 +1,19 @@
//// [computedPropertyNames21.ts]
class C {
bar() {
return 0;
}
[this.bar()]() { }
}
//// [computedPropertyNames21.js]
var C = (function () {
function C() {
}
C.prototype.bar = function () {
return 0;
};
C.prototype[this.bar()] = function () {
};
return C;
})();
tests/baselines/reference/computedPropertyNames22.js
+23
View File
@@ -0,0 +1,23 @@
//// [computedPropertyNames22.ts]
class C {
bar() {
var obj = {
[this.bar()]() { }
};
return 0;
}
}
//// [computedPropertyNames22.js]
var C = (function () {
function C() {
}
C.prototype.bar = function () {
var obj = {
[this.bar()]() {
}
};
return 0;
};
return C;
})();
tests/baselines/reference/computedPropertyNames22.types
+21
View File
@@ -0,0 +1,21 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames22.ts ===
class C {
>C : C
bar() {
>bar : () => number
var obj = {
>obj : {}
>{ [this.bar()]() { } } : {}
[this.bar()]() { }
>this.bar() : number
>this.bar : () => number
>this : C
>bar : () => number
};
return 0;
}
}
tests/baselines/reference/computedPropertyNames23.errors.txt
+14
View File
@@ -0,0 +1,14 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames23.ts(6,12): error TS2465: 'this' cannot be referenced in a computed property name.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames23.ts (1 errors) ====
class C {
bar() {
return 0;
}
[
{ [this.bar()]: 1 }[0]
~~~~
!!! error TS2465: 'this' cannot be referenced in a computed property name.
]() { }
}
tests/baselines/reference/computedPropertyNames23.js
+21
View File
@@ -0,0 +1,21 @@
//// [computedPropertyNames23.ts]
class C {
bar() {
return 0;
}
[
{ [this.bar()]: 1 }[0]
]() { }
}
//// [computedPropertyNames23.js]
var C = (function () {
function C() {
}
C.prototype.bar = function () {
return 0;
};
C.prototype[{ [this.bar()]: 1 }[0]] = function () {
};
return C;
})();
tests/baselines/reference/computedPropertyNames24.errors.txt
+16
View File
@@ -0,0 +1,16 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames24.ts(9,6): error TS2466: 'super' cannot be referenced in a computed property name.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames24.ts (1 errors) ====
class Base {
bar() {
return 0;
}
}
class C extends Base {
// Gets emitted as super, not _super, which is consistent with
// use of super in static properties initializers.
[super.bar()]() { }
~~~~~
!!! error TS2466: 'super' cannot be referenced in a computed property name.
}
tests/baselines/reference/computedPropertyNames24.js
+38
View File
@@ -0,0 +1,38 @@
//// [computedPropertyNames24.ts]
class Base {
bar() {
return 0;
}
}
class C extends Base {
// Gets emitted as super, not _super, which is consistent with
// use of super in static properties initializers.
[super.bar()]() { }
}
//// [computedPropertyNames24.js]
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Base = (function () {
function Base() {
}
Base.prototype.bar = function () {
return 0;
};
return Base;
})();
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.apply(this, arguments);
}
// Gets emitted as super, not _super, which is consistent with
// use of super in static properties initializers.
C.prototype[super.bar.call(this)] = function () {
};
return C;
})(Base);
tests/baselines/reference/computedPropertyNames25.js
+44
View File
@@ -0,0 +1,44 @@
//// [computedPropertyNames25.ts]
class Base {
bar() {
return 0;
}
}
class C extends Base {
foo() {
var obj = {
[super.bar()]() { }
};
return 0;
}
}
//// [computedPropertyNames25.js]
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Base = (function () {
function Base() {
}
Base.prototype.bar = function () {
return 0;
};
return Base;
})();
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.apply(this, arguments);
}
C.prototype.foo = function () {
var obj = {
[_super.prototype.bar.call(this)]() {
}
};
return 0;
};
return C;
})(Base);
tests/baselines/reference/computedPropertyNames25.types
+31
View File
@@ -0,0 +1,31 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames25.ts ===
class Base {
>Base : Base
bar() {
>bar : () => number
return 0;
}
}
class C extends Base {
>C : C
>Base : Base
foo() {
>foo : () => number
var obj = {
>obj : {}
>{ [super.bar()]() { } } : {}
[super.bar()]() { }
>super.bar() : number
>super.bar : () => number
>super : Base
>bar : () => number
};
return 0;
}
}
tests/baselines/reference/computedPropertyNames26.errors.txt
+18
View File
@@ -0,0 +1,18 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames26.ts(10,12): error TS2466: 'super' cannot be referenced in a computed property name.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames26.ts (1 errors) ====
class Base {
bar() {
return 0;
}
}
class C extends Base {
// Gets emitted as super, not _super, which is consistent with
// use of super in static properties initializers.
[
{ [super.bar()]: 1 }[0]
~~~~~
!!! error TS2466: 'super' cannot be referenced in a computed property name.
]() { }
}
tests/baselines/reference/computedPropertyNames26.js
+40
View File
@@ -0,0 +1,40 @@
//// [computedPropertyNames26.ts]
class Base {
bar() {
return 0;
}
}
class C extends Base {
// Gets emitted as super, not _super, which is consistent with
// use of super in static properties initializers.
[
{ [super.bar()]: 1 }[0]
]() { }
}
//// [computedPropertyNames26.js]
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Base = (function () {
function Base() {
}
Base.prototype.bar = function () {
return 0;
};
return Base;
})();
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.apply(this, arguments);
}
// Gets emitted as super, not _super, which is consistent with
// use of super in static properties initializers.
C.prototype[{ [super.bar.call(this)]: 1 }[0]] = function () {
};
return C;
})(Base);
tests/baselines/reference/computedPropertyNames27.errors.txt
+11
View File
@@ -0,0 +1,11 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames27.ts(4,7): error TS2466: 'super' cannot be referenced in a computed property name.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames27.ts (1 errors) ====
class Base {
}
class C extends Base {
[(super(), "prop")]() { }
~~~~~
!!! error TS2466: 'super' cannot be referenced in a computed property name.
}
tests/baselines/reference/computedPropertyNames27.js
+28
View File
@@ -0,0 +1,28 @@
//// [computedPropertyNames27.ts]
class Base {
}
class C extends Base {
[(super(), "prop")]() { }
}
//// [computedPropertyNames27.js]
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Base = (function () {
function Base() {
}
return Base;
})();
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.apply(this, arguments);
}
C.prototype[(_super.call(this), "prop")] = function () {
};
return C;
})(Base);
tests/baselines/reference/computedPropertyNames28.js
+35
View File
@@ -0,0 +1,35 @@
//// [computedPropertyNames28.ts]
class Base {
}
class C extends Base {
constructor() {
super();
var obj = {
[(super(), "prop")]() { }
};
}
}
//// [computedPropertyNames28.js]
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Base = (function () {
function Base() {
}
return Base;
})();
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.call(this);
var obj = {
[(_super.call(this), "prop")]() {
}
};
}
return C;
})(Base);
tests/baselines/reference/computedPropertyNames28.types
+26
View File
@@ -0,0 +1,26 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames28.ts ===
class Base {
>Base : Base
}
class C extends Base {
>C : C
>Base : Base
constructor() {
super();
>super() : void
>super : typeof Base
var obj = {
>obj : {}
>{ [(super(), "prop")]() { } } : {}
[(super(), "prop")]() { }
>(super(), "prop") : string
>super(), "prop" : string
>super() : void
>super : typeof Base
};
}
}
tests/baselines/reference/computedPropertyNames29.js
+28
View File
@@ -0,0 +1,28 @@
//// [computedPropertyNames29.ts]
class C {
bar() {
() => {
var obj = {
[this.bar()]() { } // needs capture
};
}
return 0;
}
}
//// [computedPropertyNames29.js]
var C = (function () {
function C() {
}
C.prototype.bar = function () {
var _this = this;
(function () {
var obj = {
[_this.bar()]() {
} // needs capture
};
});
return 0;
};
return C;
})();
tests/baselines/reference/computedPropertyNames29.types
+25
View File
@@ -0,0 +1,25 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames29.ts ===
class C {
>C : C
bar() {
>bar : () => number
() => {
>() => { var obj = { [this.bar()]() { } // needs capture }; } : () => void
var obj = {
>obj : {}
>{ [this.bar()]() { } // needs capture } : {}
[this.bar()]() { } // needs capture
>this.bar() : number
>this.bar : () => number
>this : C
>bar : () => number
};
}
return 0;
}
}
tests/baselines/reference/computedPropertyNames3.errors.txt
+9 -15
View File
@@ -1,36 +1,30 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(3,5): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(4,12): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(4,12): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(5,9): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(5,9): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(6,9): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(5,9): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(6,9): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(7,16): error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(7,16): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(8,16): error TS9002: Computed property names are not currently supported.
tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts(7,16): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts (8 errors) ====
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames3.ts (6 errors) ====
var id;
class C {
[0 + 1]() { }
~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
static [() => { }]() { }
~~~~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
get [delete id]() { }
~~~~~~~~~~~
!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
~~~~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
set [[0, 1]](v) { }
~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
static get [<String>""]() { }
~~~~~~~~~~~~
!!! error TS2378: A 'get' accessor must return a value or consist of a single 'throw' statement.
~~~~~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
static set [id.toString()](v) { }
~~~~~~~~~~~~~~~
!!! error TS9002: Computed property names are not currently supported.
}
tests/baselines/reference/computedPropertyNames3.js
+47
View File
@@ -0,0 +1,47 @@
//// [computedPropertyNames3.ts]
var id;
class C {
[0 + 1]() { }
static [() => { }]() { }
get [delete id]() { }
set [[0, 1]](v) { }
static get [<String>""]() { }
static set [id.toString()](v) { }
}
//// [computedPropertyNames3.js]
var id;
var C = (function () {
function C() {
}
C.prototype[0 + 1] = function () {
};
C[function () {
}] = function () {
};
Object.defineProperty(C.prototype, delete id, {
get: function () {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, [0, 1], {
set: function (v) {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C, "", {
get: function () {
},
enumerable: true,
configurable: true
});
Object.defineProperty(C, id.toString(), {
set: function (v) {
},
enumerable: true,
configurable: true
});
return C;
})();
tests/baselines/reference/computedPropertyNames30.errors.txt
+21
View File
@@ -0,0 +1,21 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames30.ts(11,19): error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames30.ts (1 errors) ====
class Base {
}
class C extends Base {
constructor() {
super();
() => {
var obj = {
// Ideally, we would capture this. But the reference is
// illegal, and not capturing this is consistent with
//treatment of other similar violations.
[(super(), "prop")]() { }
~~~~~
!!! error TS2337: Super calls are not permitted outside constructors or in nested functions inside constructors
};
}
}
}
tests/baselines/reference/computedPropertyNames30.js
+45
View File
@@ -0,0 +1,45 @@
//// [computedPropertyNames30.ts]
class Base {
}
class C extends Base {
constructor() {
super();
() => {
var obj = {
// Ideally, we would capture this. But the reference is
// illegal, and not capturing this is consistent with
//treatment of other similar violations.
[(super(), "prop")]() { }
};
}
}
}
//// [computedPropertyNames30.js]
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Base = (function () {
function Base() {
}
return Base;
})();
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.call(this);
(function () {
var obj = {
// Ideally, we would capture this. But the reference is
// illegal, and not capturing this is consistent with
//treatment of other similar violations.
[(_super.call(this), "prop")]() {
}
};
});
}
return C;
})(Base);
tests/baselines/reference/computedPropertyNames31.js
+49
View File
@@ -0,0 +1,49 @@
//// [computedPropertyNames31.ts]
class Base {
bar() {
return 0;
}
}
class C extends Base {
foo() {
() => {
var obj = {
[super.bar()]() { } // needs capture
};
}
return 0;
}
}
//// [computedPropertyNames31.js]
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Base = (function () {
function Base() {
}
Base.prototype.bar = function () {
return 0;
};
return Base;
})();
var C = (function (_super) {
__extends(C, _super);
function C() {
_super.apply(this, arguments);
}
C.prototype.foo = function () {
var _this = this;
(function () {
var obj = {
[_super.prototype.bar.call(_this)]() {
} // needs capture
};
});
return 0;
};
return C;
})(Base);
tests/baselines/reference/computedPropertyNames31.types
+35
View File
@@ -0,0 +1,35 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames31.ts ===
class Base {
>Base : Base
bar() {
>bar : () => number
return 0;
}
}
class C extends Base {
>C : C
>Base : Base
foo() {
>foo : () => number
() => {
>() => { var obj = { [super.bar()]() { } // needs capture }; } : () => void
var obj = {
>obj : {}
>{ [super.bar()]() { } // needs capture } : {}
[super.bar()]() { } // needs capture
>super.bar() : number
>super.bar : () => number
>super : Base
>bar : () => number
};
}
return 0;
}
}
tests/baselines/reference/computedPropertyNames32.errors.txt
+13
View File
@@ -0,0 +1,13 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames32.ts(6,10): error TS2466: A computed property name cannot reference a type parameter from its containing type.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames32.ts (1 errors) ====
function foo<T>() { return '' }
class C<T> {
bar() {
return 0;
}
[foo<T>()]() { }
~
!!! error TS2466: A computed property name cannot reference a type parameter from its containing type.
}
tests/baselines/reference/computedPropertyNames32.js
+23
View File
@@ -0,0 +1,23 @@
//// [computedPropertyNames32.ts]
function foo<T>() { return '' }
class C<T> {
bar() {
return 0;
}
[foo<T>()]() { }
}
//// [computedPropertyNames32.js]
function foo() {
return '';
}
var C = (function () {
function C() {
}
C.prototype.bar = function () {
return 0;
};
C.prototype[foo()] = function () {
};
return C;
})();
tests/baselines/reference/computedPropertyNames33.js
+27
View File
@@ -0,0 +1,27 @@
//// [computedPropertyNames33.ts]
function foo<T>() { return '' }
class C<T> {
bar() {
var obj = {
[foo<T>()]() { }
};
return 0;
}
}
//// [computedPropertyNames33.js]
function foo() {
return '';
}
var C = (function () {
function C() {
}
C.prototype.bar = function () {
var obj = {
[foo()]() {
}
};
return 0;
};
return C;
})();
tests/baselines/reference/computedPropertyNames33.types
+25
View File
@@ -0,0 +1,25 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames33.ts ===
function foo<T>() { return '' }
>foo : <T>() => string
>T : T
class C<T> {
>C : C<T>
>T : T
bar() {
>bar : () => number
var obj = {
>obj : {}
>{ [foo<T>()]() { } } : {}
[foo<T>()]() { }
>foo<T>() : string
>foo : <T>() => string
>T : T
};
return 0;
}
}
tests/baselines/reference/computedPropertyNames34.errors.txt
+15
View File
@@ -0,0 +1,15 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames34.ts(5,18): error TS2302: Static members cannot reference class type parameters.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames34.ts (1 errors) ====
function foo<T>() { return '' }
class C<T> {
static bar() {
var obj = {
[foo<T>()]() { }
~
!!! error TS2302: Static members cannot reference class type parameters.
};
return 0;
}
}
tests/baselines/reference/computedPropertyNames34.js
+27
View File
@@ -0,0 +1,27 @@
//// [computedPropertyNames34.ts]
function foo<T>() { return '' }
class C<T> {
static bar() {
var obj = {
[foo<T>()]() { }
};
return 0;
}
}
//// [computedPropertyNames34.js]
function foo() {
return '';
}
var C = (function () {
function C() {
}
C.bar = function () {
var obj = {
[foo()]() {
}
};
return 0;
};
return C;
})();
tests/baselines/reference/computedPropertyNames35.errors.txt
+14
View File
@@ -0,0 +1,14 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames35.ts(4,5): error TS1169: Computed property names are not allowed in interfaces.
tests/cases/conformance/es6/computedProperties/computedPropertyNames35.ts(4,10): error TS2466: A computed property name cannot reference a type parameter from its containing type.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames35.ts (2 errors) ====
function foo<T>() { return '' }
interface I<T> {
bar(): string;
[foo<T>()](): void;
~~~~~~~~~~
!!! error TS1169: Computed property names are not allowed in interfaces.
~
!!! error TS2466: A computed property name cannot reference a type parameter from its containing type.
}
tests/baselines/reference/computedPropertyNames36.errors.txt
+16
View File
@@ -0,0 +1,16 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames36.ts(8,5): error TS2411: Property '["get1"]' of type 'Foo' is not assignable to string index type 'Foo2'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames36.ts (1 errors) ====
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: Foo2;
// Computed properties
get ["get1"]() { return new Foo }
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2411: Property '["get1"]' of type 'Foo' is not assignable to string index type 'Foo2'.
set ["set1"](p: Foo2) { }
}
tests/baselines/reference/computedPropertyNames36.js
+42
View File
@@ -0,0 +1,42 @@
//// [computedPropertyNames36.ts]
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: Foo2;
// Computed properties
get ["get1"]() { return new Foo }
set ["set1"](p: Foo2) { }
}
//// [computedPropertyNames36.js]
var Foo = (function () {
function Foo() {
}
return Foo;
})();
var Foo2 = (function () {
function Foo2() {
}
return Foo2;
})();
var C = (function () {
function C() {
}
Object.defineProperty(C.prototype, "get1", {
// Computed properties
get: function () {
return new Foo;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, "set1", {
set: function (p) {
},
enumerable: true,
configurable: true
});
return C;
})();
tests/baselines/reference/computedPropertyNames37.js
+42
View File
@@ -0,0 +1,42 @@
//// [computedPropertyNames37.ts]
class Foo { x }
class Foo2 { x; y }
class C {
[s: number]: Foo2;
// Computed properties
get ["get1"]() { return new Foo }
set ["set1"](p: Foo2) { }
}
//// [computedPropertyNames37.js]
var Foo = (function () {
function Foo() {
}
return Foo;
})();
var Foo2 = (function () {
function Foo2() {
}
return Foo2;
})();
var C = (function () {
function C() {
}
Object.defineProperty(C.prototype, "get1", {
// Computed properties
get: function () {
return new Foo;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, "set1", {
set: function (p) {
},
enumerable: true,
configurable: true
});
return C;
})();
tests/baselines/reference/computedPropertyNames37.types
+26
View File
@@ -0,0 +1,26 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames37.ts ===
class Foo { x }
>Foo : Foo
>x : any
class Foo2 { x; y }
>Foo2 : Foo2
>x : any
>y : any
class C {
>C : C
[s: number]: Foo2;
>s : number
>Foo2 : Foo2
// Computed properties
get ["get1"]() { return new Foo }
>new Foo : Foo
>Foo : typeof Foo
set ["set1"](p: Foo2) { }
>p : Foo2
>Foo2 : Foo2
}
tests/baselines/reference/computedPropertyNames38.errors.txt
+16
View File
@@ -0,0 +1,16 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames38.ts(8,5): error TS2411: Property '[1 << 6]' of type 'Foo' is not assignable to string index type 'Foo2'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames38.ts (1 errors) ====
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: Foo2;
// Computed properties
get [1 << 6]() { return new Foo }
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2411: Property '[1 << 6]' of type 'Foo' is not assignable to string index type 'Foo2'.
set [1 << 6](p: Foo2) { }
}
tests/baselines/reference/computedPropertyNames38.js
+42
View File
@@ -0,0 +1,42 @@
//// [computedPropertyNames38.ts]
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: Foo2;
// Computed properties
get [1 << 6]() { return new Foo }
set [1 << 6](p: Foo2) { }
}
//// [computedPropertyNames38.js]
var Foo = (function () {
function Foo() {
}
return Foo;
})();
var Foo2 = (function () {
function Foo2() {
}
return Foo2;
})();
var C = (function () {
function C() {
}
Object.defineProperty(C.prototype, 1 << 6, {
// Computed properties
get: function () {
return new Foo;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, 1 << 6, {
set: function (p) {
},
enumerable: true,
configurable: true
});
return C;
})();
tests/baselines/reference/computedPropertyNames39.errors.txt
+16
View File
@@ -0,0 +1,16 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames39.ts(8,5): error TS2412: Property '[1 << 6]' of type 'Foo' is not assignable to numeric index type 'Foo2'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames39.ts (1 errors) ====
class Foo { x }
class Foo2 { x; y }
class C {
[s: number]: Foo2;
// Computed properties
get [1 << 6]() { return new Foo }
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2412: Property '[1 << 6]' of type 'Foo' is not assignable to numeric index type 'Foo2'.
set [1 << 6](p: Foo2) { }
}
tests/baselines/reference/computedPropertyNames39.js
+42
View File
@@ -0,0 +1,42 @@
//// [computedPropertyNames39.ts]
class Foo { x }
class Foo2 { x; y }
class C {
[s: number]: Foo2;
// Computed properties
get [1 << 6]() { return new Foo }
set [1 << 6](p: Foo2) { }
}
//// [computedPropertyNames39.js]
var Foo = (function () {
function Foo() {
}
return Foo;
})();
var Foo2 = (function () {
function Foo2() {
}
return Foo2;
})();
var C = (function () {
function C() {
}
Object.defineProperty(C.prototype, 1 << 6, {
// Computed properties
get: function () {
return new Foo;
},
enumerable: true,
configurable: true
});
Object.defineProperty(C.prototype, 1 << 6, {
set: function (p) {
},
enumerable: true,
configurable: true
});
return C;
})();
tests/baselines/reference/computedPropertyNames4.js
+35
View File
@@ -0,0 +1,35 @@
//// [computedPropertyNames4.ts]
var s: string;
var n: number;
var a: any;
var v = {
[s]: 0,
[n]: n,
[s + s]: 1,
[s + n]: 2,
[+s]: s,
[""]: 0,
[0]: 0,
[a]: 1,
[<any>true]: 0,
[`hello bye`]: 0,
[`hello ${a} bye`]: 0
}
//// [computedPropertyNames4.js]
var s;
var n;
var a;
var v = {
[s]: 0,
[n]: n,
[s + s]: 1,
[s + n]: 2,
[+s]: s,
[""]: 0,
[0]: 0,
[a]: 1,
[true]: 0,
[`hello bye`]: 0,
[`hello ${a} bye`]: 0
};
tests/baselines/reference/computedPropertyNames4.types
+48
View File
@@ -0,0 +1,48 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames4.ts ===
var s: string;
>s : string
var n: number;
>n : number
var a: any;
>a : any
var v = {
>v : {}
>{ [s]: 0, [n]: n, [s + s]: 1, [s + n]: 2, [+s]: s, [""]: 0, [0]: 0, [a]: 1, [<any>true]: 0, [`hello bye`]: 0, [`hello ${a} bye`]: 0} : {}
[s]: 0,
>s : string
[n]: n,
>n : number
>n : number
[s + s]: 1,
>s + s : string
>s : string
>s : string
[s + n]: 2,
>s + n : string
>s : string
>n : number
[+s]: s,
>+s : number
>s : string
>s : string
[""]: 0,
[0]: 0,
[a]: 1,
>a : any
[<any>true]: 0,
><any>true : any
[`hello bye`]: 0,
[`hello ${a} bye`]: 0
>a : any
}
tests/baselines/reference/computedPropertyNames40.errors.txt
+16
View File
@@ -0,0 +1,16 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames40.ts(8,5): error TS2411: Property '[""]' of type '() => Foo' is not assignable to string index type '() => Foo2'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames40.ts (1 errors) ====
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: () => Foo2;
// Computed properties
[""]() { return new Foo }
~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2411: Property '[""]' of type '() => Foo' is not assignable to string index type '() => Foo2'.
[""]() { return new Foo2 }
}
tests/baselines/reference/computedPropertyNames40.js
+35
View File
@@ -0,0 +1,35 @@
//// [computedPropertyNames40.ts]
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: () => Foo2;
// Computed properties
[""]() { return new Foo }
[""]() { return new Foo2 }
}
//// [computedPropertyNames40.js]
var Foo = (function () {
function Foo() {
}
return Foo;
})();
var Foo2 = (function () {
function Foo2() {
}
return Foo2;
})();
var C = (function () {
function C() {
}
// Computed properties
C.prototype[""] = function () {
return new Foo;
};
C.prototype[""] = function () {
return new Foo2;
};
return C;
})();
tests/baselines/reference/computedPropertyNames41.js
+31
View File
@@ -0,0 +1,31 @@
//// [computedPropertyNames41.ts]
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: () => Foo2;
// Computed properties
static [""]() { return new Foo }
}
//// [computedPropertyNames41.js]
var Foo = (function () {
function Foo() {
}
return Foo;
})();
var Foo2 = (function () {
function Foo2() {
}
return Foo2;
})();
var C = (function () {
function C() {
}
// Computed properties
C[""] = function () {
return new Foo;
};
return C;
})();
tests/baselines/reference/computedPropertyNames41.types
+22
View File
@@ -0,0 +1,22 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames41.ts ===
class Foo { x }
>Foo : Foo
>x : any
class Foo2 { x; y }
>Foo2 : Foo2
>x : any
>y : any
class C {
>C : C
[s: string]: () => Foo2;
>s : string
>Foo2 : Foo2
// Computed properties
static [""]() { return new Foo }
>new Foo : Foo
>Foo : typeof Foo
}
tests/baselines/reference/computedPropertyNames42.errors.txt
+18
View File
@@ -0,0 +1,18 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames42.ts(8,5): error TS1166: Computed property names are not allowed in class property declarations.
tests/cases/conformance/es6/computedProperties/computedPropertyNames42.ts(8,5): error TS2411: Property '[""]' of type 'Foo' is not assignable to string index type 'Foo2'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames42.ts (2 errors) ====
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: Foo2;
// Computed properties
[""]: Foo;
~~~~
!!! error TS1166: Computed property names are not allowed in class property declarations.
~~~~~~~~~~
!!! error TS2411: Property '[""]' of type 'Foo' is not assignable to string index type 'Foo2'.
}
tests/baselines/reference/computedPropertyNames43.errors.txt
+18
View File
@@ -0,0 +1,18 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames43.ts(10,5): error TS2411: Property '["get1"]' of type 'Foo' is not assignable to string index type 'Foo2'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames43.ts (1 errors) ====
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: Foo2;
}
class D extends C {
// Computed properties
get ["get1"]() { return new Foo }
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2411: Property '["get1"]' of type 'Foo' is not assignable to string index type 'Foo2'.
set ["set1"](p: Foo2) { }
}
tests/baselines/reference/computedPropertyNames43.js
+57
View File
@@ -0,0 +1,57 @@
//// [computedPropertyNames43.ts]
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: Foo2;
}
class D extends C {
// Computed properties
get ["get1"]() { return new Foo }
set ["set1"](p: Foo2) { }
}
//// [computedPropertyNames43.js]
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Foo = (function () {
function Foo() {
}
return Foo;
})();
var Foo2 = (function () {
function Foo2() {
}
return Foo2;
})();
var C = (function () {
function C() {
}
return C;
})();
var D = (function (_super) {
__extends(D, _super);
function D() {
_super.apply(this, arguments);
}
Object.defineProperty(D.prototype, "get1", {
// Computed properties
get: function () {
return new Foo;
},
enumerable: true,
configurable: true
});
Object.defineProperty(D.prototype, "set1", {
set: function (p) {
},
enumerable: true,
configurable: true
});
return D;
})(C);
tests/baselines/reference/computedPropertyNames44.errors.txt
+20
View File
@@ -0,0 +1,20 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames44.ts(6,5): error TS2411: Property '["get1"]' of type 'Foo' is not assignable to string index type 'Foo2'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames44.ts(10,5): error TS2411: Property '["set1"]' of type 'Foo' is not assignable to string index type 'Foo2'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames44.ts (2 errors) ====
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: Foo2;
get ["get1"]() { return new Foo }
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2411: Property '["get1"]' of type 'Foo' is not assignable to string index type 'Foo2'.
}
class D extends C {
set ["set1"](p: Foo) { }
~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2411: Property '["set1"]' of type 'Foo' is not assignable to string index type 'Foo2'.
}
tests/baselines/reference/computedPropertyNames44.js
+55
View File
@@ -0,0 +1,55 @@
//// [computedPropertyNames44.ts]
class Foo { x }
class Foo2 { x; y }
class C {
[s: string]: Foo2;
get ["get1"]() { return new Foo }
}
class D extends C {
set ["set1"](p: Foo) { }
}
//// [computedPropertyNames44.js]
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Foo = (function () {
function Foo() {
}
return Foo;
})();
var Foo2 = (function () {
function Foo2() {
}
return Foo2;
})();
var C = (function () {
function C() {
}
Object.defineProperty(C.prototype, "get1", {
get: function () {
return new Foo;
},
enumerable: true,
configurable: true
});
return C;
})();
var D = (function (_super) {
__extends(D, _super);
function D() {
_super.apply(this, arguments);
}
Object.defineProperty(D.prototype, "set1", {
set: function (p) {
},
enumerable: true,
configurable: true
});
return D;
})(C);
tests/baselines/reference/computedPropertyNames45.errors.txt
+18
View File
@@ -0,0 +1,18 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames45.ts(11,5): error TS2411: Property '["set1"]' of type 'Foo' is not assignable to string index type 'Foo2'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames45.ts (1 errors) ====
class Foo { x }
class Foo2 { x; y }
class C {
get ["get1"]() { return new Foo }
}
class D extends C {
// No error when the indexer is in a class more derived than the computed property
[s: string]: Foo2;
set ["set1"](p: Foo) { }
~~~~~~~~~~~~~~~~~~~~~~~~
!!! error TS2411: Property '["set1"]' of type 'Foo' is not assignable to string index type 'Foo2'.
}
tests/baselines/reference/computedPropertyNames45.js
+56
View File
@@ -0,0 +1,56 @@
//// [computedPropertyNames45.ts]
class Foo { x }
class Foo2 { x; y }
class C {
get ["get1"]() { return new Foo }
}
class D extends C {
// No error when the indexer is in a class more derived than the computed property
[s: string]: Foo2;
set ["set1"](p: Foo) { }
}
//// [computedPropertyNames45.js]
var __extends = this.__extends || function (d, b) {
for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
function __() { this.constructor = d; }
__.prototype = b.prototype;
d.prototype = new __();
};
var Foo = (function () {
function Foo() {
}
return Foo;
})();
var Foo2 = (function () {
function Foo2() {
}
return Foo2;
})();
var C = (function () {
function C() {
}
Object.defineProperty(C.prototype, "get1", {
get: function () {
return new Foo;
},
enumerable: true,
configurable: true
});
return C;
})();
var D = (function (_super) {
__extends(D, _super);
function D() {
_super.apply(this, arguments);
}
Object.defineProperty(D.prototype, "set1", {
set: function (p) {
},
enumerable: true,
configurable: true
});
return D;
})(C);
tests/baselines/reference/computedPropertyNames46.js
+9
View File
@@ -0,0 +1,9 @@
//// [computedPropertyNames46.ts]
var o = {
["" || 0]: 0
};
//// [computedPropertyNames46.js]
var o = {
["" || 0]: 0
};
tests/baselines/reference/computedPropertyNames46.types
+9
View File
@@ -0,0 +1,9 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames46.ts ===
var o = {
>o : {}
>{ ["" || 0]: 0} : {}
["" || 0]: 0
>"" || 0 : string | number
};
tests/baselines/reference/computedPropertyNames47.js
+19
View File
@@ -0,0 +1,19 @@
//// [computedPropertyNames47.ts]
enum E1 { x }
enum E2 { x }
var o = {
[E1.x || E2.x]: 0
};
//// [computedPropertyNames47.js]
var E1;
(function (E1) {
E1[E1["x"] = 0] = "x";
})(E1 || (E1 = {}));
var E2;
(function (E2) {
E2[E2["x"] = 0] = "x";
})(E2 || (E2 = {}));
var o = {
[0 /* x */ || 0 /* x */]: 0
};
tests/baselines/reference/computedPropertyNames47.types
+23
View File
@@ -0,0 +1,23 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames47.ts ===
enum E1 { x }
>E1 : E1
>x : E1
enum E2 { x }
>E2 : E2
>x : E2
var o = {
>o : {}
>{ [E1.x || E2.x]: 0} : {}
[E1.x || E2.x]: 0
>E1.x || E2.x : E1 | E2
>E1.x : E1
>E1 : typeof E1
>x : E1
>E2.x : E2
>E2 : typeof E2
>x : E2
};
tests/baselines/reference/computedPropertyNames48.js
+34
View File
@@ -0,0 +1,34 @@
//// [computedPropertyNames48.ts]
declare function extractIndexer<T>(p: { [n: number]: T }): T;
enum E { x }
var a: any;
extractIndexer({
[a]: ""
}); // Should return string
extractIndexer({
[E.x]: ""
}); // Should return string
extractIndexer({
["" || 0]: ""
}); // Should return any (widened form of undefined)
//// [computedPropertyNames48.js]
var E;
(function (E) {
E[E["x"] = 0] = "x";
})(E || (E = {}));
var a;
extractIndexer({
[a]: ""
}); // Should return string
extractIndexer({
[0 /* x */]: ""
}); // Should return string
extractIndexer({
["" || 0]: ""
}); // Should return any (widened form of undefined)

Some files were not shown because too many files have changed in this diff Show More