Make computed property names always checked, regardless of parent grammar errors

tsc/internal/checker/checker.go

@@ -5233,6 +5233,9 @@ func (c *Checker) checkEnumMember(node *ast.Node) {
 	if ast.IsPrivateIdentifier(node.Name()) {
 		c.error(node, diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier)
 	}
+	if ast.IsComputedPropertyName(node.Name()) {
+		c.checkExpression(node.Name().Expression())
+	}
 	if node.Initializer() != nil {
 		c.checkExpression(node.Initializer())
 	}
@@ -28787,13 +28790,7 @@ func (c *Checker) markLinkedReferences(location *ast.Node, hint ReferenceHint, p
 					return
 				}
 			}
-			// Computed property names on enum members are a grammar error and are never checked
-			// (checkEnumMember only checks the member initializer, not the name), so resolving
-			// identifiers in them here would report a spurious "Cannot find name" diagnostic.
 			if computedName != nil {
-				if ast.IsEnumMember(computedName.Parent) {
-					return
-				}
 				if isInvalidComputedPropertyName(computedName) {
 					return
 				}

tsc/testdata/baselines/reference/compiler/deprecatedReferenceInEnumComputedNameNoFlake.errors.txt

@@ -0,0 +1,15 @@
+deprecatedReferenceInEnumComputedNameNoFlake.ts(5,5): error TS1164: Computed property names are not allowed in enums.
+deprecatedReferenceInEnumComputedNameNoFlake.ts(5,6): suggestion TS6385: 'oldValue' is deprecated.
+
+
+==== deprecatedReferenceInEnumComputedNameNoFlake.ts (2 errors) ====
+    // TS6385: 'oldValue' is deprecated.
+    /** @deprecated */
+    declare const oldValue: { value: number };
+    export enum Values {
+        [oldValue.value] = 1,
+        ~~~~~~~~~~~~~~~~
+!!! error TS1164: Computed property names are not allowed in enums.
+         ~~~~~~~~
+!!! suggestion TS6385: 'oldValue' is deprecated.
+    }

tsc/testdata/baselines/reference/compiler/deprecatedReferenceInEnumComputedNameNoFlake.js

@@ -0,0 +1,21 @@
+//// [tests/cases/compiler/deprecatedReferenceInEnumComputedNameNoFlake.ts] ////
+
+//// [deprecatedReferenceInEnumComputedNameNoFlake.ts]
+// TS6385: 'oldValue' is deprecated.
+/** @deprecated */
+declare const oldValue: { value: number };
+export enum Values {
+    [oldValue.value] = 1,
+}
+
+//// [deprecatedReferenceInEnumComputedNameNoFlake.js]
+export var Values;
+(function (Values) {
+    Values[Values[oldValue.value] = 1] = oldValue.value;
+})(Values || (Values = {}));
+
+
+//// [deprecatedReferenceInEnumComputedNameNoFlake.d.ts]
+export declare enum Values {
+    [oldValue.value] = 1
+}

tsc/testdata/baselines/reference/compiler/deprecatedReferenceInEnumComputedNameNoFlake.symbols

@@ -0,0 +1,18 @@
+//// [tests/cases/compiler/deprecatedReferenceInEnumComputedNameNoFlake.ts] ////
+
+=== deprecatedReferenceInEnumComputedNameNoFlake.ts ===
+// TS6385: 'oldValue' is deprecated.
+/** @deprecated */
+declare const oldValue: { value: number };
+>oldValue : Symbol(oldValue, Decl(deprecatedReferenceInEnumComputedNameNoFlake.ts, 2, 13))
+>value : Symbol(value, Decl(deprecatedReferenceInEnumComputedNameNoFlake.ts, 2, 25))
+
+export enum Values {
+>Values : Symbol(Values, Decl(deprecatedReferenceInEnumComputedNameNoFlake.ts, 2, 42))
+
+    [oldValue.value] = 1,
+>[oldValue.value] : Symbol(Values[oldValue.value], Decl(deprecatedReferenceInEnumComputedNameNoFlake.ts, 3, 20))
+>oldValue.value : Symbol(value, Decl(deprecatedReferenceInEnumComputedNameNoFlake.ts, 2, 25))
+>oldValue : Symbol(oldValue, Decl(deprecatedReferenceInEnumComputedNameNoFlake.ts, 2, 13))
+>value : Symbol(value, Decl(deprecatedReferenceInEnumComputedNameNoFlake.ts, 2, 25))
+}

tsc/testdata/baselines/reference/compiler/deprecatedReferenceInEnumComputedNameNoFlake.types

@@ -0,0 +1,19 @@
+//// [tests/cases/compiler/deprecatedReferenceInEnumComputedNameNoFlake.ts] ////
+
+=== deprecatedReferenceInEnumComputedNameNoFlake.ts ===
+// TS6385: 'oldValue' is deprecated.
+/** @deprecated */
+declare const oldValue: { value: number };
+>oldValue : { value: number; }
+>value : number
+
+export enum Values {
+>Values : Values
+
+    [oldValue.value] = 1,
+>[oldValue.value] : Values
+>oldValue.value : number
+>oldValue : { value: number; }
+>value : number
+>1 : 1
+}

tsc/testdata/baselines/reference/compiler/importedValueInEnumComputedNameNoFlake.errors.txt

@@ -0,0 +1,14 @@
+main.ts(4,5): error TS1164: Computed property names are not allowed in enums.
+
+
+==== key.ts (0 errors) ====
+    export const key = "member";
+
+==== main.ts (1 errors) ====
+    import { key } from "./key";
+
+    export enum Example {
+        [key] = 0,
+        ~~~~~
+!!! error TS1164: Computed property names are not allowed in enums.
+    }

tsc/testdata/baselines/reference/compiler/importedValueInEnumComputedNameNoFlake.js

@@ -0,0 +1,20 @@
+//// [tests/cases/compiler/importedValueInEnumComputedNameNoFlake.ts] ////
+
+//// [key.ts]
+export const key = "member";
+
+//// [main.ts]
+import { key } from "./key";
+
+export enum Example {
+    [key] = 0,
+}
+
+//// [key.js]
+export const key = "member";
+//// [main.js]
+import { key } from "./key";
+export var Example;
+(function (Example) {
+    Example[Example[key] = 0] = key;
+})(Example || (Example = {}));

tsc/testdata/baselines/reference/compiler/importedValueInEnumComputedNameNoFlake.symbols

@@ -0,0 +1,17 @@
+//// [tests/cases/compiler/importedValueInEnumComputedNameNoFlake.ts] ////
+
+=== key.ts ===
+export const key = "member";
+>key : Symbol(key, Decl(key.ts, 0, 12))
+
+=== main.ts ===
+import { key } from "./key";
+>key : Symbol(key, Decl(main.ts, 0, 8))
+
+export enum Example {
+>Example : Symbol(Example, Decl(main.ts, 0, 28))
+
+    [key] = 0,
+>[key] : Symbol(Example[key], Decl(main.ts, 2, 21))
+>key : Symbol(key, Decl(main.ts, 0, 8))
+}

tsc/testdata/baselines/reference/compiler/importedValueInEnumComputedNameNoFlake.types

@@ -0,0 +1,19 @@
+//// [tests/cases/compiler/importedValueInEnumComputedNameNoFlake.ts] ////
+
+=== key.ts ===
+export const key = "member";
+>key : "member"
+>"member" : "member"
+
+=== main.ts ===
+import { key } from "./key";
+>key : "member"
+
+export enum Example {
+>Example : Example
+
+    [key] = 0,
+>[key] : Example
+>key : "member"
+>0 : 0
+}

tsc/testdata/baselines/reference/compiler/incompatibleAssignmentInEnumComputedNameNoFlake.errors.txt

@@ -0,0 +1,20 @@
+incompatibleAssignmentInEnumComputedNameNoFlake.ts(4,5): error TS1164: Computed property names are not allowed in enums.
+incompatibleAssignmentInEnumComputedNameNoFlake.ts(5,23): error TS2322: Type 'string' is not assignable to type 'number'.
+
+
+==== incompatibleAssignmentInEnumComputedNameNoFlake.ts (2 errors) ====
+    // TS2322: Type 'string' is not assignable to type 'number'.
+    let target: number;
+    enum E {
+        [(() => {
+        ~~~~~~~~~
+            const text = (target = "value");
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+                          ~~~~~~
+!!! error TS2322: Type 'string' is not assignable to type 'number'.
+            return text.length;
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        })()]
+    ~~~~~~~~~
+!!! error TS1164: Computed property names are not allowed in enums.
+    }

tsc/testdata/baselines/reference/compiler/incompatibleAssignmentInEnumComputedNameNoFlake.js

@@ -0,0 +1,36 @@
+//// [tests/cases/compiler/incompatibleAssignmentInEnumComputedNameNoFlake.ts] ////
+
+//// [incompatibleAssignmentInEnumComputedNameNoFlake.ts]
+// TS2322: Type 'string' is not assignable to type 'number'.
+let target: number;
+enum E {
+    [(() => {
+        const text = (target = "value");
+        return text.length;
+    })()]
+}
+
+//// [incompatibleAssignmentInEnumComputedNameNoFlake.js]
+"use strict";
+// TS2322: Type 'string' is not assignable to type 'number'.
+let target;
+var E;
+(function (E) {
+    E[E[(() => {
+        const text = (target = "value");
+        return text.length;
+    })()] = 0] = (() => {
+        const text = (target = "value");
+        return text.length;
+    })();
+})(E || (E = {}));
+
+
+//// [incompatibleAssignmentInEnumComputedNameNoFlake.d.ts]
+declare let target: number;
+declare enum E {
+    [(() => {
+        const text = (target = "value");
+        return text.length;
+    })()] = 0
+}

tsc/testdata/baselines/reference/compiler/incompatibleAssignmentInEnumComputedNameNoFlake.symbols

@@ -0,0 +1,27 @@
+//// [tests/cases/compiler/incompatibleAssignmentInEnumComputedNameNoFlake.ts] ////
+
+=== incompatibleAssignmentInEnumComputedNameNoFlake.ts ===
+// TS2322: Type 'string' is not assignable to type 'number'.
+let target: number;
+>target : Symbol(target, Decl(incompatibleAssignmentInEnumComputedNameNoFlake.ts, 1, 3))
+
+enum E {
+>E : Symbol(E, Decl(incompatibleAssignmentInEnumComputedNameNoFlake.ts, 1, 19))
+
+    [(() => {
+>[(() => {        const text = (target = "value");        return text.length;    })()] : Symbol(E[(() => {
+        const text = (target = "value");
+        return text.length;
+    })()], Decl(incompatibleAssignmentInEnumComputedNameNoFlake.ts, 2, 8))
+
+        const text = (target = "value");
+>text : Symbol(text, Decl(incompatibleAssignmentInEnumComputedNameNoFlake.ts, 4, 13))
+>target : Symbol(target, Decl(incompatibleAssignmentInEnumComputedNameNoFlake.ts, 1, 3))
+
+        return text.length;
+>text.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>text : Symbol(text, Decl(incompatibleAssignmentInEnumComputedNameNoFlake.ts, 4, 13))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+
+    })()]
+}

tsc/testdata/baselines/reference/compiler/incompatibleAssignmentInEnumComputedNameNoFlake.types

@@ -0,0 +1,30 @@
+//// [tests/cases/compiler/incompatibleAssignmentInEnumComputedNameNoFlake.ts] ////
+
+=== incompatibleAssignmentInEnumComputedNameNoFlake.ts ===
+// TS2322: Type 'string' is not assignable to type 'number'.
+let target: number;
+>target : number
+
+enum E {
+>E : E
+
+    [(() => {
+>[(() => {        const text = (target = "value");        return text.length;    })()] : E
+>(() => {        const text = (target = "value");        return text.length;    })() : number
+>(() => {        const text = (target = "value");        return text.length;    }) : () => number
+>() => {        const text = (target = "value");        return text.length;    } : () => number
+
+        const text = (target = "value");
+>text : "value"
+>(target = "value") : "value"
+>target = "value" : "value"
+>target : number
+>"value" : "value"
+
+        return text.length;
+>text.length : number
+>text : "value"
+>length : number
+
+    })()]
+}

tsc/testdata/baselines/reference/compiler/localReferenceInEnumComputedNameNoFlake.errors.txt

@@ -0,0 +1,12 @@
+localReferenceInEnumComputedNameNoFlake.ts(4,5): error TS1164: Computed property names are not allowed in enums.
+
+
+==== localReferenceInEnumComputedNameNoFlake.ts (1 errors) ====
+    // TS6133 must not report 'unused' as unread: the computed name references it.
+    const unused = { value: 1 };
+    export enum Example {
+        [unused.value] = 0
+        ~~~~~~~~~~~~~~
+!!! error TS1164: Computed property names are not allowed in enums.
+    }
+

tsc/testdata/baselines/reference/compiler/localReferenceInEnumComputedNameNoFlake.js

@@ -0,0 +1,23 @@
+//// [tests/cases/compiler/localReferenceInEnumComputedNameNoFlake.ts] ////
+
+//// [localReferenceInEnumComputedNameNoFlake.ts]
+// TS6133 must not report 'unused' as unread: the computed name references it.
+const unused = { value: 1 };
+export enum Example {
+    [unused.value] = 0
+}
+
+
+//// [localReferenceInEnumComputedNameNoFlake.js]
+// TS6133 must not report 'unused' as unread: the computed name references it.
+const unused = { value: 1 };
+export var Example;
+(function (Example) {
+    Example[Example[unused.value] = 0] = unused.value;
+})(Example || (Example = {}));
+
+
+//// [localReferenceInEnumComputedNameNoFlake.d.ts]
+export declare enum Example {
+    [unused.value] = 0
+}

tsc/testdata/baselines/reference/compiler/localReferenceInEnumComputedNameNoFlake.symbols

@@ -0,0 +1,18 @@
+//// [tests/cases/compiler/localReferenceInEnumComputedNameNoFlake.ts] ////
+
+=== localReferenceInEnumComputedNameNoFlake.ts ===
+// TS6133 must not report 'unused' as unread: the computed name references it.
+const unused = { value: 1 };
+>unused : Symbol(unused, Decl(localReferenceInEnumComputedNameNoFlake.ts, 1, 5))
+>value : Symbol(value, Decl(localReferenceInEnumComputedNameNoFlake.ts, 1, 16))
+
+export enum Example {
+>Example : Symbol(Example, Decl(localReferenceInEnumComputedNameNoFlake.ts, 1, 28))
+
+    [unused.value] = 0
+>[unused.value] : Symbol(Example[unused.value], Decl(localReferenceInEnumComputedNameNoFlake.ts, 2, 21))
+>unused.value : Symbol(value, Decl(localReferenceInEnumComputedNameNoFlake.ts, 1, 16))
+>unused : Symbol(unused, Decl(localReferenceInEnumComputedNameNoFlake.ts, 1, 5))
+>value : Symbol(value, Decl(localReferenceInEnumComputedNameNoFlake.ts, 1, 16))
+}
+

tsc/testdata/baselines/reference/compiler/localReferenceInEnumComputedNameNoFlake.types

@@ -0,0 +1,21 @@
+//// [tests/cases/compiler/localReferenceInEnumComputedNameNoFlake.ts] ////
+
+=== localReferenceInEnumComputedNameNoFlake.ts ===
+// TS6133 must not report 'unused' as unread: the computed name references it.
+const unused = { value: 1 };
+>unused : { value: number; }
+>{ value: 1 } : { value: number; }
+>value : number
+>1 : 1
+
+export enum Example {
+>Example : Example
+
+    [unused.value] = 0
+>[unused.value] : Example
+>unused.value : number
+>unused : { value: number; }
+>value : number
+>0 : 0
+}
+

tsc/testdata/baselines/reference/compiler/missingIdentifierInEnumComputedNameNoFlake.errors.txt

@@ -0,0 +1,13 @@
+missingIdentifierInEnumComputedNameNoFlake.ts(3,5): error TS1164: Computed property names are not allowed in enums.
+missingIdentifierInEnumComputedNameNoFlake.ts(3,6): error TS2304: Cannot find name 'missing'.
+
+
+==== missingIdentifierInEnumComputedNameNoFlake.ts (2 errors) ====
+    // TS2304: Cannot find name 'missing'.
+    export enum Values {
+        [missing.value] = 1,
+        ~~~~~~~~~~~~~~~
+!!! error TS1164: Computed property names are not allowed in enums.
+         ~~~~~~~
+!!! error TS2304: Cannot find name 'missing'.
+    }