diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 18e57303c12..7db62ed487d 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -959,7 +959,7 @@ namespace ts { case SyntaxKind.ClassDeclaration: case SyntaxKind.ClassExpression: case SyntaxKind.InterfaceDeclaration: - if (result = getSymbol(getSymbolOfNode(location).members, name, meaning & SymbolFlags.Type)) { + if (result = getSymbol(getMembersOfSymbol(getSymbolOfNode(location)), name, meaning & SymbolFlags.Type)) { if (!isTypeParameterSymbolDeclaredInContainer(result, location)) { // ignore type parameters not declared in this container result = undefined; @@ -2895,6 +2895,9 @@ namespace ts { } function getNameOfSymbol(symbol: Symbol): string { + if (symbol.flags & SymbolFlags.Dynamic) { + return unescapeIdentifier(symbol.name); + } if (symbol.declarations && symbol.declarations.length) { const declaration = symbol.declarations[0]; if (declaration.name) { @@ -5133,7 +5136,7 @@ namespace ts { function resolveDeclaredMembers(type: InterfaceType): InterfaceTypeWithDeclaredMembers { if (!(type).declaredProperties) { const symbol = type.symbol; - (type).declaredProperties = getNamedMembers(symbol.members); + (type).declaredProperties = getNamedMembers(getMembersOfSymbol(symbol)); (type).declaredCallSignatures = getSignaturesOfSymbol(symbol.members.get("__call")); (type).declaredConstructSignatures = getSignaturesOfSymbol(symbol.members.get("__new")); (type).declaredStringIndexInfo = getIndexInfoOfSymbol(symbol, IndexKind.String); @@ -5142,6 +5145,137 @@ namespace ts { return type; } + function getMembersOfSymbol(symbol: Symbol) { + const links = getSymbolLinks(symbol); + if (!links.resolvedMembers) { + links.resolvedMembers = emptySymbols; + const dynamicMembers = getDynamicMembersOfSymbol(symbol); + if (!dynamicMembers || dynamicMembers.size === 0) { + return links.resolvedMembers = symbol.members || emptySymbols; + } + if (!symbol.members || symbol.members.size === 0) { + return links.resolvedMembers = dynamicMembers; + } + const resolvedMembers = createMap(); + mergeSymbolTable(resolvedMembers, symbol.members); + mergeSymbolTable(resolvedMembers, dynamicMembers); + return links.resolvedMembers = resolvedMembers; + } + return links.resolvedMembers; + } + + function getDynamicMembersOfSymbol(symbol: Symbol) { + if (symbol.flags & (SymbolFlags.Class | SymbolFlags.Interface | SymbolFlags.TypeLiteral | SymbolFlags.ObjectLiteral)) { + const links = getSymbolLinks(symbol); + if (!links.dynamicMembers) { + const members = createMap(); + for (const decl of symbol.declarations) { + resolveDynamicMembersOfSymbol(decl, members); + } + links.dynamicMembers = members; + } + return links.dynamicMembers; + } + } + + function resolveDynamicMembersOfSymbol(node: Declaration, symbolTable: SymbolTable) { + switch (node.kind) { + case SyntaxKind.InterfaceDeclaration: + case SyntaxKind.ClassDeclaration: + case SyntaxKind.ClassExpression: + case SyntaxKind.TypeLiteral: + resolveDynamicMembersOfClassOrInterfaceOrTypeLiteralNode(node, symbolTable); + break; + case SyntaxKind.ObjectLiteralExpression: + resolveDynamicMembersOfObjectLiteralExpression(node, symbolTable); + break; + } + } + + function resolveDynamicMembersOfClassOrInterfaceOrTypeLiteralNode(node: ClassLikeDeclaration | InterfaceDeclaration | TypeLiteralNode, symbolTable: SymbolTable) { + for (const member of node.members) { + if (member.name && isComputedPropertyName(member.name) && isEntityNameExpression(member.name.expression)) { + bindDynamicMember(symbolTable, node.symbol, member); + } + } + } + + function resolveDynamicMembersOfObjectLiteralExpression(node: ObjectLiteralExpression, symbolTable: SymbolTable) { + for (const member of node.properties) { + if (member.name && isComputedPropertyName(member.name) && isEntityNameExpression(member.name.expression)) { + bindDynamicMember(symbolTable, node.symbol, member); + } + } + } + + function bindDynamicMember(symbolTable: SymbolTable, parent: Symbol, member: ClassElement | TypeElement | ObjectLiteralElement) { + const links = getNodeLinks(member); + if (!links.resolvedSymbol) { + switch (member.kind) { + case SyntaxKind.PropertyDeclaration: + case SyntaxKind.PropertySignature: + return resolveDynamicMember(symbolTable, parent, member, + SymbolFlags.Property | ((member).questionToken ? SymbolFlags.Optional : SymbolFlags.None), + SymbolFlags.PropertyExcludes); + case SyntaxKind.PropertyAssignment: + return resolveDynamicMember(symbolTable, parent, member, SymbolFlags.Property, SymbolFlags.PropertyExcludes); + case SyntaxKind.MethodDeclaration: + case SyntaxKind.MethodSignature: + return resolveDynamicMember(symbolTable, parent, member, + SymbolFlags.Method | ((member).questionToken ? SymbolFlags.Optional : SymbolFlags.None), + isObjectLiteralMethod(member) ? SymbolFlags.PropertyExcludes : SymbolFlags.MethodExcludes); + case SyntaxKind.GetAccessor: + return resolveDynamicMember(symbolTable, parent, member, SymbolFlags.GetAccessor, SymbolFlags.GetAccessorExcludes); + case SyntaxKind.SetAccessor: + return resolveDynamicMember(symbolTable, parent, member, SymbolFlags.SetAccessor, SymbolFlags.SetAccessorExcludes); + } + } + return links.resolvedSymbol; + } + + function resolveDynamicMember(symbolTable: SymbolTable, parent: Symbol, member: ClassElement | TypeElement | ObjectLiteralElement, includes: SymbolFlags, excludes: SymbolFlags) { + Debug.assert(isComputedPropertyName(member.name)); + const nameType = checkComputedPropertyName(member.name); + if (nameType.flags & TypeFlags.StringOrNumberLiteral) { + // TODO(rbuckton): ESSymbolLiteral + const memberName = escapeIdentifier((nameType).text); + let symbol = symbolTable.get(memberName); + if (!symbol) { + symbolTable.set(memberName, symbol = createSymbol(SymbolFlags.Dynamic, memberName)); + } + const staticMember = parent.members && parent.members.get(memberName); + if (symbol.flags & excludes || staticMember) { + const declarations = staticMember ? concatenate(staticMember.declarations, symbol.declarations) : symbol.declarations; + forEach(declarations, declaration => { + error(declaration.name || declaration, Diagnostics.Duplicate_identifier_0, memberName); + }); + error(member.name || member, Diagnostics.Duplicate_identifier_0, memberName); + symbol = createSymbol(SymbolFlags.Dynamic, memberName); + } + addDeclarationToSymbol(symbol, member, includes); + symbol.parent = parent; + return symbol; + } + return getNodeLinks(member).resolvedSymbol = member.symbol || unknownSymbol; + } + + function addDeclarationToSymbol(symbol: Symbol, member: ClassElement | TypeElement | ObjectLiteralElement, symbolFlags: SymbolFlags) { + symbol.flags |= symbolFlags; + getNodeLinks(member).resolvedSymbol = symbol; + if (!symbol.declarations) { + symbol.declarations = [member]; + } + else { + symbol.declarations.push(member); + } + if (symbolFlags & SymbolFlags.Value) { + const valueDeclaration = symbol.valueDeclaration; + if (!valueDeclaration || valueDeclaration.kind !== member.kind) { + symbol.valueDeclaration = member; + } + } + } + function getTypeWithThisArgument(type: Type, thisArgument?: Type): Type { if (getObjectFlags(type) & ObjectFlags.Reference) { const target = (type).target; @@ -5165,7 +5299,7 @@ namespace ts { let numberIndexInfo: IndexInfo; if (rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) { mapper = identityMapper; - members = source.symbol ? source.symbol.members : createSymbolTable(source.declaredProperties); + members = source.symbol ? getMembersOfSymbol(source.symbol) : createSymbolTable(source.declaredProperties); callSignatures = source.declaredCallSignatures; constructSignatures = source.declaredConstructSignatures; stringIndexInfo = source.declaredStringIndexInfo; @@ -5425,7 +5559,7 @@ namespace ts { setStructuredTypeMembers(type, members, callSignatures, constructSignatures, stringIndexInfo, numberIndexInfo); } else if (symbol.flags & SymbolFlags.TypeLiteral) { - const members = symbol.members; + const members = getMembersOfSymbol(symbol); const callSignatures = getSignaturesOfSymbol(members.get("__call")); const constructSignatures = getSignaturesOfSymbol(members.get("__new")); const stringIndexInfo = getIndexInfoOfSymbol(symbol, IndexKind.String); @@ -7396,7 +7530,7 @@ namespace ts { if (!links.resolvedType) { // Deferred resolution of members is handled by resolveObjectTypeMembers const aliasSymbol = getAliasSymbolForTypeNode(node); - if (node.symbol.members.size === 0 && !aliasSymbol) { + if (getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) { links.resolvedType = emptyTypeLiteralType; } else { @@ -15623,7 +15757,7 @@ namespace ts { function getInferredClassType(symbol: Symbol) { const links = getSymbolLinks(symbol); if (!links.inferredClassType) { - links.inferredClassType = createAnonymousType(symbol, symbol.members, emptyArray, emptyArray, /*stringIndexType*/ undefined, /*numberIndexType*/ undefined); + links.inferredClassType = createAnonymousType(symbol, getMembersOfSymbol(symbol), emptyArray, emptyArray, /*stringIndexType*/ undefined, /*numberIndexType*/ undefined); } return links.inferredClassType; } @@ -21741,7 +21875,7 @@ namespace ts { // (type parameters of classDeclaration/classExpression and interface are in member property of the symbol. // Note: that the memberFlags come from previous iteration. if (!(memberFlags & ModifierFlags.Static)) { - copySymbols(getSymbolOfNode(location).members, meaning & SymbolFlags.Type); + copySymbols(getMembersOfSymbol(getSymbolOfNode(location)), meaning & SymbolFlags.Type); } break; case SyntaxKind.FunctionExpression: @@ -23739,7 +23873,10 @@ namespace ts { function checkGrammarForNonSymbolComputedProperty(node: DeclarationName, message: DiagnosticMessage) { if (isDynamicName(node)) { - return grammarErrorOnNode(node, message); + if (!isEntityNameExpression((node).expression) || + (checkExpressionCached((node).expression).flags & TypeFlags.StringOrNumberLiteral) === 0) { + return grammarErrorOnNode(node, message); + } } } diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 57cf17f7100..bbe5dff8ef2 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2775,6 +2775,7 @@ namespace ts { ExportStar = 1 << 25, // Export * declaration Optional = 1 << 26, // Optional property Transient = 1 << 27, // Transient symbol (created during type check) + Dynamic = 1 << 28, // Dynamically resolved symbol from computed property Enum = RegularEnum | ConstEnum, Variable = FunctionScopedVariable | BlockScopedVariable, @@ -2869,6 +2870,8 @@ namespace ts { isDeclarationWithCollidingName?: boolean; // True if symbol is block scoped redeclaration bindingElement?: BindingElement; // Binding element associated with property symbol exportsSomeValue?: boolean; // True if module exports some value (not just types) + dynamicMembers?: SymbolTable; // Dynamic members with literal names resolved during check + resolvedMembers?: SymbolTable; } /* @internal */ diff --git a/src/harness/unittests/transform.ts b/src/harness/unittests/transform.ts index 71f50ed94a9..b66849917d6 100644 --- a/src/harness/unittests/transform.ts +++ b/src/harness/unittests/transform.ts @@ -68,6 +68,9 @@ namespace ts { transformers: { before: [replaceUndefinedWithVoid0], after: [replaceIdentifiersNamedOldNameWithNewName] + }, + compilerOptions: { + newLine: ts.NewLineKind.CarriageReturnLineFeed } }).outputText; }); diff --git a/tests/baselines/reference/dynamicNames.js b/tests/baselines/reference/dynamicNames.js new file mode 100644 index 00000000000..b5462f91c78 --- /dev/null +++ b/tests/baselines/reference/dynamicNames.js @@ -0,0 +1,150 @@ +//// [tests/cases/compiler/dynamicNames.ts] //// + +//// [module.ts] +export const c0 = "a"; +export const c1 = 1; +export interface T0 { + [c0]: number; + [c1]: string; +} +export declare class T1 implements T2 { + [c0]: number; + [c1]: string; +} +export declare class T2 extends T1 { +} +export declare type T3 = { + [c0]: number; + [c1]: string; +}; + +//// [main.ts] +import { c0, c1, T0, T1, T2, T3 } from "./module"; +import * as M from "./module"; + +namespace N { + export const c2 = "a"; + export const c3 = 1; + + export interface T4 { + [N.c2]: number; + [N.c3]: string; + } + export declare class T5 implements T4 { + [N.c2]: number; + [N.c3]: string; + } + export declare class T6 extends T5 { + } + export declare type T7 = { + [N.c2]: number; + [N.c3]: string; + }; +} + +const c4 = "a"; +const c5 = 1; +const c6 = "1"; + +interface T8 { + [c4]: number; + [c5]: string; +} +declare class T9 implements T8 { + [c4]: number; + [c5]: string; +} +declare class T10 extends T9 { +} +declare type T11 = { + [c4]: number; + [c5]: string; +}; + +interface T12 { + a: number; + 1: string; +} +declare class T13 implements T2 { + a: number; + 1: string; +} +declare class T14 extends T13 { +} +declare type T15 = { + a: number; + 1: string; +}; + +interface T16 { + [c5]: number; + [c6]: string; +} + + +let t0: T0; +let t1: T1; +let t2: T2; +let t3: T3; +let t0_1: M.T0; +let t1_1: M.T1; +let t2_1: M.T2; +let t3_1: M.T3; +let t4: N.T4; +let t5: N.T5; +let t6: N.T6; +let t7: N.T7; +let t8: T8; +let t9: T9; +let t10: T10; +let t11: T11; +let t12: T12; +let t13: T13; +let t14: T14; +let t15: T15; + +// assignability +t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, t3 = t1, t3 = t2; +t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, t7 = t5, t7 = t6; +t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, t14 = t0, t15 = t0; + +//// [module.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.c0 = "a"; +exports.c1 = 1; +//// [main.js] +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +var N; +(function (N) { + N.c2 = "a"; + N.c3 = 1; +})(N || (N = {})); +const c4 = "a"; +const c5 = 1; +const c6 = "1"; +let t0; +let t1; +let t2; +let t3; +let t0_1; +let t1_1; +let t2_1; +let t3_1; +let t4; +let t5; +let t6; +let t7; +let t8; +let t9; +let t10; +let t11; +let t12; +let t13; +let t14; +let t15; +// assignability +t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, t3 = t1, t3 = t2; +t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, t7 = t5, t7 = t6; +t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, t14 = t0, t15 = t0; diff --git a/tests/baselines/reference/dynamicNames.symbols b/tests/baselines/reference/dynamicNames.symbols new file mode 100644 index 00000000000..fec309e2937 --- /dev/null +++ b/tests/baselines/reference/dynamicNames.symbols @@ -0,0 +1,352 @@ +=== tests/cases/compiler/module.ts === +export const c0 = "a"; +>c0 : Symbol(c0, Decl(module.ts, 0, 12)) + +export const c1 = 1; +>c1 : Symbol(c1, Decl(module.ts, 1, 12)) + +export interface T0 { +>T0 : Symbol(T0, Decl(module.ts, 1, 20)) + + [c0]: number; +>c0 : Symbol(c0, Decl(module.ts, 0, 12)) + + [c1]: string; +>c1 : Symbol(c1, Decl(module.ts, 1, 12)) +} +export declare class T1 implements T2 { +>T1 : Symbol(T1, Decl(module.ts, 5, 1)) +>T2 : Symbol(T2, Decl(module.ts, 9, 1)) + + [c0]: number; +>c0 : Symbol(c0, Decl(module.ts, 0, 12)) + + [c1]: string; +>c1 : Symbol(c1, Decl(module.ts, 1, 12)) +} +export declare class T2 extends T1 { +>T2 : Symbol(T2, Decl(module.ts, 9, 1)) +>T1 : Symbol(T1, Decl(module.ts, 5, 1)) +} +export declare type T3 = { +>T3 : Symbol(T3, Decl(module.ts, 11, 1)) + + [c0]: number; +>c0 : Symbol(c0, Decl(module.ts, 0, 12)) + + [c1]: string; +>c1 : Symbol(c1, Decl(module.ts, 1, 12)) + +}; + +=== tests/cases/compiler/main.ts === +import { c0, c1, T0, T1, T2, T3 } from "./module"; +>c0 : Symbol(c0, Decl(main.ts, 0, 8)) +>c1 : Symbol(c1, Decl(main.ts, 0, 12)) +>T0 : Symbol(T0, Decl(main.ts, 0, 16)) +>T1 : Symbol(T1, Decl(main.ts, 0, 20)) +>T2 : Symbol(T2, Decl(main.ts, 0, 24)) +>T3 : Symbol(T3, Decl(main.ts, 0, 28)) + +import * as M from "./module"; +>M : Symbol(M, Decl(main.ts, 1, 6)) + +namespace N { +>N : Symbol(N, Decl(main.ts, 1, 30)) + + export const c2 = "a"; +>c2 : Symbol(c2, Decl(main.ts, 4, 16)) + + export const c3 = 1; +>c3 : Symbol(c3, Decl(main.ts, 5, 16)) + + export interface T4 { +>T4 : Symbol(T4, Decl(main.ts, 5, 24)) + + [N.c2]: number; +>N.c2 : Symbol(c2, Decl(main.ts, 4, 16)) +>N : Symbol(N, Decl(main.ts, 1, 30)) +>c2 : Symbol(c2, Decl(main.ts, 4, 16)) + + [N.c3]: string; +>N.c3 : Symbol(c3, Decl(main.ts, 5, 16)) +>N : Symbol(N, Decl(main.ts, 1, 30)) +>c3 : Symbol(c3, Decl(main.ts, 5, 16)) + } + export declare class T5 implements T4 { +>T5 : Symbol(T5, Decl(main.ts, 10, 5)) +>T4 : Symbol(T4, Decl(main.ts, 5, 24)) + + [N.c2]: number; +>N.c2 : Symbol(c2, Decl(main.ts, 4, 16)) +>N : Symbol(N, Decl(main.ts, 1, 30)) +>c2 : Symbol(c2, Decl(main.ts, 4, 16)) + + [N.c3]: string; +>N.c3 : Symbol(c3, Decl(main.ts, 5, 16)) +>N : Symbol(N, Decl(main.ts, 1, 30)) +>c3 : Symbol(c3, Decl(main.ts, 5, 16)) + } + export declare class T6 extends T5 { +>T6 : Symbol(T6, Decl(main.ts, 14, 5)) +>T5 : Symbol(T5, Decl(main.ts, 10, 5)) + } + export declare type T7 = { +>T7 : Symbol(T7, Decl(main.ts, 16, 5)) + + [N.c2]: number; +>N.c2 : Symbol(c2, Decl(main.ts, 4, 16)) +>N : Symbol(N, Decl(main.ts, 1, 30)) +>c2 : Symbol(c2, Decl(main.ts, 4, 16)) + + [N.c3]: string; +>N.c3 : Symbol(c3, Decl(main.ts, 5, 16)) +>N : Symbol(N, Decl(main.ts, 1, 30)) +>c3 : Symbol(c3, Decl(main.ts, 5, 16)) + + }; +} + +const c4 = "a"; +>c4 : Symbol(c4, Decl(main.ts, 23, 5)) + +const c5 = 1; +>c5 : Symbol(c5, Decl(main.ts, 24, 5)) + +const c6 = "1"; +>c6 : Symbol(c6, Decl(main.ts, 25, 5)) + +interface T8 { +>T8 : Symbol(T8, Decl(main.ts, 25, 15)) + + [c4]: number; +>c4 : Symbol(c4, Decl(main.ts, 23, 5)) + + [c5]: string; +>c5 : Symbol(c5, Decl(main.ts, 24, 5)) +} +declare class T9 implements T8 { +>T9 : Symbol(T9, Decl(main.ts, 30, 1)) +>T8 : Symbol(T8, Decl(main.ts, 25, 15)) + + [c4]: number; +>c4 : Symbol(c4, Decl(main.ts, 23, 5)) + + [c5]: string; +>c5 : Symbol(c5, Decl(main.ts, 24, 5)) +} +declare class T10 extends T9 { +>T10 : Symbol(T10, Decl(main.ts, 34, 1)) +>T9 : Symbol(T9, Decl(main.ts, 30, 1)) +} +declare type T11 = { +>T11 : Symbol(T11, Decl(main.ts, 36, 1)) + + [c4]: number; +>c4 : Symbol(c4, Decl(main.ts, 23, 5)) + + [c5]: string; +>c5 : Symbol(c5, Decl(main.ts, 24, 5)) + +}; + +interface T12 { +>T12 : Symbol(T12, Decl(main.ts, 40, 2)) + + a: number; +>a : Symbol(T12.a, Decl(main.ts, 42, 15)) + + 1: string; +} +declare class T13 implements T2 { +>T13 : Symbol(T13, Decl(main.ts, 45, 1)) +>T2 : Symbol(T2, Decl(main.ts, 0, 24)) + + a: number; +>a : Symbol(T13.a, Decl(main.ts, 46, 33)) + + 1: string; +} +declare class T14 extends T13 { +>T14 : Symbol(T14, Decl(main.ts, 49, 1)) +>T13 : Symbol(T13, Decl(main.ts, 45, 1)) +} +declare type T15 = { +>T15 : Symbol(T15, Decl(main.ts, 51, 1)) + + a: number; +>a : Symbol(a, Decl(main.ts, 52, 20)) + + 1: string; +}; + +interface T16 { +>T16 : Symbol(T16, Decl(main.ts, 55, 2)) + + [c5]: number; +>c5 : Symbol(c5, Decl(main.ts, 24, 5)) + + [c6]: string; +>c6 : Symbol(c6, Decl(main.ts, 25, 5)) +} + + +let t0: T0; +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>T0 : Symbol(T0, Decl(main.ts, 0, 16)) + +let t1: T1; +>t1 : Symbol(t1, Decl(main.ts, 64, 3)) +>T1 : Symbol(T1, Decl(main.ts, 0, 20)) + +let t2: T2; +>t2 : Symbol(t2, Decl(main.ts, 65, 3)) +>T2 : Symbol(T2, Decl(main.ts, 0, 24)) + +let t3: T3; +>t3 : Symbol(t3, Decl(main.ts, 66, 3)) +>T3 : Symbol(T3, Decl(main.ts, 0, 28)) + +let t0_1: M.T0; +>t0_1 : Symbol(t0_1, Decl(main.ts, 67, 3)) +>M : Symbol(M, Decl(main.ts, 1, 6)) +>T0 : Symbol(T0, Decl(module.ts, 1, 20)) + +let t1_1: M.T1; +>t1_1 : Symbol(t1_1, Decl(main.ts, 68, 3)) +>M : Symbol(M, Decl(main.ts, 1, 6)) +>T1 : Symbol(T1, Decl(module.ts, 5, 1)) + +let t2_1: M.T2; +>t2_1 : Symbol(t2_1, Decl(main.ts, 69, 3)) +>M : Symbol(M, Decl(main.ts, 1, 6)) +>T2 : Symbol(T2, Decl(module.ts, 9, 1)) + +let t3_1: M.T3; +>t3_1 : Symbol(t3_1, Decl(main.ts, 70, 3)) +>M : Symbol(M, Decl(main.ts, 1, 6)) +>T3 : Symbol(T3, Decl(module.ts, 11, 1)) + +let t4: N.T4; +>t4 : Symbol(t4, Decl(main.ts, 71, 3)) +>N : Symbol(N, Decl(main.ts, 1, 30)) +>T4 : Symbol(N.T4, Decl(main.ts, 5, 24)) + +let t5: N.T5; +>t5 : Symbol(t5, Decl(main.ts, 72, 3)) +>N : Symbol(N, Decl(main.ts, 1, 30)) +>T5 : Symbol(N.T5, Decl(main.ts, 10, 5)) + +let t6: N.T6; +>t6 : Symbol(t6, Decl(main.ts, 73, 3)) +>N : Symbol(N, Decl(main.ts, 1, 30)) +>T6 : Symbol(N.T6, Decl(main.ts, 14, 5)) + +let t7: N.T7; +>t7 : Symbol(t7, Decl(main.ts, 74, 3)) +>N : Symbol(N, Decl(main.ts, 1, 30)) +>T7 : Symbol(N.T7, Decl(main.ts, 16, 5)) + +let t8: T8; +>t8 : Symbol(t8, Decl(main.ts, 75, 3)) +>T8 : Symbol(T8, Decl(main.ts, 25, 15)) + +let t9: T9; +>t9 : Symbol(t9, Decl(main.ts, 76, 3)) +>T9 : Symbol(T9, Decl(main.ts, 30, 1)) + +let t10: T10; +>t10 : Symbol(t10, Decl(main.ts, 77, 3)) +>T10 : Symbol(T10, Decl(main.ts, 34, 1)) + +let t11: T11; +>t11 : Symbol(t11, Decl(main.ts, 78, 3)) +>T11 : Symbol(T11, Decl(main.ts, 36, 1)) + +let t12: T12; +>t12 : Symbol(t12, Decl(main.ts, 79, 3)) +>T12 : Symbol(T12, Decl(main.ts, 40, 2)) + +let t13: T13; +>t13 : Symbol(t13, Decl(main.ts, 80, 3)) +>T13 : Symbol(T13, Decl(main.ts, 45, 1)) + +let t14: T14; +>t14 : Symbol(t14, Decl(main.ts, 81, 3)) +>T14 : Symbol(T14, Decl(main.ts, 49, 1)) + +let t15: T15; +>t15 : Symbol(t15, Decl(main.ts, 82, 3)) +>T15 : Symbol(T15, Decl(main.ts, 51, 1)) + +// assignability +t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, t3 = t1, t3 = t2; +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t1 : Symbol(t1, Decl(main.ts, 64, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t2 : Symbol(t2, Decl(main.ts, 65, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t3 : Symbol(t3, Decl(main.ts, 66, 3)) +>t1 : Symbol(t1, Decl(main.ts, 64, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t1 : Symbol(t1, Decl(main.ts, 64, 3)) +>t2 : Symbol(t2, Decl(main.ts, 65, 3)) +>t1 : Symbol(t1, Decl(main.ts, 64, 3)) +>t3 : Symbol(t3, Decl(main.ts, 66, 3)) +>t2 : Symbol(t2, Decl(main.ts, 65, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t2 : Symbol(t2, Decl(main.ts, 65, 3)) +>t1 : Symbol(t1, Decl(main.ts, 64, 3)) +>t2 : Symbol(t2, Decl(main.ts, 65, 3)) +>t3 : Symbol(t3, Decl(main.ts, 66, 3)) +>t3 : Symbol(t3, Decl(main.ts, 66, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t3 : Symbol(t3, Decl(main.ts, 66, 3)) +>t1 : Symbol(t1, Decl(main.ts, 64, 3)) +>t3 : Symbol(t3, Decl(main.ts, 66, 3)) +>t2 : Symbol(t2, Decl(main.ts, 65, 3)) + +t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, t7 = t5, t7 = t6; +>t4 : Symbol(t4, Decl(main.ts, 71, 3)) +>t5 : Symbol(t5, Decl(main.ts, 72, 3)) +>t4 : Symbol(t4, Decl(main.ts, 71, 3)) +>t6 : Symbol(t6, Decl(main.ts, 73, 3)) +>t4 : Symbol(t4, Decl(main.ts, 71, 3)) +>t7 : Symbol(t7, Decl(main.ts, 74, 3)) +>t5 : Symbol(t5, Decl(main.ts, 72, 3)) +>t4 : Symbol(t4, Decl(main.ts, 71, 3)) +>t5 : Symbol(t5, Decl(main.ts, 72, 3)) +>t6 : Symbol(t6, Decl(main.ts, 73, 3)) +>t5 : Symbol(t5, Decl(main.ts, 72, 3)) +>t7 : Symbol(t7, Decl(main.ts, 74, 3)) +>t6 : Symbol(t6, Decl(main.ts, 73, 3)) +>t4 : Symbol(t4, Decl(main.ts, 71, 3)) +>t6 : Symbol(t6, Decl(main.ts, 73, 3)) +>t5 : Symbol(t5, Decl(main.ts, 72, 3)) +>t6 : Symbol(t6, Decl(main.ts, 73, 3)) +>t7 : Symbol(t7, Decl(main.ts, 74, 3)) +>t7 : Symbol(t7, Decl(main.ts, 74, 3)) +>t4 : Symbol(t4, Decl(main.ts, 71, 3)) +>t7 : Symbol(t7, Decl(main.ts, 74, 3)) +>t5 : Symbol(t5, Decl(main.ts, 72, 3)) +>t7 : Symbol(t7, Decl(main.ts, 74, 3)) +>t6 : Symbol(t6, Decl(main.ts, 73, 3)) + +t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, t14 = t0, t15 = t0; +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t12 : Symbol(t12, Decl(main.ts, 79, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t13 : Symbol(t13, Decl(main.ts, 80, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t14 : Symbol(t14, Decl(main.ts, 81, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t15 : Symbol(t15, Decl(main.ts, 82, 3)) +>t12 : Symbol(t12, Decl(main.ts, 79, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t13 : Symbol(t13, Decl(main.ts, 80, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t14 : Symbol(t14, Decl(main.ts, 81, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) +>t15 : Symbol(t15, Decl(main.ts, 82, 3)) +>t0 : Symbol(t0, Decl(main.ts, 63, 3)) + diff --git a/tests/baselines/reference/dynamicNames.types b/tests/baselines/reference/dynamicNames.types new file mode 100644 index 00000000000..68c4026c35c --- /dev/null +++ b/tests/baselines/reference/dynamicNames.types @@ -0,0 +1,420 @@ +=== tests/cases/compiler/module.ts === +export const c0 = "a"; +>c0 : "a" +>"a" : "a" + +export const c1 = 1; +>c1 : 1 +>1 : 1 + +export interface T0 { +>T0 : T0 + + [c0]: number; +>c0 : "a" + + [c1]: string; +>c1 : 1 +} +export declare class T1 implements T2 { +>T1 : T1 +>T2 : T2 + + [c0]: number; +>c0 : "a" + + [c1]: string; +>c1 : 1 +} +export declare class T2 extends T1 { +>T2 : T2 +>T1 : T1 +} +export declare type T3 = { +>T3 : T3 + + [c0]: number; +>c0 : "a" + + [c1]: string; +>c1 : 1 + +}; + +=== tests/cases/compiler/main.ts === +import { c0, c1, T0, T1, T2, T3 } from "./module"; +>c0 : "a" +>c1 : 1 +>T0 : any +>T1 : typeof T1 +>T2 : typeof T2 +>T3 : any + +import * as M from "./module"; +>M : typeof M + +namespace N { +>N : typeof N + + export const c2 = "a"; +>c2 : "a" +>"a" : "a" + + export const c3 = 1; +>c3 : 1 +>1 : 1 + + export interface T4 { +>T4 : T4 + + [N.c2]: number; +>N.c2 : "a" +>N : typeof N +>c2 : "a" + + [N.c3]: string; +>N.c3 : 1 +>N : typeof N +>c3 : 1 + } + export declare class T5 implements T4 { +>T5 : T5 +>T4 : T4 + + [N.c2]: number; +>N.c2 : "a" +>N : typeof N +>c2 : "a" + + [N.c3]: string; +>N.c3 : 1 +>N : typeof N +>c3 : 1 + } + export declare class T6 extends T5 { +>T6 : T6 +>T5 : T5 + } + export declare type T7 = { +>T7 : { a: number; 1: string; } + + [N.c2]: number; +>N.c2 : "a" +>N : typeof N +>c2 : "a" + + [N.c3]: string; +>N.c3 : 1 +>N : typeof N +>c3 : 1 + + }; +} + +const c4 = "a"; +>c4 : "a" +>"a" : "a" + +const c5 = 1; +>c5 : 1 +>1 : 1 + +const c6 = "1"; +>c6 : "1" +>"1" : "1" + +interface T8 { +>T8 : T8 + + [c4]: number; +>c4 : "a" + + [c5]: string; +>c5 : 1 +} +declare class T9 implements T8 { +>T9 : T9 +>T8 : T8 + + [c4]: number; +>c4 : "a" + + [c5]: string; +>c5 : 1 +} +declare class T10 extends T9 { +>T10 : T10 +>T9 : T9 +} +declare type T11 = { +>T11 : { a: number; 1: string; } + + [c4]: number; +>c4 : "a" + + [c5]: string; +>c5 : 1 + +}; + +interface T12 { +>T12 : T12 + + a: number; +>a : number + + 1: string; +} +declare class T13 implements T2 { +>T13 : T13 +>T2 : T2 + + a: number; +>a : number + + 1: string; +} +declare class T14 extends T13 { +>T14 : T14 +>T13 : T13 +} +declare type T15 = { +>T15 : { a: number; 1: string; } + + a: number; +>a : number + + 1: string; +}; + +interface T16 { +>T16 : T16 + + [c5]: number; +>c5 : 1 + + [c6]: string; +>c6 : "1" +} + + +let t0: T0; +>t0 : T0 +>T0 : T0 + +let t1: T1; +>t1 : T1 +>T1 : T1 + +let t2: T2; +>t2 : T2 +>T2 : T2 + +let t3: T3; +>t3 : T3 +>T3 : T3 + +let t0_1: M.T0; +>t0_1 : T0 +>M : any +>T0 : T0 + +let t1_1: M.T1; +>t1_1 : T1 +>M : any +>T1 : T1 + +let t2_1: M.T2; +>t2_1 : T2 +>M : any +>T2 : T2 + +let t3_1: M.T3; +>t3_1 : T3 +>M : any +>T3 : T3 + +let t4: N.T4; +>t4 : N.T4 +>N : any +>T4 : N.T4 + +let t5: N.T5; +>t5 : N.T5 +>N : any +>T5 : N.T5 + +let t6: N.T6; +>t6 : N.T6 +>N : any +>T6 : N.T6 + +let t7: N.T7; +>t7 : { a: number; 1: string; } +>N : any +>T7 : { a: number; 1: string; } + +let t8: T8; +>t8 : T8 +>T8 : T8 + +let t9: T9; +>t9 : T9 +>T9 : T9 + +let t10: T10; +>t10 : T10 +>T10 : T10 + +let t11: T11; +>t11 : { a: number; 1: string; } +>T11 : { a: number; 1: string; } + +let t12: T12; +>t12 : T12 +>T12 : T12 + +let t13: T13; +>t13 : T13 +>T13 : T13 + +let t14: T14; +>t14 : T14 +>T14 : T14 + +let t15: T15; +>t15 : { a: number; 1: string; } +>T15 : { a: number; 1: string; } + +// assignability +t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, t3 = t1, t3 = t2; +>t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, t3 = t1, t3 = t2 : T2 +>t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, t3 = t1 : T1 +>t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0 : T0 +>t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3 : T3 +>t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1 : T1 +>t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0 : T0 +>t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3 : T3 +>t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2 : T2 +>t0 = t1, t0 = t2, t0 = t3, t1 = t0 : T0 +>t0 = t1, t0 = t2, t0 = t3 : T3 +>t0 = t1, t0 = t2 : T2 +>t0 = t1 : T1 +>t0 : T0 +>t1 : T1 +>t0 = t2 : T2 +>t0 : T0 +>t2 : T2 +>t0 = t3 : T3 +>t0 : T0 +>t3 : T3 +>t1 = t0 : T0 +>t1 : T1 +>t0 : T0 +>t1 = t2 : T2 +>t1 : T1 +>t2 : T2 +>t1 = t3 : T3 +>t1 : T1 +>t3 : T3 +>t2 = t0 : T0 +>t2 : T2 +>t0 : T0 +>t2 = t1 : T1 +>t2 : T2 +>t1 : T1 +>t2 = t3 : T3 +>t2 : T2 +>t3 : T3 +>t3 = t0 : T0 +>t3 : T3 +>t0 : T0 +>t3 = t1 : T1 +>t3 : T3 +>t1 : T1 +>t3 = t2 : T2 +>t3 : T3 +>t2 : T2 + +t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, t7 = t5, t7 = t6; +>t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, t7 = t5, t7 = t6 : N.T6 +>t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, t7 = t5 : N.T5 +>t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4 : N.T4 +>t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7 : { a: number; 1: string; } +>t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5 : N.T5 +>t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4 : N.T4 +>t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7 : { a: number; 1: string; } +>t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6 : N.T6 +>t4 = t5, t4 = t6, t4 = t7, t5 = t4 : N.T4 +>t4 = t5, t4 = t6, t4 = t7 : { a: number; 1: string; } +>t4 = t5, t4 = t6 : N.T6 +>t4 = t5 : N.T5 +>t4 : N.T4 +>t5 : N.T5 +>t4 = t6 : N.T6 +>t4 : N.T4 +>t6 : N.T6 +>t4 = t7 : { a: number; 1: string; } +>t4 : N.T4 +>t7 : { a: number; 1: string; } +>t5 = t4 : N.T4 +>t5 : N.T5 +>t4 : N.T4 +>t5 = t6 : N.T6 +>t5 : N.T5 +>t6 : N.T6 +>t5 = t7 : { a: number; 1: string; } +>t5 : N.T5 +>t7 : { a: number; 1: string; } +>t6 = t4 : N.T4 +>t6 : N.T6 +>t4 : N.T4 +>t6 = t5 : N.T5 +>t6 : N.T6 +>t5 : N.T5 +>t6 = t7 : { a: number; 1: string; } +>t6 : N.T6 +>t7 : { a: number; 1: string; } +>t7 = t4 : N.T4 +>t7 : { a: number; 1: string; } +>t4 : N.T4 +>t7 = t5 : N.T5 +>t7 : { a: number; 1: string; } +>t5 : N.T5 +>t7 = t6 : N.T6 +>t7 : { a: number; 1: string; } +>t6 : N.T6 + +t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, t14 = t0, t15 = t0; +>t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, t14 = t0, t15 = t0 : T0 +>t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, t14 = t0 : T0 +>t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0 : T0 +>t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0 : T0 +>t0 = t12, t0 = t13, t0 = t14, t0 = t15 : { a: number; 1: string; } +>t0 = t12, t0 = t13, t0 = t14 : T14 +>t0 = t12, t0 = t13 : T13 +>t0 = t12 : T12 +>t0 : T0 +>t12 : T12 +>t0 = t13 : T13 +>t0 : T0 +>t13 : T13 +>t0 = t14 : T14 +>t0 : T0 +>t14 : T14 +>t0 = t15 : { a: number; 1: string; } +>t0 : T0 +>t15 : { a: number; 1: string; } +>t12 = t0 : T0 +>t12 : T12 +>t0 : T0 +>t13 = t0 : T0 +>t13 : T13 +>t0 : T0 +>t14 = t0 : T0 +>t14 : T14 +>t0 : T0 +>t15 = t0 : T0 +>t15 : { a: number; 1: string; } +>t0 : T0 + diff --git a/tests/baselines/reference/dynamicNamesErrors.errors.txt b/tests/baselines/reference/dynamicNamesErrors.errors.txt new file mode 100644 index 00000000000..12796f95b99 --- /dev/null +++ b/tests/baselines/reference/dynamicNamesErrors.errors.txt @@ -0,0 +1,43 @@ +tests/cases/compiler/dynamicNamesErrors.ts(5,5): error TS2300: Duplicate identifier '1'. +tests/cases/compiler/dynamicNamesErrors.ts(6,5): error TS2300: Duplicate identifier '1'. +tests/cases/compiler/dynamicNamesErrors.ts(19,1): error TS2322: Type 'T2' is not assignable to type 'T1'. + Types of property '1' are incompatible. + Type 'string' is not assignable to type 'number'. +tests/cases/compiler/dynamicNamesErrors.ts(20,1): error TS2322: Type 'T1' is not assignable to type 'T2'. + Types of property '1' are incompatible. + Type 'number' is not assignable to type 'string'. + + +==== tests/cases/compiler/dynamicNamesErrors.ts (4 errors) ==== + const c0 = "1"; + const c1 = 1; + + interface T0 { + [c0]: number; + ~~~~ +!!! error TS2300: Duplicate identifier '1'. + 1: number; + ~ +!!! error TS2300: Duplicate identifier '1'. + } + + interface T1 { + [c0]: number; + } + + interface T2 { + [c0]: string; + } + + let t1: T1; + let t2: T2; + t1 = t2; + ~~ +!!! error TS2322: Type 'T2' is not assignable to type 'T1'. +!!! error TS2322: Types of property '1' are incompatible. +!!! error TS2322: Type 'string' is not assignable to type 'number'. + t2 = t1; + ~~ +!!! error TS2322: Type 'T1' is not assignable to type 'T2'. +!!! error TS2322: Types of property '1' are incompatible. +!!! error TS2322: Type 'number' is not assignable to type 'string'. \ No newline at end of file diff --git a/tests/baselines/reference/dynamicNamesErrors.js b/tests/baselines/reference/dynamicNamesErrors.js new file mode 100644 index 00000000000..960ad19db77 --- /dev/null +++ b/tests/baselines/reference/dynamicNamesErrors.js @@ -0,0 +1,29 @@ +//// [dynamicNamesErrors.ts] +const c0 = "1"; +const c1 = 1; + +interface T0 { + [c0]: number; + 1: number; +} + +interface T1 { + [c0]: number; +} + +interface T2 { + [c0]: string; +} + +let t1: T1; +let t2: T2; +t1 = t2; +t2 = t1; + +//// [dynamicNamesErrors.js] +const c0 = "1"; +const c1 = 1; +let t1; +let t2; +t1 = t2; +t2 = t1; diff --git a/tests/baselines/reference/transformApi/transformsCorrectly.fromTranspileModule.js b/tests/baselines/reference/transformApi/transformsCorrectly.fromTranspileModule.js index ddf3fd0e8d6..714feaea305 100644 --- a/tests/baselines/reference/transformApi/transformsCorrectly.fromTranspileModule.js +++ b/tests/baselines/reference/transformApi/transformsCorrectly.fromTranspileModule.js @@ -1 +1 @@ -var newName = void 0 /*undefined*/; +var newName = void 0 /*undefined*/; diff --git a/tests/cases/compiler/dynamicNames.ts b/tests/cases/compiler/dynamicNames.ts new file mode 100644 index 00000000000..09255054d00 --- /dev/null +++ b/tests/cases/compiler/dynamicNames.ts @@ -0,0 +1,109 @@ +// @target: esnext +// @module: commonjs +// @filename: module.ts +export const c0 = "a"; +export const c1 = 1; +export interface T0 { + [c0]: number; + [c1]: string; +} +export declare class T1 implements T2 { + [c0]: number; + [c1]: string; +} +export declare class T2 extends T1 { +} +export declare type T3 = { + [c0]: number; + [c1]: string; +}; + +// @filename: main.ts +import { c0, c1, T0, T1, T2, T3 } from "./module"; +import * as M from "./module"; + +namespace N { + export const c2 = "a"; + export const c3 = 1; + + export interface T4 { + [N.c2]: number; + [N.c3]: string; + } + export declare class T5 implements T4 { + [N.c2]: number; + [N.c3]: string; + } + export declare class T6 extends T5 { + } + export declare type T7 = { + [N.c2]: number; + [N.c3]: string; + }; +} + +const c4 = "a"; +const c5 = 1; +const c6 = "1"; + +interface T8 { + [c4]: number; + [c5]: string; +} +declare class T9 implements T8 { + [c4]: number; + [c5]: string; +} +declare class T10 extends T9 { +} +declare type T11 = { + [c4]: number; + [c5]: string; +}; + +interface T12 { + a: number; + 1: string; +} +declare class T13 implements T2 { + a: number; + 1: string; +} +declare class T14 extends T13 { +} +declare type T15 = { + a: number; + 1: string; +}; + +interface T16 { + [c5]: number; + [c6]: string; +} + + +let t0: T0; +let t1: T1; +let t2: T2; +let t3: T3; +let t0_1: M.T0; +let t1_1: M.T1; +let t2_1: M.T2; +let t3_1: M.T3; +let t4: N.T4; +let t5: N.T5; +let t6: N.T6; +let t7: N.T7; +let t8: T8; +let t9: T9; +let t10: T10; +let t11: T11; +let t12: T12; +let t13: T13; +let t14: T14; +let t15: T15; + +// assignability +t0 = t1, t0 = t2, t0 = t3, t1 = t0, t1 = t2, t1 = t3, t2 = t0, t2 = t1, t2 = t3, t3 = t0, t3 = t1, t3 = t2; +t4 = t5, t4 = t6, t4 = t7, t5 = t4, t5 = t6, t5 = t7, t6 = t4, t6 = t5, t6 = t7, t7 = t4, t7 = t5, t7 = t6; +t0 = t12, t0 = t13, t0 = t14, t0 = t15, t12 = t0, t13 = t0, t14 = t0, t15 = t0; \ No newline at end of file diff --git a/tests/cases/compiler/dynamicNamesErrors.ts b/tests/cases/compiler/dynamicNamesErrors.ts new file mode 100644 index 00000000000..f2c937cbdeb --- /dev/null +++ b/tests/cases/compiler/dynamicNamesErrors.ts @@ -0,0 +1,22 @@ +// @target: esnext + +const c0 = "1"; +const c1 = 1; + +interface T0 { + [c0]: number; + 1: number; +} + +interface T1 { + [c0]: number; +} + +interface T2 { + [c0]: string; +} + +let t1: T1; +let t2: T2; +t1 = t2; +t2 = t1; \ No newline at end of file