improve enum rechability check

Kingwl · Kingwl · commit 1c522a6e994b · 2018-07-20T15:48:30.000+08:00
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -2789,9 +2789,7 @@ namespace ts {
                     // report error on class declarations
                     node.kind === SyntaxKind.ClassDeclaration ||
                     // report error on instantiated modules or const-enums only modules if preserveConstEnums is set
-                    (node.kind === SyntaxKind.ModuleDeclaration && shouldReportErrorOnModuleDeclaration(<ModuleDeclaration>node)) ||
-                    // report error on regular enums and const enums if preserveConstEnums is set
-                    (isEnumDeclaration(node) && (!isEnumConst(node) || options.preserveConstEnums));
+                    (node.kind === SyntaxKind.ModuleDeclaration && shouldReportErrorOnModuleDeclaration(<ModuleDeclaration>node));
 
                 if (reportError) {
                     currentFlow = reportedUnreachableFlow;
@@ -2836,7 +2834,7 @@ namespace ts {
     // As opposed to a pure declaration like an `interface`
     function isExecutableStatement(s: Statement): boolean {
         // Don't remove statements that can validly be used before they appear.
-        return !isFunctionDeclaration(s) && !isPurelyTypeDeclaration(s) &&
+        return !isFunctionDeclaration(s) && !isPurelyTypeDeclaration(s) && !isEnumDeclaration(s) &&
             // `var x;` may declare a variable used above
             !(isVariableStatement(s) && !(getCombinedNodeFlags(s) & (NodeFlags.Let | NodeFlags.Const)) && s.declarationList.declarations.some(d => !d.initializer));
     }
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -1679,6 +1679,9 @@ namespace ts {
                 }
                 else {
                     Debug.assert(!!(result.flags & SymbolFlags.ConstEnum));
+                    if (compilerOptions.preserveConstEnums) {
+                        diagnosticMessage = error(errorLocation, Diagnostics.Class_0_used_before_its_declaration, declarationName);
+                    }
                 }
 
                 if (diagnosticMessage) {
@@ -22786,6 +22789,12 @@ namespace ts {
             }
         }
 
+        const enum DeclarationSpaces {
+            None = 0,
+            ExportValue = 1 << 0,
+            ExportType = 1 << 1,
+            ExportNamespace = 1 << 2,
+        }
         function checkExportsOnMergedDeclarations(node: Node): void {
             if (!produceDiagnostics) {
                 return;
@@ -22850,12 +22859,6 @@ namespace ts {
                 }
             }
 
-            const enum DeclarationSpaces {
-                None = 0,
-                ExportValue = 1 << 0,
-                ExportType = 1 << 1,
-                ExportNamespace = 1 << 2,
-            }
             function getDeclarationSpaces(decl: Declaration): DeclarationSpaces {
                 let d = decl as Node;
                 switch (d.kind) {
diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.errors.txt b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.errors.txt
@@ -0,0 +1,16 @@
+tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts(2,12): error TS2450: Enum 'E' used before its declaration.
+
+
+==== tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts (1 errors) ====
+    function foo1() {
+        return E.A
+               ~
+!!! error TS2450: Enum 'E' used before its declaration.
+!!! related TS2728 tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts:3:10: 'E' is declared here.
+        enum E { A }
+    }
+    
+    function foo2() {
+        return E.A
+        const enum E { A }
+    }
diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.js b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.js
@@ -0,0 +1,22 @@
+//// [blockScopedEnumVariablesUseBeforeDef.ts]
+function foo1() {
+    return E.A
+    enum E { A }
+}
+
+function foo2() {
+    return E.A
+    const enum E { A }
+}
+
+//// [blockScopedEnumVariablesUseBeforeDef.js]
+function foo1() {
+    return E.A;
+    var E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+    })(E || (E = {}));
+}
+function foo2() {
+    return 0 /* A */;
+}
diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.symbols b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.symbols
@@ -0,0 +1,26 @@
+=== tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts ===
+function foo1() {
+>foo1 : Symbol(foo1, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 0, 0))
+
+    return E.A
+>E.A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 2, 12))
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 1, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 2, 12))
+
+    enum E { A }
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 1, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 2, 12))
+}
+
+function foo2() {
+>foo2 : Symbol(foo2, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 3, 1))
+
+    return E.A
+>E.A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 7, 18))
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 6, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 7, 18))
+
+    const enum E { A }
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 6, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef.ts, 7, 18))
+}
diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.types b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.types
@@ -0,0 +1,26 @@
+=== tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts ===
+function foo1() {
+>foo1 : () => E
+
+    return E.A
+>E.A : E
+>E : typeof E
+>A : E
+
+    enum E { A }
+>E : E
+>A : E
+}
+
+function foo2() {
+>foo2 : () => E
+
+    return E.A
+>E.A : E
+>E : typeof E
+>A : E
+
+    const enum E { A }
+>E : E
+>A : E
+}
diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_preserve.errors.txt b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_preserve.errors.txt
@@ -0,0 +1,20 @@
+tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts(2,12): error TS2450: Enum 'E' used before its declaration.
+tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts(7,12): error TS2449: Class 'E' used before its declaration.
+
+
+==== tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts (2 errors) ====
+    function foo1() {
+        return E.A
+               ~
+!!! error TS2450: Enum 'E' used before its declaration.
+!!! related TS2728 tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts:3:10: 'E' is declared here.
+        enum E { A }
+    }
+    
+    function foo2() {
+        return E.A
+               ~
+!!! error TS2449: Class 'E' used before its declaration.
+!!! related TS2728 tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts:8:16: 'E' is declared here.
+        const enum E { A }
+    }
diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_preserve.js b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_preserve.js
@@ -0,0 +1,26 @@
+//// [blockScopedEnumVariablesUseBeforeDef_preserve.ts]
+function foo1() {
+    return E.A
+    enum E { A }
+}
+
+function foo2() {
+    return E.A
+    const enum E { A }
+}
+
+//// [blockScopedEnumVariablesUseBeforeDef_preserve.js]
+function foo1() {
+    return E.A;
+    var E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+    })(E || (E = {}));
+}
+function foo2() {
+    return 0 /* A */;
+    var E;
+    (function (E) {
+        E[E["A"] = 0] = "A";
+    })(E || (E = {}));
+}
diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_preserve.symbols b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_preserve.symbols
@@ -0,0 +1,26 @@
+=== tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts ===
+function foo1() {
+>foo1 : Symbol(foo1, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 0, 0))
+
+    return E.A
+>E.A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 2, 12))
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 1, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 2, 12))
+
+    enum E { A }
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 1, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 2, 12))
+}
+
+function foo2() {
+>foo2 : Symbol(foo2, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 3, 1))
+
+    return E.A
+>E.A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 7, 18))
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 6, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 7, 18))
+
+    const enum E { A }
+>E : Symbol(E, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 6, 14))
+>A : Symbol(E.A, Decl(blockScopedEnumVariablesUseBeforeDef_preserve.ts, 7, 18))
+}
diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_preserve.types b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_preserve.types
@@ -0,0 +1,26 @@
+=== tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts ===
+function foo1() {
+>foo1 : () => E
+
+    return E.A
+>E.A : E
+>E : typeof E
+>A : E
+
+    enum E { A }
+>E : E
+>A : E
+}
+
+function foo2() {
+>foo2 : () => E
+
+    return E.A
+>E.A : E
+>E : typeof E
+>A : E
+
+    const enum E { A }
+>E : E
+>A : E
+}
diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.errors.txt b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.errors.txt
@@ -119,4 +119,5 @@ tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts(100,12): error TS2448:
 !!! related TS2728 tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts:102:9: 'x' is declared here.
         }
         let x
