Computed names in declarations files are resolved even when non-literal, preserve computed names when expressions are entity names (#60052)

Author: weswigham

src/compiler/checker.ts

@@ -5886,7 +5886,7 @@ export interface EmitResolver {
     getDeclarationStatementsForSourceFile(node: SourceFile, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): Statement[] | undefined;
     isImportRequiredByAugmentation(decl: ImportDeclaration): boolean;
     isDefinitelyReferenceToGlobalSymbolObject(node: Node): boolean;
-    createLateBoundIndexSignatures(cls: ClassLikeDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): IndexSignatureDeclaration[] | undefined;
+    createLateBoundIndexSignatures(cls: ClassLikeDeclaration, enclosingDeclaration: Node, flags: NodeBuilderFlags, internalFlags: InternalNodeBuilderFlags, tracker: SymbolTracker): (IndexSignatureDeclaration | PropertyDeclaration)[] | undefined;
 }
 
 // dprint-ignore
@@ -7020,11 +7020,14 @@ export const enum IndexKind {
     Number,
 }
 
+export type ElementWithComputedPropertyName = (ClassElement | ObjectLiteralElement) & { name: ComputedPropertyName; };
+
 export interface IndexInfo {
     keyType: Type;
     type: Type;
     isReadonly: boolean;
     declaration?: IndexSignatureDeclaration;
+    components?: ElementWithComputedPropertyName[];
 }
 
 /** @internal */

src/compiler/types.ts

@@ -11,10 +11,10 @@ var Symbol: SymbolConstructor;
 >       : ^^^^^^^^^^^^^^^^^
 
 var obj = {
->obj : { [x: string]: number; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^
->{    [Symbol.foo]: 0} : { [x: string]: number; }
->                      : ^^^^^^^^^^^^^^^^^^^^^^^^
+>obj : { [Symbol.foo]: number; }
+>    : ^^              ^^^^^^ ^^
+>{    [Symbol.foo]: 0} : { [Symbol.foo]: number; }
+>                      : ^^              ^^^^^^ ^^
 
     [Symbol.foo]: 0
 >[Symbol.foo] : number
@@ -32,8 +32,8 @@ var obj = {
 obj[Symbol.foo];
 >obj[Symbol.foo] : number
 >                : ^^^^^^
->obj : { [x: string]: number; }
->    : ^^^^^^^^^^^^^^^^^^^^^^^^
+>obj : { [Symbol.foo]: number; }
+>    : ^^              ^^^^^^ ^^
 >Symbol.foo : string
 >           : ^^^^^^
 >Symbol : SymbolConstructor

tests/baselines/reference/ES5SymbolProperty1.types

@@ -6852,11 +6852,15 @@ declare namespace ts {
         String = 0,
         Number = 1,
     }
+    type ElementWithComputedPropertyName = (ClassElement | ObjectLiteralElement) & {
+        name: ComputedPropertyName;
+    };
     interface IndexInfo {
         keyType: Type;
         type: Type;
         isReadonly: boolean;
         declaration?: IndexSignatureDeclaration;
+        components?: ElementWithComputedPropertyName[];
     }
     enum InferencePriority {
         None = 0,

tests/baselines/reference/api/typescript.d.ts

@@ -177,12 +177,12 @@ function foo8(y = (async () => z)(), z = 1) {
 
 // error - used as computed name of method
 function foo9(y = {[z]() { return z; }}, z = 1) {
->foo9 : (y?: { [x: number]: () => number; }, z?: number) => void
->     : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^
->y : { [x: number]: () => number; }
->  : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
->{[z]() { return z; }} : { [x: number]: () => number; }
->                      : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>foo9 : (y?: { [z]: () => number; }, z?: number) => void
+>     : ^ ^^^^^     ^^^^^^^^^^^^ ^^^^ ^^^^^^^^^^^^^^^^^^
+>y : { [z]: () => number; }
+>  : ^^     ^^^^^^^^^^^^ ^^
+>{[z]() { return z; }} : { [z]: () => number; }
+>                      : ^^     ^^^^^^^^^^^^ ^^
 >[z] : () => number
 >    : ^^^^^^^^^^^^
 >z : number

tests/baselines/reference/capturedParametersInInitializers1.types

@@ -1,11 +1,10 @@
 capturedParametersInInitializers2.ts(3,20): error TS2373: Parameter 'y' cannot reference identifier 'x' declared after it.
 capturedParametersInInitializers2.ts(4,14): error TS2373: Parameter 'y' cannot reference identifier 'x' declared after it.
 capturedParametersInInitializers2.ts(6,10): error TS2373: Parameter 'y' cannot reference identifier 'z' declared after it.
-capturedParametersInInitializers2.ts(13,26): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type.
 capturedParametersInInitializers2.ts(13,27): error TS2373: Parameter 'y' cannot reference identifier 'x' declared after it.
 
 
-==== capturedParametersInInitializers2.ts (5 errors) ====
+==== capturedParametersInInitializers2.ts (4 errors) ====
     function foo(
         y = class {
             static c = x;
@@ -25,8 +24,6 @@ capturedParametersInInitializers2.ts(13,27): error TS2373: Parameter 'y' cannot
         y.c
     }
     function foo2(y = class {[x] = x}, x = 1) {
-                             ~~~
-!!! error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type.
                               ~
 !!! error TS2373: Parameter 'y' cannot reference identifier 'x' declared after it.
     }

tests/baselines/reference/capturedParametersInInitializers2.errors.txt

@@ -24,10 +24,10 @@ let s = `${n}`;
 >  : ^^^^^^
 
 const numericIndex = { [n]: 1 };
->numericIndex : { [x: number]: number; }
->             : ^^^^^^^^^^^^^^^^^^^^^^^^
->{ [n]: 1 } : { [x: number]: number; }
->           : ^^^^^^^^^^^^^^^^^^^^^^^^
+>numericIndex : { [n]: number; }
+>             : ^^     ^^^^^^ ^^
+>{ [n]: 1 } : { [n]: number; }
+>           : ^^     ^^^^^^ ^^
 >[n] : number
 >    : ^^^^^^
 >n : number
@@ -42,18 +42,18 @@ numericIndex[n].toFixed();
 >                        : ^              ^^^      ^^^^^      
 >numericIndex[n] : number
 >                : ^^^^^^
->numericIndex : { [x: number]: number; }
->             : ^^^^^^^^^^^^^^^^^^^^^^^^
+>numericIndex : { [n]: number; }
+>             : ^^     ^^^^^^ ^^
 >n : number
 >  : ^^^^^^
 >toFixed : (fractionDigits?: number) => string
 >        : ^              ^^^      ^^^^^      
 
 const stringIndex = { [s]: 1 };
->stringIndex : { [x: string]: number; }
->            : ^^^^^^^^^^^^^^^^^^^^^^^^
->{ [s]: 1 } : { [x: string]: number; }
->           : ^^^^^^^^^^^^^^^^^^^^^^^^
+>stringIndex : { [s]: number; }
+>            : ^^     ^^^^^^ ^^
+>{ [s]: 1 } : { [s]: number; }
+>           : ^^     ^^^^^^ ^^
 >[s] : number
 >    : ^^^^^^
 >s : string
@@ -68,8 +68,8 @@ stringIndex[s].toFixed();
 >                       : ^              ^^^      ^^^^^      
 >stringIndex[s] : number
 >               : ^^^^^^
->stringIndex : { [x: string]: number; }
->            : ^^^^^^^^^^^^^^^^^^^^^^^^
+>stringIndex : { [s]: number; }
+>            : ^^     ^^^^^^ ^^
 >s : string
 >  : ^^^^^^
 >toFixed : (fractionDigits?: number) => string

tests/baselines/reference/checkJsObjectLiteralIndexSignatures.types

@@ -27,13 +27,15 @@ export const Mixer = Mix(class {
 
 
 //// [classNonUniqueSymbolMethodHasSymbolIndexer.d.ts]
+declare const a: symbol;
 export declare class A {
-    [x: symbol]: () => number;
+    [a]: () => number;
 }
 export declare const Mixer: {
     new (): {
-        [x: symbol]: () => number;
+        [a]: () => number;
     };
 } & (new (...args: any[]) => {
     mixed: true;
 });
+export {};

tests/baselines/reference/classNonUniqueSymbolMethodHasSymbolIndexer.js

@@ -8,8 +8,8 @@ function f (m: string) {
 >  : ^^^^^^
 
     [1, 2, 3].map(i => {
->[1, 2, 3].map(i => {        return true? { [m]: i } : { [m]: i + 1 }    }) : { [x: string]: number; }[]
->                                                                           : ^^^^^^^^^^^^^^^^^^^^^^^^^^
+>[1, 2, 3].map(i => {        return true? { [m]: i } : { [m]: i + 1 }    }) : { [m]: number; }[]
+>                                                                           : ^^     ^^^^^^ ^^^^
 >[1, 2, 3].map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >              : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
 >[1, 2, 3] : number[]
@@ -22,26 +22,26 @@ function f (m: string) {
 >  : ^
 >map : <U>(callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[]
 >    : ^ ^^          ^^^     ^^^^^^^^^^     ^^      ^^     ^^^^^^^^^^^^^^^^^^       ^^^   ^^^^^^^^
->i => {        return true? { [m]: i } : { [m]: i + 1 }    } : (i: number) => { [x: string]: number; }
->                                                            : ^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>i => {        return true? { [m]: i } : { [m]: i + 1 }    } : (i: number) => { [m]: number; }
+>                                                            : ^ ^^^^^^^^^^^^^^^     ^^^^^^ ^^
 >i : number
 >  : ^^^^^^
 
         return true? { [m]: i } : { [m]: i + 1 }
->true? { [m]: i } : { [m]: i + 1 } : { [x: string]: number; }
->                                  : ^^^^^^^^^^^^^^^^^^^^^^^^
+>true? { [m]: i } : { [m]: i + 1 } : { [m]: number; }
+>                                  : ^^     ^^^^^^ ^^
 >true : true
 >     : ^^^^
->{ [m]: i } : { [x: string]: number; }
->           : ^^^^^^^^^^^^^^^^^^^^^^^^
+>{ [m]: i } : { [m]: number; }
+>           : ^^     ^^^^^^ ^^
 >[m] : number
 >    : ^^^^^^
 >m : string
 >  : ^^^^^^
 >i : number
 >  : ^^^^^^
->{ [m]: i + 1 } : { [x: string]: number; }
->               : ^^^^^^^^^^^^^^^^^^^^^^^^
+>{ [m]: i + 1 } : { [m]: number; }
+>               : ^^     ^^^^^^ ^^
 >[m] : number
 >    : ^^^^^^
 >m : string

tests/baselines/reference/commaOperatorInConditionalExpression.types

@@ -1,10 +1,9 @@
 complicatedPrivacy.ts(11,24): error TS1054: A 'get' accessor cannot have parameters.
-complicatedPrivacy.ts(35,5): error TS1170: A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type.
 complicatedPrivacy.ts(35,6): error TS2693: 'number' only refers to a type, but is being used as a value here.
 complicatedPrivacy.ts(73,55): error TS2694: Namespace 'mglo5' has no exported member 'i6'.
 
 
-==== complicatedPrivacy.ts (4 errors) ====
+==== complicatedPrivacy.ts (3 errors) ====
     module m1 {
         export module m2 {
 
@@ -42,8 +41,6 @@ complicatedPrivacy.ts(73,55): error TS2694: Namespace 'mglo5' has no exported me
         export function f4(arg1: 
         {
         [number]: C1; // Used to be indexer, now it is a computed property
-        ~~~~~~~~
-!!! error TS1170: A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type.
          ~~~~~~
 !!! error TS2693: 'number' only refers to a type, but is being used as a value here.
         }) {