Reissue used before declaration error for const enums in isolatedModules (#57174)

src/compiler/checker.ts

@@ -3924,6 +3924,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             else if (result.flags & SymbolFlags.RegularEnum) {
                 diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
             }
+            else {
+                Debug.assert(!!(result.flags & SymbolFlags.ConstEnum));
+                if (getIsolatedModules(compilerOptions)) {
+                    diagnosticMessage = error(errorLocation, Diagnostics.Enum_0_used_before_its_declaration, declarationName);
+                }
+            }
 
             if (diagnosticMessage) {
                 addRelatedInfo(diagnosticMessage, createDiagnosticForNode(declaration, Diagnostics._0_is_declared_here, declarationName));

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.errors.txt

@@ -13,4 +13,13 @@ blockScopedEnumVariablesUseBeforeDef.ts(2,12): error TS2450: Enum 'E' used befor
     function foo2() {
         return E.A
         const enum E { A }
-    }
+    }
+    
+    const config = {
+        a: AfterObject.A,
+    };
+    
+    const enum AfterObject {
+        A = 2,
+    }
+    

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.js

@@ -9,7 +9,16 @@ function foo1() {
 function foo2() {
     return E.A
     const enum E { A }
-}
+}
+
+const config = {
+    a: AfterObject.A,
+};
+
+const enum AfterObject {
+    A = 2,
+}
+
 
 //// [blockScopedEnumVariablesUseBeforeDef.js]
 function foo1() {
@@ -22,3 +31,6 @@ function foo1() {
 function foo2() {
     return 0 /* E.A */;
 }
+var config = {
+    a: 2 /* AfterObject.A */,
+};

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.symbols

@@ -26,3 +26,22 @@ function foo2() {
 >E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 6, 14))
 >A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 7, 18))
 }
+
+const config = {
+>config : Symbol(config, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 10, 5))
+
+    a: AfterObject.A,
+>a : Symbol(a, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 10, 16))
+>AfterObject.A : Symbol(AfterObject.A, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 14, 24))
+>AfterObject : Symbol(AfterObject, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 12, 2))
+>A : Symbol(AfterObject.A, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 14, 24))
+
+};
+
+const enum AfterObject {
+>AfterObject : Symbol(AfterObject, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 12, 2))
+
+    A = 2,
+>A : Symbol(AfterObject.A, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 14, 24))
+}
+

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.types

@@ -26,3 +26,24 @@ function foo2() {
 >E : E
 >A : E.A
 }
+
+const config = {
+>config : { a: AfterObject; }
+>{    a: AfterObject.A,} : { a: AfterObject; }
+
+    a: AfterObject.A,
+>a : AfterObject
+>AfterObject.A : AfterObject
+>AfterObject : typeof AfterObject
+>A : AfterObject
+
+};
+
+const enum AfterObject {
+>AfterObject : AfterObject
+
+    A = 2,
+>A : AfterObject.A
+>2 : 2
+}
+

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.errors.txt

@@ -0,0 +1,33 @@
+blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts(2,12): error TS2450: Enum 'E' used before its declaration.
+blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts(7,12): error TS2450: Enum 'E' used before its declaration.
+blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts(12,8): error TS2450: Enum 'AfterObject' used before its declaration.
+
+
+==== blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts (3 errors) ====
+    function foo1() {
+        return E.A
+               ~
+!!! error TS2450: Enum 'E' used before its declaration.
+!!! related TS2728 blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts:3:10: 'E' is declared here.
+        enum E { A }
+    }
+    
+    function foo2() {
+        return E.A
+               ~
+!!! error TS2450: Enum 'E' used before its declaration.
+!!! related TS2728 blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts:8:16: 'E' is declared here.
+        const enum E { A }
+    }
+    
+    const config = {
+        a: AfterObject.A,
+           ~~~~~~~~~~~
+!!! error TS2450: Enum 'AfterObject' used before its declaration.
+!!! related TS2728 blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts:15:12: 'AfterObject' is declared here.
+    };
+    
+    const enum AfterObject {
+        A = 2,
+    }
+    

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.js

