maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Merge branch 'master' into objectLiteralWidening

Browse source 
Conflicts:
	src/compiler/checker.ts
	tests/baselines/reference/intTypeCheck.errors.txt
This commit is contained in:
Anders Hejlsberg 2015-01-27 06:28:04 -08:00
parent a298835f01 0dcc168105
commit 5c3da7cc8c
295 changed files with 5183 additions and 462 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
src/compiler/binder.ts
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);
}
}
}
}

362
src/compiler/checker.ts
View file

@ -337,6 +337,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 +1679,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 +1725,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 +2641,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);
}
@ -4768,6 +4787,7 @@ module ts {
return type;
}
}
/*Transitively mark all linked imports as referenced*/
function markLinkedImportsAsReferenced(node: ImportDeclaration): void {
var nodeLinks = getNodeLinks(node);
@ -4864,6 +4884,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) {
@ -4878,26 +4901,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) {
@ -4921,7 +4924,7 @@ module ts {
return unknownType;
}
var container = getSuperContainer(node);
var container = getSuperContainer(node, /*includeFunctions*/ true);
if (container) {
var canUseSuperExpression = false;
@ -4939,7 +4942,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;
}
@ -4994,7 +4997,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 {
@ -5176,13 +5182,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;
}
@ -5381,7 +5396,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',
@ -5406,80 +5431,95 @@ 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);
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);
}
}
}
@ -6782,7 +6822,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);
@ -7063,10 +7103,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);
}
@ -7437,7 +7489,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;
@ -7457,9 +7509,9 @@ module ts {
}
}
}
checkAndStoreTypeOfAccessors(getSymbolOfNode(node));
}
checkAndStoreTypeOfAccessors(getSymbolOfNode(node));
}
checkFunctionLikeDeclaration(node);
@ -7875,7 +7927,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
@ -8104,7 +8161,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);
}
@ -8447,45 +8505,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);
@ -8495,9 +8515,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;
@ -8514,9 +8549,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.
@ -8810,8 +8887,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;
@ -10001,8 +10077,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);
}
}
@ -10438,22 +10514,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);
}
}

5
src/compiler/diagnosticInformationMap.generated.ts
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 },
};
}

25
src/compiler/diagnosticMessages.json
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
}
}

32
src/compiler/emitter.ts
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);
}

44
src/compiler/utilities.ts
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;

12
src/harness/fourslash.ts
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 + '"/>');

73
src/services/services.ts
View file

@ -59,7 +59,7 @@ module ts {
isOpen: boolean;
version: string;
scriptSnapshot: IScriptSnapshot;
nameTable: Map<string>;
getNamedDeclarations(): Declaration[];
}
@ -750,6 +750,7 @@ module ts {
public isOpen: boolean;
public languageVersion: ScriptTarget;
public identifiers: Map<string>;
public nameTable: Map<string>;
private namedDeclarations: Declaration[];
@ -1546,6 +1547,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 +1580,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 +3241,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 +3794,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 +3874,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 +3943,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 +4155,7 @@ module ts {
}
function getReferencesForSuperKeyword(superKeyword: Node): ReferenceEntry[] {
var searchSpaceNode = getSuperContainer(superKeyword);
var searchSpaceNode = getSuperContainer(superKeyword, /*includeFunctions*/ false);
if (!searchSpaceNode) {
return undefined;
}
@ -4149,7 +4190,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 +4232,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;
}

12
tests/baselines/reference/FunctionDeclaration8_es6.errors.txt
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'.

9
tests/baselines/reference/FunctionDeclaration9_es6.errors.txt
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.
}

12
tests/baselines/reference/FunctionPropertyAssignments5_es6.errors.txt
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'.

5
tests/baselines/reference/MemberFunctionDeclaration3_es6.errors.txt
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'.
}

7
tests/baselines/reference/complicatedPrivacy.errors.txt
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'.
}) {
}

13
tests/baselines/reference/computedPropertyNames1.errors.txt
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.
}

14
tests/baselines/reference/computedPropertyNames1.js Normal file
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
};

12
tests/baselines/reference/computedPropertyNames1.types Normal file
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
}

