[wontfix] fix(checker): Allow element access expressions in computed property names if argument is literal

src/compiler/checker.ts

@@ -742,6 +742,7 @@ import {
     isShorthandAmbientModuleSymbol,
     isShorthandPropertyAssignment,
     isSideEffectImport,
+    isSignedNumericLiteral,
     isSingleOrDoubleQuote,
     isSourceFile,
     isSourceFileJS,
@@ -13735,14 +13736,25 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             && isTypeUsableAsIndexSignature(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached((node as ElementAccessExpression).argumentExpression));
     }
 
-    function isLateBindableAST(node: DeclarationName) {
-        if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
-            return false;
+    function isLateBindableExpression(expr: Expression): boolean {
+        while (isElementAccessExpression(expr)) {
+            const argument = skipParentheses(expr.argumentExpression);
+            if (!isStringOrNumericLiteralLike(argument) && !isSignedNumericLiteral(argument)) return false;
+            expr = expr.expression;
         }
-        const expr = isComputedPropertyName(node) ? node.expression : node.argumentExpression;
         return isEntityNameExpression(expr);
     }
 
+    function isLateBindableAST(node: DeclarationName) {
+        if (isComputedPropertyName(node)) {
+            return isLateBindableExpression(node.expression);
+        }
+        else if (isElementAccessExpression(node)) {
+            return isLateBindableExpression(node.argumentExpression);
+        }
+        return false;
+    }
+
     function isTypeUsableAsIndexSignature(type: Type): boolean {
         return isTypeAssignableTo(type, stringNumberSymbolType);
     }

tests/baselines/reference/enumKeysInTypeLiteral.js

@@ -0,0 +1,48 @@
+//// [tests/cases/compiler/enumKeysInTypeLiteral.ts] ////
+
+//// [enumKeysInTypeLiteral.ts]
+enum Type {
+  Foo = 'foo',
+  '3x14' = '3x14'
+}
+
+type TypeMap = {
+  [Type.Foo]: 1;
+  [Type['3x14']]: 2;
+}
+
+const t: TypeMap = {
+    'foo': 1,
+    '3x14': 2
+};
+
+enum Numeric {
+    Negative = -1,
+    Zero = 0
+}
+
+type NumericMap = {
+    // Valid: Accessing enum member via string literal for the name
+    [Numeric['Negative']]: number; 
+    [Numeric['Zero']]: number;
+    // Valid: Parenthesized access
+    [Numeric[('Negative')]]: number;
+}
+
+
+
+//// [enumKeysInTypeLiteral.js]
+var Type;
+(function (Type) {
+    Type["Foo"] = "foo";
+    Type["3x14"] = "3x14";
+})(Type || (Type = {}));
+var t = {
+    'foo': 1,
+    '3x14': 2
+};
+var Numeric;
+(function (Numeric) {
+    Numeric[Numeric["Negative"] = -1] = "Negative";
+    Numeric[Numeric["Zero"] = 0] = "Zero";
+})(Numeric || (Numeric = {}));

tests/baselines/reference/enumKeysInTypeLiteral.symbols

@@ -0,0 +1,71 @@
+//// [tests/cases/compiler/enumKeysInTypeLiteral.ts] ////
+
+=== enumKeysInTypeLiteral.ts ===
+enum Type {
+>Type : Symbol(Type, Decl(enumKeysInTypeLiteral.ts, 0, 0))
+
+  Foo = 'foo',
+>Foo : Symbol(Type.Foo, Decl(enumKeysInTypeLiteral.ts, 0, 11))
+
+  '3x14' = '3x14'
+>'3x14' : Symbol(Type['3x14'], Decl(enumKeysInTypeLiteral.ts, 1, 14))
+}
+
+type TypeMap = {
+>TypeMap : Symbol(TypeMap, Decl(enumKeysInTypeLiteral.ts, 3, 1))
+
+  [Type.Foo]: 1;
+>[Type.Foo] : Symbol([Type.Foo], Decl(enumKeysInTypeLiteral.ts, 5, 16))
+>Type.Foo : Symbol(Type.Foo, Decl(enumKeysInTypeLiteral.ts, 0, 11))
+>Type : Symbol(Type, Decl(enumKeysInTypeLiteral.ts, 0, 0))
+>Foo : Symbol(Type.Foo, Decl(enumKeysInTypeLiteral.ts, 0, 11))
+
+  [Type['3x14']]: 2;
+>[Type['3x14']] : Symbol([Type['3x14']], Decl(enumKeysInTypeLiteral.ts, 6, 16))
+>Type : Symbol(Type, Decl(enumKeysInTypeLiteral.ts, 0, 0))
+>'3x14' : Symbol(Type['3x14'], Decl(enumKeysInTypeLiteral.ts, 1, 14))
+}
+
+const t: TypeMap = {
+>t : Symbol(t, Decl(enumKeysInTypeLiteral.ts, 10, 5))
+>TypeMap : Symbol(TypeMap, Decl(enumKeysInTypeLiteral.ts, 3, 1))
+
+    'foo': 1,
+>'foo' : Symbol('foo', Decl(enumKeysInTypeLiteral.ts, 10, 20))
+
+    '3x14': 2
+>'3x14' : Symbol('3x14', Decl(enumKeysInTypeLiteral.ts, 11, 13))
+
+};
+
+enum Numeric {
+>Numeric : Symbol(Numeric, Decl(enumKeysInTypeLiteral.ts, 13, 2))
+
+    Negative = -1,
+>Negative : Symbol(Numeric.Negative, Decl(enumKeysInTypeLiteral.ts, 15, 14))
+
+    Zero = 0
+>Zero : Symbol(Numeric.Zero, Decl(enumKeysInTypeLiteral.ts, 16, 18))
+}
+
+type NumericMap = {
+>NumericMap : Symbol(NumericMap, Decl(enumKeysInTypeLiteral.ts, 18, 1))
+
+    // Valid: Accessing enum member via string literal for the name
+    [Numeric['Negative']]: number; 
+>[Numeric['Negative']] : Symbol([Numeric['Negative']], Decl(enumKeysInTypeLiteral.ts, 20, 19), Decl(enumKeysInTypeLiteral.ts, 23, 30))
+>Numeric : Symbol(Numeric, Decl(enumKeysInTypeLiteral.ts, 13, 2))
+>'Negative' : Symbol(Numeric.Negative, Decl(enumKeysInTypeLiteral.ts, 15, 14))
+
+    [Numeric['Zero']]: number;
+>[Numeric['Zero']] : Symbol([Numeric['Zero']], Decl(enumKeysInTypeLiteral.ts, 22, 34))
+>Numeric : Symbol(Numeric, Decl(enumKeysInTypeLiteral.ts, 13, 2))
+>'Zero' : Symbol(Numeric.Zero, Decl(enumKeysInTypeLiteral.ts, 16, 18))
+
+    // Valid: Parenthesized access
+    [Numeric[('Negative')]]: number;
+>[Numeric[('Negative')]] : Symbol([Numeric['Negative']], Decl(enumKeysInTypeLiteral.ts, 20, 19), Decl(enumKeysInTypeLiteral.ts, 23, 30))
+>Numeric : Symbol(Numeric, Decl(enumKeysInTypeLiteral.ts, 13, 2))
+}
+
+

tests/baselines/reference/enumKeysInTypeLiteral.types

@@ -0,0 +1,124 @@
+//// [tests/cases/compiler/enumKeysInTypeLiteral.ts] ////
+
+=== enumKeysInTypeLiteral.ts ===
+enum Type {
+>Type : Type
+>     : ^^^^
+
+  Foo = 'foo',
+>Foo : Type.Foo
+>    : ^^^^^^^^
+>'foo' : "foo"
+>      : ^^^^^
+
+  '3x14' = '3x14'
+>'3x14' : (typeof Type)["3x14"]
+>       : ^^^^^^^^^^^^^^^^^^^^^
+>'3x14' : "3x14"
+>       : ^^^^^^
+}
+
+type TypeMap = {
+>TypeMap : TypeMap
+>        : ^^^^^^^
+
+  [Type.Foo]: 1;
+>[Type.Foo] : 1
+>           : ^
+>Type.Foo : Type.Foo
+>         : ^^^^^^^^
+>Type : typeof Type
+>     : ^^^^^^^^^^^
+>Foo : Type.Foo
+>    : ^^^^^^^^
+
+  [Type['3x14']]: 2;
+>[Type['3x14']] : 2
+>               : ^
+>Type['3x14'] : (typeof Type)["3x14"]
+>             : ^^^^^^^^^^^^^^^^^^^^^
+>Type : typeof Type
+>     : ^^^^^^^^^^^
+>'3x14' : "3x14"
+>       : ^^^^^^
+}
+
+const t: TypeMap = {
+>t : TypeMap
+>  : ^^^^^^^
+>{    'foo': 1,    '3x14': 2} : { foo: 1; '3x14': 2; }
+>                             : ^^^^^^^^^^^^^^^^^^^^^^
+
+    'foo': 1,
+>'foo' : 1
+>      : ^
+>1 : 1
+>  : ^
+
+    '3x14': 2
+>'3x14' : 2
+>       : ^
+>2 : 2
+>  : ^
+
+};
+
+enum Numeric {
+>Numeric : Numeric
+>        : ^^^^^^^
+
+    Negative = -1,
+>Negative : Numeric.Negative
+>         : ^^^^^^^^^^^^^^^^
+>-1 : -1
+>   : ^^
+>1 : 1
+>  : ^
+
+    Zero = 0
+>Zero : Numeric.Zero
+>     : ^^^^^^^^^^^^
+>0 : 0
+>  : ^
+}
+
+type NumericMap = {
+>NumericMap : NumericMap
+>           : ^^^^^^^^^^
+
+    // Valid: Accessing enum member via string literal for the name
+    [Numeric['Negative']]: number; 
+>[Numeric['Negative']] : number
+>                      : ^^^^^^
+>Numeric['Negative'] : Numeric.Negative
+>                    : ^^^^^^^^^^^^^^^^
+>Numeric : typeof Numeric
+>        : ^^^^^^^^^^^^^^
+>'Negative' : "Negative"
+>           : ^^^^^^^^^^
+
+    [Numeric['Zero']]: number;
+>[Numeric['Zero']] : number
+>                  : ^^^^^^
+>Numeric['Zero'] : Numeric.Zero
+>                : ^^^^^^^^^^^^
+>Numeric : typeof Numeric
+>        : ^^^^^^^^^^^^^^
+>'Zero' : "Zero"
+>       : ^^^^^^
+
+    // Valid: Parenthesized access
+    [Numeric[('Negative')]]: number;
+>[Numeric[('Negative')]] : number
+>                        : ^^^^^^
+>Numeric[('Negative')] : Numeric.Negative
+>                      : ^^^^^^^^^^^^^^^^
+>Numeric : typeof Numeric
+>        : ^^^^^^^^^^^^^^
+>('Negative') : "Negative"
+>             : ^^^^^^^^^^
+>'Negative' : "Negative"
+>           : ^^^^^^^^^^
+}
+
+

tests/baselines/reference/isolatedDeclarationLazySymbols.errors.txt

@@ -1,6 +1,6 @@
 isolatedDeclarationLazySymbols.ts(1,17): error TS9007: Function must have an explicit return type annotation with --isolatedDeclarations.
+isolatedDeclarationLazySymbols.ts(12,1): error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function.
 isolatedDeclarationLazySymbols.ts(13,1): error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function.
-isolatedDeclarationLazySymbols.ts(16,5): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type.
 isolatedDeclarationLazySymbols.ts(16,5): error TS9038: Computed property names on class or object literals cannot be inferred with --isolatedDeclarations.
 isolatedDeclarationLazySymbols.ts(21,5): error TS9038: Computed property names on class or object literals cannot be inferred with --isolatedDeclarations.
 isolatedDeclarationLazySymbols.ts(22,5): error TS9038: Computed property names on class or object literals cannot be inferred with --isolatedDeclarations.
@@ -22,15 +22,15 @@ isolatedDeclarationLazySymbols.ts(22,5): error TS9038: Computed property names o
     } as const
 
     foo[o["prop.inner"]] ="A";