@@ -0,0 +1,44 @@
+//// [tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts] ////
+
+//// [blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts]
+function foo1() {
+    return E.A
+    enum E { A }
+}
+
+function foo2() {
+    return E.A
+    const enum E { A }
+}
+
+const config = {
+    a: AfterObject.A,
+};
+
+const enum AfterObject {
+    A = 2,
+}
+
+
+//// [blockScopedEnumVariablesUseBeforeDef_isolatedModules.js]
+function foo1() {
+    return E.A;
+    var E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+    })(E || (E = {}));
+}
+function foo2() {
+    return E.A;
+    var E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+    })(E || (E = {}));
+}
+var config = {
+    a: AfterObject.A,
+};
+var AfterObject;
+(function (AfterObject) {
+    AfterObject[AfterObject["A"] = 2] = "A";
+})(AfterObject || (AfterObject = {}));

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.symbols

@@ -0,0 +1,47 @@
+//// [tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts] ////
+
+=== blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts ===
+function foo1() {
+>foo1 : Symbol(foo1, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 0, 0))
+
+    return E.A
+>E.A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 2, 12))
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 1, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 2, 12))
+
+    enum E { A }
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 1, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 2, 12))
+}
+
+function foo2() {
+>foo2 : Symbol(foo2, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 3, 1))
+
+    return E.A
+>E.A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 7, 18))
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 6, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 7, 18))
+
+    const enum E { A }
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 6, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 7, 18))
+}
+
+const config = {
+>config : Symbol(config, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 10, 5))
+
+    a: AfterObject.A,
+>a : Symbol(a, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 10, 16))
+>AfterObject.A : Symbol(AfterObject.A, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 14, 24))
+>AfterObject : Symbol(AfterObject, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 12, 2))
+>A : Symbol(AfterObject.A, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 14, 24))
+
+};
+
+const enum AfterObject {
+>AfterObject : Symbol(AfterObject, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 12, 2))
+
+    A = 2,
+>A : Symbol(AfterObject.A, Decl(blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts, 14, 24))
+}
+

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.types

@@ -0,0 +1,49 @@
+//// [tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts] ////
+
+=== blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts ===
+function foo1() {
+>foo1 : () => E
+
+    return E.A
+>E.A : E
+>E : typeof E
+>A : E
+
+    enum E { A }
+>E : E
+>A : E.A
+}
+
+function foo2() {
+>foo2 : () => E
+
+    return E.A
+>E.A : E
+>E : typeof E
+>A : E
+
+    const enum E { A }
+>E : E
+>A : E.A
+}
+
+const config = {
+>config : { a: AfterObject; }
+>{    a: AfterObject.A,} : { a: AfterObject; }
+
+    a: AfterObject.A,
+>a : AfterObject
+>AfterObject.A : AfterObject
+>AfterObject : typeof AfterObject
+>A : AfterObject
+
+};
+
+const enum AfterObject {
+>AfterObject : AfterObject
+
+    A = 2,
+>A : AfterObject.A
+>2 : 2
+}
+

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.errors.txt

@@ -0,0 +1,33 @@
+blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts(2,12): error TS2450: Enum 'E' used before its declaration.
+blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts(7,12): error TS2450: Enum 'E' used before its declaration.
+blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts(12,8): error TS2450: Enum 'AfterObject' used before its declaration.
+
+
+==== blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts (3 errors) ====
+    function foo1() {
+        return E.A
+               ~
+!!! error TS2450: Enum 'E' used before its declaration.
+!!! related TS2728 blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts:3:10: 'E' is declared here.
+        enum E { A }
+    }
+    
+    function foo2() {
+        return E.A
+               ~
+!!! error TS2450: Enum 'E' used before its declaration.
+!!! related TS2728 blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts:8:16: 'E' is declared here.
+        const enum E { A }
+    }
+    
+    const config = {
+        a: AfterObject.A,
+           ~~~~~~~~~~~
+!!! error TS2450: Enum 'AfterObject' used before its declaration.
+!!! related TS2728 blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts:15:12: 'AfterObject' is declared here.
+    };
+    
+    const enum AfterObject {
+        A = 2,
+    }
+    

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.js

