diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 5e7ce50a86f..33a2a9b64e2 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -2802,9 +2802,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;
@@ -2849,7 +2847,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
index a5e810c3972..4fe46958196 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -1703,6 +1703,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) {
@@ -22981,6 +22984,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;
@@ -23045,12 +23054,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
new file mode 100644
index 00000000000..5927caba434
--- /dev/null
+++ 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 }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.js b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.js
new file mode 100644
index 00000000000..552d099b07c
--- /dev/null
+++ 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
new file mode 100644
index 00000000000..73f8419c8c1
--- /dev/null
+++ 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
new file mode 100644
index 00000000000..5c4dc43f774
--- /dev/null
+++ 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
new file mode 100644
index 00000000000..94b2ff97d9f
--- /dev/null
+++ 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 }
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_preserve.js b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_preserve.js
new file mode 100644
index 00000000000..239a87f0042
--- /dev/null
+++ 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
new file mode 100644
index 00000000000..b76089c0a0f
--- /dev/null
+++ 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
new file mode 100644
index 00000000000..5194114112e
--- /dev/null
+++ 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
index 4de97fa02a4..91bd5dde00c 100644
--- 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
-    }
\ No newline at end of file
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js
index b14ea2a3069..7e6b452302b 100644
--- 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
index 9dcb26712fb..83cb91db1d0 100644
--- 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
index 771518e5901..3098b8c0f91 100644
--- 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
index 041d10bfecd..97fd5302d45 100644
--- 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,12 +81,8 @@ 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() {
@@ -96,12 +90,8 @@ tests/cases/compiler/reachabilityChecks1.ts(69,5): error TS7027: Unreachable cod
             throw new Error();
         }
         const enum E {
-        ~~~~~~~~~~~~~~
             X = 1
-    ~~~~~~~~~~~~~
         }
-    ~~~~~
-!!! error TS7027: Unreachable code detected.
     }
     
     
\ No newline at end of file
diff --git a/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts b/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts
new file mode 100644
index 00000000000..84eff340164
--- /dev/null
+++ 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 }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts b/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_preserve.ts
new file mode 100644
index 00000000000..0d7cb73b3ad
--- /dev/null
+++ 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 }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts b/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts
index 956705bd7d3..351bdde122e 100644
--- a/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts
+++ b/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts
@@ -101,4 +101,4 @@ function foo14() {
         a: x 
     }
     let x
-}
\ No newline at end of file
+}
diff --git a/tests/cases/fourslash/codeFixUnreachableCode.ts b/tests/cases/fourslash/codeFixUnreachableCode.ts
index 9c9eea6dae4..eb5731081e7 100644
--- 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;
+}
\ No newline at end of file