46
tests/baselines/reference/computedPropertyNames10.js Normal file
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`]() {
}
};

46
tests/baselines/reference/computedPropertyNames10.types Normal file
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
}

52
tests/baselines/reference/computedPropertyNames11.js Normal file
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;
}
};

53
tests/baselines/reference/computedPropertyNames11.types Normal file
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
}

52
tests/baselines/reference/computedPropertyNames12.errors.txt Normal file
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.
}

49
tests/baselines/reference/computedPropertyNames13.js Normal file
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;
})();

45
tests/baselines/reference/computedPropertyNames13.types Normal file
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
}

30
tests/baselines/reference/computedPropertyNames14.errors.txt Normal file
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'.
}

30
tests/baselines/reference/computedPropertyNames14.js Normal file
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;
})();

17
tests/baselines/reference/computedPropertyNames15.errors.txt Normal file
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'.
}

25
tests/baselines/reference/computedPropertyNames15.js Normal file
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;
})();

99
tests/baselines/reference/computedPropertyNames16.js Normal file
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;
})();

52
tests/baselines/reference/computedPropertyNames16.types Normal file
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
}

30
tests/baselines/reference/computedPropertyNames17.errors.txt Normal file
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'.
}

57
tests/baselines/reference/computedPropertyNames17.js Normal file
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;
})();

13
tests/baselines/reference/computedPropertyNames18.js Normal file
View file

@ -0,0 +1,13 @@
//// [computedPropertyNames18.ts]
function foo() {
var obj = {
[this.bar]: 0
}
}
//// [computedPropertyNames18.js]
function foo() {
var obj = {
[this.bar]: 0
};
}

14
tests/baselines/reference/computedPropertyNames18.types Normal file
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
}
}

11
tests/baselines/reference/computedPropertyNames19.errors.txt Normal file
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.
}
}

14
tests/baselines/reference/computedPropertyNames19.js Normal file
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 = {}));

20
tests/baselines/reference/computedPropertyNames2.errors.txt
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.
}

48
tests/baselines/reference/computedPropertyNames2.js Normal file
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;
})();

9
tests/baselines/reference/computedPropertyNames20.js Normal file
View file

@ -0,0 +1,9 @@
//// [computedPropertyNames20.ts]
var obj = {
[this.bar]: 0
}
//// [computedPropertyNames20.js]
var obj = {
[this.bar]: 0
};

10
tests/baselines/reference/computedPropertyNames20.types Normal file
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
}

12
tests/baselines/reference/computedPropertyNames21.errors.txt Normal file
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.
}

19
tests/baselines/reference/computedPropertyNames21.js Normal file
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;
})();

23
tests/baselines/reference/computedPropertyNames22.js Normal file
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;
})();

21
tests/baselines/reference/computedPropertyNames22.types Normal file
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;
}
}

14
tests/baselines/reference/computedPropertyNames23.errors.txt Normal file
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.
]() { }
}

21
tests/baselines/reference/computedPropertyNames23.js Normal file
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;
})();

16
tests/baselines/reference/computedPropertyNames24.errors.txt Normal file
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.
}

38
tests/baselines/reference/computedPropertyNames24.js Normal file
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);

44
tests/baselines/reference/computedPropertyNames25.js Normal file
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);

31
tests/baselines/reference/computedPropertyNames25.types Normal file
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;
}
}

18
tests/baselines/reference/computedPropertyNames26.errors.txt Normal file
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.
]() { }
}

40
tests/baselines/reference/computedPropertyNames26.js Normal file
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);

11
tests/baselines/reference/computedPropertyNames27.errors.txt Normal file
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.
}

28
tests/baselines/reference/computedPropertyNames27.js Normal file
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);

35
tests/baselines/reference/computedPropertyNames28.js Normal file
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);

26
tests/baselines/reference/computedPropertyNames28.types Normal file
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
};
}
}

28
tests/baselines/reference/computedPropertyNames29.js Normal file
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;
})();

25
tests/baselines/reference/computedPropertyNames29.types Normal file
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;
}
}

24
tests/baselines/reference/computedPropertyNames3.errors.txt
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.
}

47
tests/baselines/reference/computedPropertyNames3.js Normal file
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;
})();

21
tests/baselines/reference/computedPropertyNames30.errors.txt Normal file
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
};
}
}
}

45
tests/baselines/reference/computedPropertyNames30.js Normal file
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);

49
tests/baselines/reference/computedPropertyNames31.js Normal file
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);

35
tests/baselines/reference/computedPropertyNames31.types Normal file
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;
}
}

13
tests/baselines/reference/computedPropertyNames32.errors.txt Normal file
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.
}

23
tests/baselines/reference/computedPropertyNames32.js Normal file
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;
})();

27
tests/baselines/reference/computedPropertyNames33.js Normal file
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;
})();

25
tests/baselines/reference/computedPropertyNames33.types Normal file
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;
}
}

15
tests/baselines/reference/computedPropertyNames34.errors.txt Normal file
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;
}
}

27
tests/baselines/reference/computedPropertyNames34.js Normal file
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;
})();

14
tests/baselines/reference/computedPropertyNames35.errors.txt Normal file
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.
}

16
tests/baselines/reference/computedPropertyNames36.errors.txt Normal file
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) { }
}

42
tests/baselines/reference/computedPropertyNames36.js Normal file
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;
})();

42
tests/baselines/reference/computedPropertyNames37.js Normal file
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;
})();

26
tests/baselines/reference/computedPropertyNames37.types Normal file
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
}

16
tests/baselines/reference/computedPropertyNames38.errors.txt Normal file
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) { }
}

42
tests/baselines/reference/computedPropertyNames38.js Normal file
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;
})();

16
tests/baselines/reference/computedPropertyNames39.errors.txt Normal file
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) { }
}

42
tests/baselines/reference/computedPropertyNames39.js Normal file
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;
})();

35
tests/baselines/reference/computedPropertyNames4.js Normal file
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
};

48
tests/baselines/reference/computedPropertyNames4.types Normal file
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
}

16
tests/baselines/reference/computedPropertyNames40.errors.txt Normal file
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 }
}

35
tests/baselines/reference/computedPropertyNames40.js Normal file
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;
})();

31
tests/baselines/reference/computedPropertyNames41.js Normal file
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;
})();

22
tests/baselines/reference/computedPropertyNames41.types Normal file
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
}

18
tests/baselines/reference/computedPropertyNames42.errors.txt Normal file
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'.
}

18
tests/baselines/reference/computedPropertyNames43.errors.txt Normal file
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) { }
}

57
tests/baselines/reference/computedPropertyNames43.js Normal file
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);

20
tests/baselines/reference/computedPropertyNames44.errors.txt Normal file
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'.
}

55
tests/baselines/reference/computedPropertyNames44.js Normal file
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);

18
tests/baselines/reference/computedPropertyNames45.errors.txt Normal file
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'.
}

56
tests/baselines/reference/computedPropertyNames45.js Normal file
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);

9
tests/baselines/reference/computedPropertyNames46.js Normal file
View file

@ -0,0 +1,9 @@
//// [computedPropertyNames46.ts]
var o = {
["" || 0]: 0
};
//// [computedPropertyNames46.js]
var o = {
["" || 0]: 0
};

9
tests/baselines/reference/computedPropertyNames46.types Normal file
View file

@ -0,0 +1,9 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames46.ts ===
var o = {
>o : {}
>{ ["" || 0]: 0} : {}
["" || 0]: 0
>"" || 0 : string | number
};

19
tests/baselines/reference/computedPropertyNames47.js Normal file
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
};

23
tests/baselines/reference/computedPropertyNames47.types Normal file
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
};

34
tests/baselines/reference/computedPropertyNames48.js Normal file
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)

47
tests/baselines/reference/computedPropertyNames48.types Normal file
View file

@ -0,0 +1,47 @@
=== tests/cases/conformance/es6/computedProperties/computedPropertyNames48.ts ===
declare function extractIndexer<T>(p: { [n: number]: T }): T;
>extractIndexer : <T>(p: { [n: number]: T; }) => T
>T : T
>p : { [n: number]: T; }
>n : number
>T : T
>T : T
enum E { x }
>E : E
>x : E
var a: any;
>a : any
extractIndexer({
>extractIndexer({ [a]: ""}) : string
>extractIndexer : <T>(p: { [n: number]: T; }) => T
>{ [a]: ""} : { [x: number]: string; }
[a]: ""
>a : any
}); // Should return string
extractIndexer({
>extractIndexer({ [E.x]: ""}) : string
>extractIndexer : <T>(p: { [n: number]: T; }) => T
>{ [E.x]: ""} : { [x: number]: string; }
[E.x]: ""
>E.x : E
>E : typeof E
>x : E
}); // Should return string
extractIndexer({
>extractIndexer({ ["" || 0]: ""}) : any
>extractIndexer : <T>(p: { [n: number]: T; }) => T
>{ ["" || 0]: ""} : { [x: number]: undefined; }
["" || 0]: ""
>"" || 0 : string | number
}); // Should return any (widened form of undefined)

30
tests/baselines/reference/computedPropertyNames5.errors.txt Normal file
View file

@ -0,0 +1,30 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames5.ts(3,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames5.ts(4,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames5.ts(5,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames5.ts(6,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames5.ts(7,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames5.ts(8,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames5.ts (6 errors) ====
var b: boolean;
var v = {
[b]: 0,
~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
[true]: 1,
~~~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
[[]]: 0,
~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
[{}]: 0,
~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
[undefined]: undefined,
~~~~~~~~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
[null]: null
~~~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
}

21
tests/baselines/reference/computedPropertyNames5.js Normal file
View file

@ -0,0 +1,21 @@
//// [computedPropertyNames5.ts]
var b: boolean;
var v = {
[b]: 0,
[true]: 1,
[[]]: 0,
[{}]: 0,
[undefined]: undefined,
[null]: null
}
//// [computedPropertyNames5.js]
var b;
var v = {
[b]: 0,
[true]: 1,
[[]]: 0,
[{}]: 0,
[undefined]: undefined,
[null]: null
};

17
tests/baselines/reference/computedPropertyNames6.errors.txt Normal file
View file

@ -0,0 +1,17 @@
tests/cases/conformance/es6/computedProperties/computedPropertyNames6.ts(6,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
tests/cases/conformance/es6/computedProperties/computedPropertyNames6.ts(7,5): error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
==== tests/cases/conformance/es6/computedProperties/computedPropertyNames6.ts (2 errors) ====
var p1: number | string;
var p2: number | number[];
var p3: string | boolean;
var v = {
[p1]: 0,
[p2]: 1,
~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
[p3]: 2
~~~~
!!! error TS2464: A computed property name must be of type 'string', 'number', or 'any'.
}

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