-    }
+    }
+    
diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js
@@ -101,7 +101,8 @@ function foo14() {
         a: x 
     }
     let x
-}
+}
+
 
 //// [blockScopedVariablesUseBeforeDef.js]
 function foo0() {
diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols
@@ -212,3 +212,4 @@ function foo14() {
     let x
 >x : Symbol(x, Decl(blockScopedVariablesUseBeforeDef.ts, 101, 7))
 }
+
diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.types b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.types
@@ -224,3 +224,4 @@ function foo14() {
     let x
 >x : any
 }
+
diff --git a/tests/baselines/reference/reachabilityChecks1.errors.txt b/tests/baselines/reference/reachabilityChecks1.errors.txt
@@ -3,11 +3,9 @@ tests/cases/compiler/reachabilityChecks1.ts(6,5): error TS7027: Unreachable code
 tests/cases/compiler/reachabilityChecks1.ts(18,5): error TS7027: Unreachable code detected.
 tests/cases/compiler/reachabilityChecks1.ts(30,5): error TS7027: Unreachable code detected.
 tests/cases/compiler/reachabilityChecks1.ts(47,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/reachabilityChecks1.ts(60,5): error TS7027: Unreachable code detected.
-tests/cases/compiler/reachabilityChecks1.ts(69,5): error TS7027: Unreachable code detected.
 
 
-==== tests/cases/compiler/reachabilityChecks1.ts (7 errors) ====
+==== tests/cases/compiler/reachabilityChecks1.ts (5 errors) ====
     while (true);
     var x = 1;
     ~~~~~~~~~~
@@ -83,25 +81,17 @@ tests/cases/compiler/reachabilityChecks1.ts(69,5): error TS7027: Unreachable cod
         do {
         } while (true);
         enum E {
-        ~~~~~~~~
             X = 1
-    ~~~~~~~~~~~~~
         }
-    ~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     
     function f4() {
         if (true) {
             throw new Error();
         }
         const enum E {
-        ~~~~~~~~~~~~~~
             X = 1
-    ~~~~~~~~~~~~~
         }
-    ~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     
     
diff --git a/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts b/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts
@@ -0,0 +1,10 @@
+// @target: ES5
+function foo1() {
+    return E.A
+    enum E { A }
+}
+
+function foo2() {
+    return E.A
+    const enum E { A }
+}
diff --git a/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts b/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts
@@ -0,0 +1,12 @@
+// @target: ES5
+// @preserveConstEnums: true
+
+function foo1() {
+    return E.A
+    enum E { A }
+}
+
+function foo2() {
+    return E.A
+    const enum E { A }
+}
diff --git a/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts b/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts
@@ -101,4 +101,4 @@ function foo14() {
         a: x 
     }
     let x
-}
+}
diff --git a/tests/cases/fourslash/codeFixUnreachableCode.ts b/tests/cases/fourslash/codeFixUnreachableCode.ts
@@ -3,12 +3,12 @@
 ////function f() {
 ////    return f();
 ////    [|return 1;|]
-////    function f() {}
+////    function f(a?: EE) { return a; }
 ////    [|return 2;|]
 ////    type T = number;
 ////    interface I {}
 ////    const enum E {}
-////    [|enum E {}|]
+////    enum EE {}
 ////    namespace N { export type T = number; }
 ////    [|namespace N { export const x: T = 0; }|]
 ////    var x: I;
@@ -29,11 +29,23 @@ verify.codeFixAll({
     newFileContent:
 `function f() {
     return f();
-    function f() {}
+    function f(a?: EE) { return a; }
     type T = number;
     interface I {}
     const enum E {}
+    enum EE {}
     namespace N { export type T = number; }
     var x: I;
 }`,
 });
+
+function f() {
+   return f();
+   function f(a?: EE) { return a; }
+   type T = number;
+   interface I {}
+   const enum E {}
+   enum EE {}
+   namespace N { export type T = number; }
+   var x: I;
+}

Original file line number	Diff line number	Diff line change
`@@ -1679,6 +1679,9 @@ namespace ts {`
`1679`	`1679`	`}`
`1680`	`1680`	`else {`
`1681`	`1681`	`Debug.assert(!!(result.flags & SymbolFlags.ConstEnum));`
	`1682`	`+ if (compilerOptions.preserveConstEnums) {`
	`1683`	`+ diagnosticMessage = error(errorLocation, Diagnostics.Class_0_used_before_its_declaration, declarationName);`
	`1684`	`+ }`
`1682`	`1685`	`}`
`1683`	`1686`
`1684`	`1687`	`if (diagnosticMessage) {`
`@@ -22786,6 +22789,12 @@ namespace ts {`
`22786`	`22789`	`}`
`22787`	`22790`	`}`
`22788`	`22791`
	`22792`	`+ const enum DeclarationSpaces {`
	`22793`	`+ None = 0,`
	`22794`	`+ ExportValue = 1 << 0,`
	`22795`	`+ ExportType = 1 << 1,`
	`22796`	`+ ExportNamespace = 1 << 2,`
	`22797`	`+ }`
`22789`	`22798`	`function checkExportsOnMergedDeclarations(node: Node): void {`
`22790`	`22799`	`if (!produceDiagnostics) {`
`22791`	`22800`	`return;`
`@@ -22850,12 +22859,6 @@ namespace ts {`
`22850`	`22859`	`}`
`22851`	`22860`	`}`
`22852`	`22861`
`22853`		`- const enum DeclarationSpaces {`
`22854`		`- None = 0,`
`22855`		`- ExportValue = 1 << 0,`
`22856`		`- ExportType = 1 << 1,`
`22857`		`- ExportNamespace = 1 << 2,`
`22858`		`- }`
`22859`	`22862`	`function getDeclarationSpaces(decl: Declaration): DeclarationSpaces {`
`22860`	`22863`	`let d = decl as Node;`
`22861`	`22864`	`switch (d.kind) {`