fix(checker): also skip parentheses on element access keys

Support obj[('a')] by applying skipParentheses to argumentExpression
before checking isStringOrNumericLiteralLike.

Added test cases for parenthesized keys in element access.

Author: tt-a1i

src/compiler/checker.ts

@@ -13744,7 +13744,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         if (isPropertyAccessExpression(node) && isIdentifier(node.name)) {
             return isLateBindableAccessExpression(node.expression);
         }
-        if (isElementAccessExpression(node) && isStringOrNumericLiteralLike(node.argumentExpression)) {
+        if (isElementAccessExpression(node) && isStringOrNumericLiteralLike(skipParentheses(node.argumentExpression))) {
             return isLateBindableAccessExpression(node.expression);
         }
         return false;

tests/baselines/reference/enumKeysAsComputedPropertiesWithBracketNotation.js

@@ -77,6 +77,19 @@ type TypeMap10 = {
 type TypeMap11 = {
     [(nested).inner.key]: string;
 }
+
+// Parenthesized keys in element access
+type TypeMap12 = {
+    [nested[('inner')]['key']]: string;
+}
+
+type TypeMap13 = {
+    [nested['inner'][('key')]]: string;
+}
+
+type TypeMap14 = {
+    [deep[('a')][('b')].c['d']]: string;
+}
 
 
 //// [enumKeysAsComputedPropertiesWithBracketNotation.js]

tests/baselines/reference/enumKeysAsComputedPropertiesWithBracketNotation.symbols

@@ -185,3 +185,33 @@ type TypeMap11 = {
 >key : Symbol(key, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 21, 12))
 }
 
+// Parenthesized keys in element access
+type TypeMap12 = {
+>TypeMap12 : Symbol(TypeMap12, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 75, 1))
+
+    [nested[('inner')]['key']]: string;
+>[nested[('inner')]['key']] : Symbol([nested[('inner')]['key']], Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 78, 18))
+>nested : Symbol(nested, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 20, 5))
+>'key' : Symbol(key, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 21, 12))
+}
+
+type TypeMap13 = {
+>TypeMap13 : Symbol(TypeMap13, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 80, 1))
+
+    [nested['inner'][('key')]]: string;
+>[nested['inner'][('key')]] : Symbol([nested['inner'][('key')]], Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 82, 18))
+>nested : Symbol(nested, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 20, 5))
+>'inner' : Symbol(inner, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 20, 16))
+}
+
+type TypeMap14 = {
+>TypeMap14 : Symbol(TypeMap14, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 84, 1))
+
+    [deep[('a')][('b')].c['d']]: string;
+>[deep[('a')][('b')].c['d']] : Symbol([deep[('a')][('b')].c['d']], Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 86, 18))
+>deep[('a')][('b')].c : Symbol(c, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 48, 12))
+>deep : Symbol(deep, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 46, 5))
+>c : Symbol(c, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 48, 12))
+>'d' : Symbol(d, Decl(enumKeysAsComputedPropertiesWithBracketNotation.ts, 49, 16))
+}
+

tests/baselines/reference/enumKeysAsComputedPropertiesWithBracketNotation.types

@@ -320,3 +320,77 @@ type TypeMap11 = {
 >    : ^^^^^^^
 }
 
+// Parenthesized keys in element access
+type TypeMap12 = {
+>TypeMap12 : TypeMap12
+>          : ^^^^^^^^^
+
+    [nested[('inner')]['key']]: string;
+>[nested[('inner')]['key']] : string
+>                           : ^^^^^^
+>nested[('inner')]['key'] : "hello"
+>                         : ^^^^^^^
+>nested[('inner')] : { key: "hello"; }
+>                  : ^^^^^^^^^^^^^^^^^
+>nested : { inner: { key: "hello"; }; }
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>('inner') : "inner"
+>          : ^^^^^^^
+>'inner' : "inner"
+>        : ^^^^^^^
+>'key' : "key"
+>      : ^^^^^
+}
+
+type TypeMap13 = {
+>TypeMap13 : TypeMap13
+>          : ^^^^^^^^^
+
+    [nested['inner'][('key')]]: string;
+>[nested['inner'][('key')]] : string
+>                           : ^^^^^^
+>nested['inner'][('key')] : "hello"
+>                         : ^^^^^^^
+>nested['inner'] : { key: "hello"; }
+>                : ^^^^^^^^^^^^^^^^^
+>nested : { inner: { key: "hello"; }; }
+>       : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>'inner' : "inner"
+>        : ^^^^^^^
+>('key') : "key"
+>        : ^^^^^
+>'key' : "key"
+>      : ^^^^^
+}
+
+type TypeMap14 = {
+>TypeMap14 : TypeMap14
+>          : ^^^^^^^^^
+
+    [deep[('a')][('b')].c['d']]: string;
+>[deep[('a')][('b')].c['d']] : string
+>                            : ^^^^^^
+>deep[('a')][('b')].c['d'] : "value"
+>                          : ^^^^^^^
+>deep[('a')][('b')].c : { d: "value"; }
+>                     : ^^^^^^^^^^^^^^^
+>deep[('a')][('b')] : { c: { d: "value"; }; }
+>                   : ^^^^^^^^^^^^^^^^^^^^^^^
+>deep[('a')] : { b: { c: { d: "value"; }; }; }
+>            : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>deep : { a: { b: { c: { d: "value"; }; }; }; }
+>     : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+>('a') : "a"
+>      : ^^^
+>'a' : "a"
+>    : ^^^
+>('b') : "b"
+>      : ^^^
+>'b' : "b"
+>    : ^^^
+>c : { d: "value"; }
+>  : ^^^^^^^^^^^^^^^
+>'d' : "d"
+>    : ^^^
+}
+

tests/cases/compiler/enumKeysAsComputedPropertiesWithBracketNotation.ts

@@ -76,3 +76,16 @@ type TypeMap10 = {
 type TypeMap11 = {
     [(nested).inner.key]: string;
 }
+
+// Parenthesized keys in element access
+type TypeMap12 = {
+    [nested[('inner')]['key']]: string;
+}
+
+type TypeMap13 = {
+    [nested['inner'][('key')]]: string;
+}
+
+type TypeMap14 = {
+    [deep[('a')][('b')].c['d']]: string;
+}