From 1445bd43449b09aecfd9d5ca5a49d98c1131cffd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Mateusz=20Burzy=C5=84ski?= Date: Tue, 30 Jan 2024 17:35:59 +0100 Subject: [PATCH] Reissue used before declaration error for const enums in `isolatedModules` (#57174) --- src/compiler/checker.ts | 6 +++ ...ScopedEnumVariablesUseBeforeDef.errors.txt | 11 ++++- .../blockScopedEnumVariablesUseBeforeDef.js | 14 +++++- ...ockScopedEnumVariablesUseBeforeDef.symbols | 19 +++++++ ...blockScopedEnumVariablesUseBeforeDef.types | 21 ++++++++ ...lesUseBeforeDef_isolatedModules.errors.txt | 33 +++++++++++++ ...umVariablesUseBeforeDef_isolatedModules.js | 44 +++++++++++++++++ ...iablesUseBeforeDef_isolatedModules.symbols | 47 ++++++++++++++++++ ...ariablesUseBeforeDef_isolatedModules.types | 49 +++++++++++++++++++ ...eBeforeDef_verbatimModuleSyntax.errors.txt | 33 +++++++++++++ ...iablesUseBeforeDef_verbatimModuleSyntax.js | 44 +++++++++++++++++ ...sUseBeforeDef_verbatimModuleSyntax.symbols | 47 ++++++++++++++++++ ...lesUseBeforeDef_verbatimModuleSyntax.types | 49 +++++++++++++++++++ .../blockScopedEnumVariablesUseBeforeDef.ts | 10 +++- ...umVariablesUseBeforeDef_isolatedModules.ts | 20 ++++++++ ...iablesUseBeforeDef_verbatimModuleSyntax.ts | 20 ++++++++ 16 files changed, 464 insertions(+), 3 deletions(-) create mode 100644 tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.errors.txt create mode 100644 tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.js create mode 100644 tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.symbols create mode 100644 tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.types create mode 100644 tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.errors.txt create mode 100644 tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.js create mode 100644 tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.symbols create mode 100644 tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.types create mode 100644 tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts create mode 100644 tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 3a137ac66fe..dfd117be086 100644 --- a/src/compiler/checker.ts +++ b/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)); diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.errors.txt b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.errors.txt index fdad5cd8e54..1b67e080e24 100644 --- a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.errors.txt +++ b/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 } - } \ No newline at end of file + } + + const config = { + a: AfterObject.A, + }; + + const enum AfterObject { + A = 2, + } + \ No newline at end of file diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.js b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.js index c0b64a55061..80bd068246b 100644 --- a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.js +++ b/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 */, +}; diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.symbols b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.symbols index 178c0cae366..6542daff85e 100644 --- a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.symbols +++ b/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)) +} + diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.types b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.types index aad25bfe2fc..176e2055faf 100644 --- a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef.types +++ b/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 +} + diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.errors.txt b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.errors.txt new file mode 100644 index 00000000000..99a0a42f860 --- /dev/null +++ b/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, + } + \ No newline at end of file diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.js b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.js new file mode 100644 index 00000000000..02875471bcb --- /dev/null +++ b/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 = {})); diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.symbols b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.symbols new file mode 100644 index 00000000000..2269e82f4fc --- /dev/null +++ b/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)) +} + diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.types b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_isolatedModules.types new file mode 100644 index 00000000000..98a0e5cb2d3 --- /dev/null +++ b/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 +} + diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.errors.txt b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.errors.txt new file mode 100644 index 00000000000..d3059e8840a --- /dev/null +++ b/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, + } + \ No newline at end of file diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.js b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.js new file mode 100644 index 00000000000..4d4f7ead874 --- /dev/null +++ b/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 = {})); diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.symbols b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.symbols new file mode 100644 index 00000000000..967db9a58c3 --- /dev/null +++ b/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)) +} + diff --git a/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.types b/tests/baselines/reference/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.types new file mode 100644 index 00000000000..cbbd657d005 --- /dev/null +++ b/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 +} + diff --git a/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts b/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts index 84eff340164..39f5eafd733 100644 --- a/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts +++ b/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef.ts @@ -7,4 +7,12 @@ function foo1() { function foo2() { return E.A const enum E { A } -} \ No newline at end of file +} + +const config = { + a: AfterObject.A, +}; + +const enum AfterObject { + A = 2, +} diff --git a/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts b/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_isolatedModules.ts new file mode 100644 index 00000000000..3b02ad81557 --- /dev/null +++ b/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, +} diff --git a/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts b/tests/cases/compiler/blockScopedEnumVariablesUseBeforeDef_verbatimModuleSyntax.ts new file mode 100644 index 00000000000..20e2c68c031 --- /dev/null +++ b/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, +}