🤖 Pick PR #58786 (Fixed declaration emit crash relate...) into release-5.5

src/compiler/checker.ts

@@ -8856,8 +8856,23 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                     else {
                         const type = getWidenedType(getRegularTypeOfExpression(node.expression));
                         const computedPropertyNameType = typeToTypeNodeHelper(type, context);
-                        Debug.assertNode(computedPropertyNameType, isLiteralTypeNode);
-                        const literal = computedPropertyNameType.literal;
+                        let literal;
+                        if (isLiteralTypeNode(computedPropertyNameType)) {
+                            literal = computedPropertyNameType.literal;
+                        }
+                        else {
+                            const evaluated = evaluateEntityNameExpression(node.expression);
+                            const literalNode = typeof evaluated.value === "string" ? factory.createStringLiteral(evaluated.value, /*isSingleQuote*/ undefined) :
+                                typeof evaluated.value === "number" ? factory.createNumericLiteral(evaluated.value, /*numericLiteralFlags*/ 0) :
+                                undefined;
+                            if (!literalNode) {
+                                if (isImportTypeNode(computedPropertyNameType)) {
+                                    trackComputedName(node.expression, context.enclosingDeclaration, context);
+                                }
+                                return node;
+                            }
+                            literal = literalNode;
+                        }
                         if (literal.kind === SyntaxKind.StringLiteral && isIdentifierText(literal.text, getEmitScriptTarget(compilerOptions))) {
                             return factory.createIdentifier(literal.text);
                         }

tests/baselines/reference/declarationEmitComputedPropertyNameEnum1.js

@@ -0,0 +1,34 @@
+//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum1.ts] ////
+
+//// [type.ts]
+export enum Enum {
+  A = "a",
+  B = "b"
+}
+
+export type Type = { x?: { [Enum.A]: 0 } };
+
+//// [index.ts]
+import { type Type } from "./type";
+
+export const foo = { ...({} as Type) };
+
+
+
+
+//// [type.d.ts]
+export declare enum Enum {
+    A = "a",
+    B = "b"
+}
+export type Type = {
+    x?: {
+        [Enum.A]: 0;
+    };
+};
+//// [index.d.ts]
+export declare const foo: {
+    x?: {
+        a: 0;
+    };
+};

tests/baselines/reference/declarationEmitComputedPropertyNameEnum1.symbols

@@ -0,0 +1,29 @@
+//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum1.ts] ////
+
+=== type.ts ===
+export enum Enum {
+>Enum : Symbol(Enum, Decl(type.ts, 0, 0))
+
+  A = "a",
+>A : Symbol(Enum.A, Decl(type.ts, 0, 18))
+
+  B = "b"
+>B : Symbol(Enum.B, Decl(type.ts, 1, 10))
+}
+
+export type Type = { x?: { [Enum.A]: 0 } };
+>Type : Symbol(Type, Decl(type.ts, 3, 1))
+>x : Symbol(x, Decl(type.ts, 5, 20))
+>[Enum.A] : Symbol([Enum.A], Decl(type.ts, 5, 26))
+>Enum.A : Symbol(Enum.A, Decl(type.ts, 0, 18))
+>Enum : Symbol(Enum, Decl(type.ts, 0, 0))
+>A : Symbol(Enum.A, Decl(type.ts, 0, 18))
+
+=== index.ts ===
+import { type Type } from "./type";
+>Type : Symbol(Type, Decl(index.ts, 0, 8))
+
+export const foo = { ...({} as Type) };
+>foo : Symbol(foo, Decl(index.ts, 2, 12))
+>Type : Symbol(Type, Decl(index.ts, 0, 8))
+

tests/baselines/reference/declarationEmitComputedPropertyNameEnum1.types

@@ -0,0 +1,51 @@
+//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum1.ts] ////
+
+=== type.ts ===
+export enum Enum {
+>Enum : Enum
+>     : ^^^^
+
+  A = "a",
+>A : Enum.A
+>  : ^^^^^^
+>"a" : "a"
+>    : ^^^
+
+  B = "b"
+>B : Enum.B
+>  : ^^^^^^
+>"b" : "b"
+>    : ^^^
+}
+
+export type Type = { x?: { [Enum.A]: 0 } };
+>Type : Type
+>     : ^^^^
+>x : { a: 0; } | undefined
+>  : ^^^^^ ^^^^^^^^^^^^^^^
+>[Enum.A] : 0
+>         : ^
+>Enum.A : Enum.A
+>       : ^^^^^^
+>Enum : typeof Enum
+>     : ^^^^^^^^^^^
+>A : Enum.A
+>  : ^^^^^^
+
+=== index.ts ===
+import { type Type } from "./type";
+>Type : any
+>     : ^^^
+
+export const foo = { ...({} as Type) };
+>foo : { x?: { a: 0; }; }
+>    : ^^^^^^         ^^^
+>{ ...({} as Type) } : { x?: { a: 0; }; }
+>                    : ^^^^^^         ^^^
+>({} as Type) : Type
+>             : ^^^^
+>{} as Type : Type
+>           : ^^^^
+>{} : {}
+>   : ^^
+

tests/baselines/reference/declarationEmitComputedPropertyNameEnum2.errors.txt

@@ -0,0 +1,16 @@
+type.ts(1,28): 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.
+type.ts(1,29): error TS2304: Cannot find name 'Enum'.
+
+
+==== type.ts (2 errors) ====
+    export type Type = { x?: { [Enum.A]: 0 } };
+                               ~~~~~~~~
+!!! 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 TS2304: Cannot find name 'Enum'.
+
+==== index.ts (0 errors) ====
+    import { type Type } from "./type";
+
+    export const foo = { ...({} as Type) };
+

tests/baselines/reference/declarationEmitComputedPropertyNameEnum2.js

@@ -0,0 +1,23 @@
+//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum2.ts] ////
+
+//// [type.ts]
+export type Type = { x?: { [Enum.A]: 0 } };
+
+//// [index.ts]
+import { type Type } from "./type";
+
+export const foo = { ...({} as Type) };
+
+
+
+
+//// [type.d.ts]
+export type Type = {
+    x?: {};
+};
+//// [index.d.ts]
+export declare const foo: {
+    x?: {
+        [Enum.A]: 0;
+    };
+};

tests/baselines/reference/declarationEmitComputedPropertyNameEnum2.symbols

@@ -0,0 +1,16 @@
+//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum2.ts] ////
+
+=== type.ts ===
+export type Type = { x?: { [Enum.A]: 0 } };
+>Type : Symbol(Type, Decl(type.ts, 0, 0))
+>x : Symbol(x, Decl(type.ts, 0, 20))
+>[Enum.A] : Symbol([Enum.A], Decl(type.ts, 0, 26))
+
+=== index.ts ===
+import { type Type } from "./type";
+>Type : Symbol(Type, Decl(index.ts, 0, 8))
+
+export const foo = { ...({} as Type) };
+>foo : Symbol(foo, Decl(index.ts, 2, 12))
+>Type : Symbol(Type, Decl(index.ts, 0, 8))
+

tests/baselines/reference/declarationEmitComputedPropertyNameEnum2.types

@@ -0,0 +1,34 @@
+//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum2.ts] ////
+
+=== type.ts ===
+export type Type = { x?: { [Enum.A]: 0 } };
+>Type : Type
+>     : ^^^^
+>x : {} | undefined
+>  : ^^^^^^^^^^^^^^
+>[Enum.A] : 0
+>         : ^
+>Enum.A : any
+>       : ^^^
+>Enum : any
+>     : ^^^
+>A : any
+>  : ^^^
+
+=== index.ts ===
+import { type Type } from "./type";
+>Type : any
+>     : ^^^
+
+export const foo = { ...({} as Type) };
+>foo : { x?: { [Enum.A]: 0; }; }
+>    : ^^^^^^                ^^^
+>{ ...({} as Type) } : { x?: { [Enum.A]: 0; }; }
+>                    : ^^^^^^                ^^^
+>({} as Type) : Type
+>             : ^^^^
+>{} as Type : Type
+>           : ^^^^
+>{} : {}
+>   : ^^
+

tests/baselines/reference/declarationEmitComputedPropertyNameEnum3.errors.txt

@@ -0,0 +1,22 @@
+type.ts(7,28): 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.
+type.ts(7,28): error TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
+
+
+==== type.ts (2 errors) ====
+    export namespace Foo {
+      export enum Enum {
+        A = "a",
+        B = "b",
+      }
+    }
+    export type Type = { x?: { [Foo.Enum]: 0 } };
+                               ~~~~~~~~~~
+!!! 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 TS2464: A computed property name must be of type 'string', 'number', 'symbol', or 'any'.
+
+==== index.ts (0 errors) ====
+    import { type Type } from "./type";
+
+    export const foo = { ...({} as Type) };
+

tests/baselines/reference/declarationEmitComputedPropertyNameEnum3.js

@@ -0,0 +1,33 @@
+//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum3.ts] ////
+
+//// [type.ts]
+export namespace Foo {
+  export enum Enum {
+    A = "a",
+    B = "b",
+  }
+}
+export type Type = { x?: { [Foo.Enum]: 0 } };
+
+//// [index.ts]
+import { type Type } from "./type";
+
+export const foo = { ...({} as Type) };
+
+
+
+
+//// [type.d.ts]
+export declare namespace Foo {
+    enum Enum {
+        A = "a",
+        B = "b"
+    }
+}
+export type Type = {
+    x?: {};
+};
+//// [index.d.ts]
+export declare const foo: {
+    x?: {};
+};

tests/baselines/reference/declarationEmitComputedPropertyNameEnum3.symbols

@@ -0,0 +1,32 @@
+//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum3.ts] ////
+
+=== type.ts ===
+export namespace Foo {
+>Foo : Symbol(Foo, Decl(type.ts, 0, 0))
+
+  export enum Enum {
+>Enum : Symbol(Enum, Decl(type.ts, 0, 22))
+
+    A = "a",
+>A : Symbol(Enum.A, Decl(type.ts, 1, 20))
+
+    B = "b",
+>B : Symbol(Enum.B, Decl(type.ts, 2, 12))
+  }
+}
+export type Type = { x?: { [Foo.Enum]: 0 } };
+>Type : Symbol(Type, Decl(type.ts, 5, 1))
+>x : Symbol(x, Decl(type.ts, 6, 20))
+>[Foo.Enum] : Symbol([Foo.Enum], Decl(type.ts, 6, 26))
+>Foo.Enum : Symbol(Foo.Enum, Decl(type.ts, 0, 22))
+>Foo : Symbol(Foo, Decl(type.ts, 0, 0))
+>Enum : Symbol(Foo.Enum, Decl(type.ts, 0, 22))
+
+=== index.ts ===
+import { type Type } from "./type";
+>Type : Symbol(Type, Decl(index.ts, 0, 8))
+
+export const foo = { ...({} as Type) };
+>foo : Symbol(foo, Decl(index.ts, 2, 12))
+>Type : Symbol(Type, Decl(index.ts, 0, 8))
+

tests/baselines/reference/declarationEmitComputedPropertyNameEnum3.types

@@ -0,0 +1,55 @@
+//// [tests/cases/compiler/declarationEmitComputedPropertyNameEnum3.ts] ////
+
+=== type.ts ===
+export namespace Foo {
+>Foo : typeof Foo
+>    : ^^^^^^^^^^
+
+  export enum Enum {
+>Enum : Enum
+>     : ^^^^
+
+    A = "a",
+>A : Enum.A
+>  : ^^^^^^
+>"a" : "a"
+>    : ^^^
+
+    B = "b",
+>B : Enum.B
+>  : ^^^^^^
+>"b" : "b"
+>    : ^^^
+  }
+}
+export type Type = { x?: { [Foo.Enum]: 0 } };
+>Type : Type
+>     : ^^^^
+>x : {} | undefined
+>  : ^^^^^^^^^^^^^^
+>[Foo.Enum] : 0
+>           : ^
+>Foo.Enum : typeof Foo.Enum
+>         : ^^^^^^^^^^^^^^^
+>Foo : typeof Foo
+>    : ^^^^^^^^^^
+>Enum : typeof Foo.Enum
+>     : ^^^^^^^^^^^^^^^
+
+=== index.ts ===
+import { type Type } from "./type";
+>Type : any
+>     : ^^^
+
+export const foo = { ...({} as Type) };
+>foo : { x?: {}; }
+>    : ^^^^^^  ^^^
+>{ ...({} as Type) } : { x?: {}; }
+>                    : ^^^^^^  ^^^
+>({} as Type) : Type
+>             : ^^^^
+>{} as Type : Type
+>           : ^^^^
+>{} : {}
+>   : ^^
+