@@ -0,0 +1,44 @@
+//// [tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts] ////
+
+//// [blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts]
+function foo1() {
+    return E.A
+    enum E { A }
+}
+
+function foo2() {
+    return E.A
+    const enum E { A }
+}
+
+const config = {
+    a: AfterObject.A,
+};
+
+const enum AfterObject {
+    A = 2,
+}
+
+
+//// [blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.js]
+function foo1() {
+    return E.A;
+    var E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+    })(E || (E = {}));
+}
+function foo2() {
+    return E.A;
+    var E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+    })(E || (E = {}));
+}
+var config = {
+    a: AfterObject.A,
+};
+var AfterObject;
+(function (AfterObject) {
+    AfterObject[AfterObject["A"] = 2] = "A";
+})(AfterObject || (AfterObject = {}));

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.symbols

@@ -0,0 +1,47 @@
+//// [tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts] ////
+
+=== blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts ===
+function foo1() {
+>foo1 : Symbol(foo1, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 0, 0))
+
+    return E.A
+>E.A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 2, 12))
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 1, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 2, 12))
+
+    enum E { A }
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 1, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 2, 12))
+}
+
+function foo2() {
+>foo2 : Symbol(foo2, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 3, 1))
+
+    return E.A
+>E.A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 7, 18))
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 6, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 7, 18))
+
+    const enum E { A }
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 6, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 7, 18))
+}
+
+const config = {
+>config : Symbol(config, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 10, 5))
+
+    a: AfterObject.A,
+>a : Symbol(a, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 10, 16))
+>AfterObject.A : Symbol(AfterObject.A, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 14, 24))
+>AfterObject : Symbol(AfterObject, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 12, 2))
+>A : Symbol(AfterObject.A, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 14, 24))
+
+};
+
+const enum AfterObject {
+>AfterObject : Symbol(AfterObject, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 12, 2))
+
+    A = 2,
+>A : Symbol(AfterObject.A, Decl(blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts, 14, 24))
+}
+

tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.types

@@ -0,0 +1,49 @@
+//// [tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts] ////
+
+=== blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts ===
+function foo1() {
+>foo1 : () => E
+
+    return E.A
+>E.A : E
+>E : typeof E
+>A : E
+
+    enum E { A }
+>E : E
+>A : E.A
+}
+
+function foo2() {
+>foo2 : () => E
+
+    return E.A
+>E.A : E
+>E : typeof E
+>A : E
+
+    const enum E { A }
+>E : E
+>A : E.A
+}
+
+const config = {
+>config : { a: AfterObject; }
+>{    a: AfterObject.A,} : { a: AfterObject; }
+
+    a: AfterObject.A,
+>a : AfterObject
+>AfterObject.A : AfterObject
+>AfterObject : typeof AfterObject
+>A : AfterObject
+
+};
+
+const enum AfterObject {
+>AfterObject : AfterObject
+
+    A = 2,
+>A : AfterObject.A
+>2 : 2
+}
+

tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts

@@ -7,4 +7,12 @@ function foo1() {
 function foo2() {
     return E.A
     const enum E { A }
-}
+}
+
+const config = {
+    a: AfterObject.A,
+};
+
+const enum AfterObject {
+    A = 2,
+}

tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts

@@ -0,0 +1,20 @@
+// @target: ES5
+// @isolatedModules: true
+
+function foo1() {
+    return E.A
+    enum E { A }
+}
+
+function foo2() {
+    return E.A
+    const enum E { A }
+}
+
+const config = {
+    a: AfterObject.A,
+};
+
+const enum AfterObject {
+    A = 2,
+}

tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts

@@ -0,0 +1,20 @@
+// @target: ES5
+// @verbatimModuleSyntax: true
+
+function foo1() {
+    return E.A
+    enum E { A }
+}
+
+function foo2() {
+    return E.A
+    const enum E { A }
+}
+
+const config = {
+    a: AfterObject.A,
+};
+
+const enum AfterObject {
+    A = 2,
+}