+    ~~~~~~~~~~~~~~~~~~~~
+!!! error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function.
     foo[o.prop.inner] = "B";
     ~~~~~~~~~~~~~~~~~
 !!! error TS9023: Assigning properties to functions without declaring them is not supported with --isolatedDeclarations. Add an explicit declaration for the properties assigned to this function.
 
     export class Foo {
         [o["prop.inner"]] ="A"
         ~~~~~~~~~~~~~~~~~
-!!! error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type.
-        ~~~~~~~~~~~~~~~~~
 !!! error TS9038: Computed property names on class or object literals cannot be inferred with --isolatedDeclarations.
         [o.prop.inner] = "B"
     }

tests/baselines/reference/isolatedDeclarationLazySymbols.types

@@ -40,8 +40,8 @@ const o = {
 foo[o["prop.inner"]] ="A";
 >foo[o["prop.inner"]] ="A" : "A"
 >                          : ^^^
->foo[o["prop.inner"]] : any
->                     : ^^^
+>foo[o["prop.inner"]] : string
+>                     : ^^^^^^
 >foo : typeof foo
 >    : ^^^^^^^^^^
 >o["prop.inner"] : "a"

tests/cases/compiler/enumKeysInTypeLiteral.ts

@@ -0,0 +1,29 @@
+
+enum Type {
+  Foo = 'foo',
+  '3x14' = '3x14'
+}
+
+type TypeMap = {
+  [Type.Foo]: 1;
+  [Type['3x14']]: 2;
+}
+
+const t: TypeMap = {
+    'foo': 1,
+    '3x14': 2
+};
+
+enum Numeric {
+    Negative = -1,
+    Zero = 0
+}
+
+type NumericMap = {
+    // Valid: Accessing enum member via string literal for the name
+    [Numeric['Negative']]: number; 
+    [Numeric['Zero']]: number;
+    // Valid: Parenthesized access
+    [Numeric[('Negative')]]: number;
+}
+