diff --git a/src/compiler/transformers/classFields.ts b/src/compiler/transformers/classFields.ts index 7d4afe2baffc4..3bd3d1b1cbba6 100644 --- a/src/compiler/transformers/classFields.ts +++ b/src/compiler/transformers/classFields.ts @@ -133,7 +133,7 @@ namespace ts { const languageVersion = getEmitScriptTarget(compilerOptions); const useDefineForClassFields = getUseDefineForClassFields(compilerOptions); - const shouldTransformPrivateElementsOrClassStaticBlocks = languageVersion < ScriptTarget.ESNext; + const shouldTransformPrivateElementsOrClassStaticBlocks = languageVersion < ScriptTarget.ES2022; // We don't need to transform `super` property access when targeting ES5, ES3 because // the es2015 transformation handles those. @@ -172,7 +172,7 @@ namespace ts { function transformSourceFile(node: SourceFile) { const options = context.getCompilerOptions(); if (node.isDeclarationFile - || useDefineForClassFields && getEmitScriptTarget(options) === ScriptTarget.ESNext) { + || useDefineForClassFields && getEmitScriptTarget(options) >= ScriptTarget.ES2022) { return node; } const visited = visitEachChild(node, visitor, context); @@ -1201,7 +1201,7 @@ namespace ts { if (useDefineForClassFields) { // If we are using define semantics and targeting ESNext or higher, // then we don't need to transform any class properties. - return languageVersion < ScriptTarget.ESNext; + return languageVersion < ScriptTarget.ES2022; } return isInitializedProperty(member) || shouldTransformPrivateElementsOrClassStaticBlocks && isPrivateIdentifierClassElementDeclaration(member); } diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts index 72ce071940dcc..00bc27b973cab 100644 --- a/src/compiler/utilities.ts +++ b/src/compiler/utilities.ts @@ -6239,7 +6239,7 @@ namespace ts { } export function getUseDefineForClassFields(compilerOptions: CompilerOptions): boolean { - return compilerOptions.useDefineForClassFields === undefined ? getEmitScriptTarget(compilerOptions) === ScriptTarget.ESNext : compilerOptions.useDefineForClassFields; + return compilerOptions.useDefineForClassFields === undefined ? getEmitScriptTarget(compilerOptions) >= ScriptTarget.ES2022 : compilerOptions.useDefineForClassFields; } export function compilerOptionsAffectSemanticDiagnostics(newOptions: CompilerOptions, oldOptions: CompilerOptions): boolean { diff --git a/tests/baselines/reference/classStaticBlock1(target=es2022).js b/tests/baselines/reference/classStaticBlock1(target=es2022).js new file mode 100644 index 0000000000000..c7180cdabd6f8 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock1(target=es2022).js @@ -0,0 +1,20 @@ +//// [classStaticBlock1.ts] +const a = 2; + +class C { + static { + const a = 1; + + a; + } +} + + +//// [classStaticBlock1.js] +const a = 2; +class C { + static { + const a = 1; + a; + } +} diff --git a/tests/baselines/reference/classStaticBlock1(target=es2022).symbols b/tests/baselines/reference/classStaticBlock1(target=es2022).symbols new file mode 100644 index 0000000000000..e4aa99e0d68d5 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock1(target=es2022).symbols @@ -0,0 +1,16 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock1.ts === +const a = 2; +>a : Symbol(a, Decl(classStaticBlock1.ts, 0, 5)) + +class C { +>C : Symbol(C, Decl(classStaticBlock1.ts, 0, 12)) + + static { + const a = 1; +>a : Symbol(a, Decl(classStaticBlock1.ts, 4, 13)) + + a; +>a : Symbol(a, Decl(classStaticBlock1.ts, 4, 13)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock1(target=es2022).types b/tests/baselines/reference/classStaticBlock1(target=es2022).types new file mode 100644 index 0000000000000..a0fd3b4d6480a --- /dev/null +++ b/tests/baselines/reference/classStaticBlock1(target=es2022).types @@ -0,0 +1,18 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock1.ts === +const a = 2; +>a : 2 +>2 : 2 + +class C { +>C : C + + static { + const a = 1; +>a : 1 +>1 : 1 + + a; +>a : 1 + } +} + diff --git a/tests/baselines/reference/classStaticBlock10(target=es2015).js b/tests/baselines/reference/classStaticBlock10(target=es2015).js index dcf0be3960cb6..b9129346c7a2f 100644 --- a/tests/baselines/reference/classStaticBlock10(target=es2015).js +++ b/tests/baselines/reference/classStaticBlock10(target=es2015).js @@ -25,7 +25,8 @@ class C2 { const b1 = 222; const b2 = 222; } -} +} + //// [classStaticBlock10.js] var a1 = 1; diff --git a/tests/baselines/reference/classStaticBlock10(target=es2015).symbols b/tests/baselines/reference/classStaticBlock10(target=es2015).symbols index 12d2d16b0784c..c7aca333245ec 100644 --- a/tests/baselines/reference/classStaticBlock10(target=es2015).symbols +++ b/tests/baselines/reference/classStaticBlock10(target=es2015).symbols @@ -56,3 +56,4 @@ class C2 { >b2 : Symbol(b2, Decl(classStaticBlock10.ts, 24, 13)) } } + diff --git a/tests/baselines/reference/classStaticBlock10(target=es2015).types b/tests/baselines/reference/classStaticBlock10(target=es2015).types index dbbf3ebd6b0a4..ceda14a642e38 100644 --- a/tests/baselines/reference/classStaticBlock10(target=es2015).types +++ b/tests/baselines/reference/classStaticBlock10(target=es2015).types @@ -70,3 +70,4 @@ class C2 { >222 : 222 } } + diff --git a/tests/baselines/reference/classStaticBlock10(target=es2022).js b/tests/baselines/reference/classStaticBlock10(target=es2022).js new file mode 100644 index 0000000000000..7fe65ddcace5a --- /dev/null +++ b/tests/baselines/reference/classStaticBlock10(target=es2022).js @@ -0,0 +1,55 @@ +//// [classStaticBlock10.ts] +var a1 = 1; +var a2 = 1; +const b1 = 2; +const b2 = 2; + +function f () { + var a1 = 11; + const b1 = 22; + + class C1 { + static { + var a1 = 111; + var a2 = 111; + const b1 = 222; + const b2 = 222; + } + } +} + +class C2 { + static { + var a1 = 111; + var a2 = 111; + const b1 = 222; + const b2 = 222; + } +} + + +//// [classStaticBlock10.js] +var a1 = 1; +var a2 = 1; +const b1 = 2; +const b2 = 2; +function f() { + var a1 = 11; + const b1 = 22; + class C1 { + static { + var a1 = 111; + var a2 = 111; + const b1 = 222; + const b2 = 222; + } + } +} +class C2 { + static { + var a1 = 111; + var a2 = 111; + const b1 = 222; + const b2 = 222; + } +} diff --git a/tests/baselines/reference/classStaticBlock10(target=es2022).symbols b/tests/baselines/reference/classStaticBlock10(target=es2022).symbols new file mode 100644 index 0000000000000..c7aca333245ec --- /dev/null +++ b/tests/baselines/reference/classStaticBlock10(target=es2022).symbols @@ -0,0 +1,59 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock10.ts === +var a1 = 1; +>a1 : Symbol(a1, Decl(classStaticBlock10.ts, 0, 3)) + +var a2 = 1; +>a2 : Symbol(a2, Decl(classStaticBlock10.ts, 1, 3)) + +const b1 = 2; +>b1 : Symbol(b1, Decl(classStaticBlock10.ts, 2, 5)) + +const b2 = 2; +>b2 : Symbol(b2, Decl(classStaticBlock10.ts, 3, 5)) + +function f () { +>f : Symbol(f, Decl(classStaticBlock10.ts, 3, 13)) + + var a1 = 11; +>a1 : Symbol(a1, Decl(classStaticBlock10.ts, 6, 7)) + + const b1 = 22; +>b1 : Symbol(b1, Decl(classStaticBlock10.ts, 7, 9)) + + class C1 { +>C1 : Symbol(C1, Decl(classStaticBlock10.ts, 7, 18)) + + static { + var a1 = 111; +>a1 : Symbol(a1, Decl(classStaticBlock10.ts, 11, 15)) + + var a2 = 111; +>a2 : Symbol(a2, Decl(classStaticBlock10.ts, 12, 15)) + + const b1 = 222; +>b1 : Symbol(b1, Decl(classStaticBlock10.ts, 13, 17)) + + const b2 = 222; +>b2 : Symbol(b2, Decl(classStaticBlock10.ts, 14, 17)) + } + } +} + +class C2 { +>C2 : Symbol(C2, Decl(classStaticBlock10.ts, 17, 1)) + + static { + var a1 = 111; +>a1 : Symbol(a1, Decl(classStaticBlock10.ts, 21, 11)) + + var a2 = 111; +>a2 : Symbol(a2, Decl(classStaticBlock10.ts, 22, 11)) + + const b1 = 222; +>b1 : Symbol(b1, Decl(classStaticBlock10.ts, 23, 13)) + + const b2 = 222; +>b2 : Symbol(b2, Decl(classStaticBlock10.ts, 24, 13)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock10(target=es2022).types b/tests/baselines/reference/classStaticBlock10(target=es2022).types new file mode 100644 index 0000000000000..ceda14a642e38 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock10(target=es2022).types @@ -0,0 +1,73 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock10.ts === +var a1 = 1; +>a1 : number +>1 : 1 + +var a2 = 1; +>a2 : number +>1 : 1 + +const b1 = 2; +>b1 : 2 +>2 : 2 + +const b2 = 2; +>b2 : 2 +>2 : 2 + +function f () { +>f : () => void + + var a1 = 11; +>a1 : number +>11 : 11 + + const b1 = 22; +>b1 : 22 +>22 : 22 + + class C1 { +>C1 : C1 + + static { + var a1 = 111; +>a1 : number +>111 : 111 + + var a2 = 111; +>a2 : number +>111 : 111 + + const b1 = 222; +>b1 : 222 +>222 : 222 + + const b2 = 222; +>b2 : 222 +>222 : 222 + } + } +} + +class C2 { +>C2 : C2 + + static { + var a1 = 111; +>a1 : number +>111 : 111 + + var a2 = 111; +>a2 : number +>111 : 111 + + const b1 = 222; +>b1 : 222 +>222 : 222 + + const b2 = 222; +>b2 : 222 +>222 : 222 + } +} + diff --git a/tests/baselines/reference/classStaticBlock10(target=es5).js b/tests/baselines/reference/classStaticBlock10(target=es5).js index e390c2eb62da5..0c5cb146bc71e 100644 --- a/tests/baselines/reference/classStaticBlock10(target=es5).js +++ b/tests/baselines/reference/classStaticBlock10(target=es5).js @@ -25,7 +25,8 @@ class C2 { const b1 = 222; const b2 = 222; } -} +} + //// [classStaticBlock10.js] var a1 = 1; diff --git a/tests/baselines/reference/classStaticBlock10(target=es5).symbols b/tests/baselines/reference/classStaticBlock10(target=es5).symbols index 12d2d16b0784c..c7aca333245ec 100644 --- a/tests/baselines/reference/classStaticBlock10(target=es5).symbols +++ b/tests/baselines/reference/classStaticBlock10(target=es5).symbols @@ -56,3 +56,4 @@ class C2 { >b2 : Symbol(b2, Decl(classStaticBlock10.ts, 24, 13)) } } + diff --git a/tests/baselines/reference/classStaticBlock10(target=es5).types b/tests/baselines/reference/classStaticBlock10(target=es5).types index dbbf3ebd6b0a4..ceda14a642e38 100644 --- a/tests/baselines/reference/classStaticBlock10(target=es5).types +++ b/tests/baselines/reference/classStaticBlock10(target=es5).types @@ -70,3 +70,4 @@ class C2 { >222 : 222 } } + diff --git a/tests/baselines/reference/classStaticBlock10(target=esnext).js b/tests/baselines/reference/classStaticBlock10(target=esnext).js index 6593ae74ffed9..7fe65ddcace5a 100644 --- a/tests/baselines/reference/classStaticBlock10(target=esnext).js +++ b/tests/baselines/reference/classStaticBlock10(target=esnext).js @@ -25,7 +25,8 @@ class C2 { const b1 = 222; const b2 = 222; } -} +} + //// [classStaticBlock10.js] var a1 = 1; diff --git a/tests/baselines/reference/classStaticBlock10(target=esnext).symbols b/tests/baselines/reference/classStaticBlock10(target=esnext).symbols index 12d2d16b0784c..c7aca333245ec 100644 --- a/tests/baselines/reference/classStaticBlock10(target=esnext).symbols +++ b/tests/baselines/reference/classStaticBlock10(target=esnext).symbols @@ -56,3 +56,4 @@ class C2 { >b2 : Symbol(b2, Decl(classStaticBlock10.ts, 24, 13)) } } + diff --git a/tests/baselines/reference/classStaticBlock10(target=esnext).types b/tests/baselines/reference/classStaticBlock10(target=esnext).types index dbbf3ebd6b0a4..ceda14a642e38 100644 --- a/tests/baselines/reference/classStaticBlock10(target=esnext).types +++ b/tests/baselines/reference/classStaticBlock10(target=esnext).types @@ -70,3 +70,4 @@ class C2 { >222 : 222 } } + diff --git a/tests/baselines/reference/classStaticBlock11(target=es2022).js b/tests/baselines/reference/classStaticBlock11(target=es2022).js new file mode 100644 index 0000000000000..42228bd5d223d --- /dev/null +++ b/tests/baselines/reference/classStaticBlock11(target=es2022).js @@ -0,0 +1,27 @@ +//// [classStaticBlock11.ts] +let getX; +class C { + #x = 1 + constructor(x: number) { + this.#x = x; + } + + static { + // getX has privileged access to #x + getX = (obj: C) => obj.#x; + } +} + + +//// [classStaticBlock11.js] +let getX; +class C { + #x = 1; + constructor(x) { + this.#x = x; + } + static { + // getX has privileged access to #x + getX = (obj) => obj.#x; + } +} diff --git a/tests/baselines/reference/classStaticBlock11(target=es2022).symbols b/tests/baselines/reference/classStaticBlock11(target=es2022).symbols new file mode 100644 index 0000000000000..d61ff7c9e16f9 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock11(target=es2022).symbols @@ -0,0 +1,30 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock11.ts === +let getX; +>getX : Symbol(getX, Decl(classStaticBlock11.ts, 0, 3)) + +class C { +>C : Symbol(C, Decl(classStaticBlock11.ts, 0, 9)) + + #x = 1 +>#x : Symbol(C.#x, Decl(classStaticBlock11.ts, 1, 9)) + + constructor(x: number) { +>x : Symbol(x, Decl(classStaticBlock11.ts, 3, 14)) + + this.#x = x; +>this.#x : Symbol(C.#x, Decl(classStaticBlock11.ts, 1, 9)) +>this : Symbol(C, Decl(classStaticBlock11.ts, 0, 9)) +>x : Symbol(x, Decl(classStaticBlock11.ts, 3, 14)) + } + + static { + // getX has privileged access to #x + getX = (obj: C) => obj.#x; +>getX : Symbol(getX, Decl(classStaticBlock11.ts, 0, 3)) +>obj : Symbol(obj, Decl(classStaticBlock11.ts, 9, 12)) +>C : Symbol(C, Decl(classStaticBlock11.ts, 0, 9)) +>obj.#x : Symbol(C.#x, Decl(classStaticBlock11.ts, 1, 9)) +>obj : Symbol(obj, Decl(classStaticBlock11.ts, 9, 12)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock11(target=es2022).types b/tests/baselines/reference/classStaticBlock11(target=es2022).types new file mode 100644 index 0000000000000..c295e7b93df36 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock11(target=es2022).types @@ -0,0 +1,33 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock11.ts === +let getX; +>getX : any + +class C { +>C : C + + #x = 1 +>#x : number +>1 : 1 + + constructor(x: number) { +>x : number + + this.#x = x; +>this.#x = x : number +>this.#x : number +>this : this +>x : number + } + + static { + // getX has privileged access to #x + getX = (obj: C) => obj.#x; +>getX = (obj: C) => obj.#x : (obj: C) => number +>getX : any +>(obj: C) => obj.#x : (obj: C) => number +>obj : C +>obj.#x : number +>obj : C + } +} + diff --git a/tests/baselines/reference/classStaticBlock13(target=es2015).js b/tests/baselines/reference/classStaticBlock13(target=es2015).js index 442dbba65755f..de7cb926fba12 100644 --- a/tests/baselines/reference/classStaticBlock13(target=es2015).js +++ b/tests/baselines/reference/classStaticBlock13(target=es2015).js @@ -1,7 +1,7 @@ //// [classStaticBlock13.ts] class C { static #x = 123; - + static { console.log(C.#x) } diff --git a/tests/baselines/reference/classStaticBlock13(target=es2015).symbols b/tests/baselines/reference/classStaticBlock13(target=es2015).symbols index 7f94ddadbe167..dec13b283d9bd 100644 --- a/tests/baselines/reference/classStaticBlock13(target=es2015).symbols +++ b/tests/baselines/reference/classStaticBlock13(target=es2015).symbols @@ -4,7 +4,7 @@ class C { static #x = 123; >#x : Symbol(C.#x, Decl(classStaticBlock13.ts, 0, 9)) - + static { console.log(C.#x) >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) diff --git a/tests/baselines/reference/classStaticBlock13(target=es2015).types b/tests/baselines/reference/classStaticBlock13(target=es2015).types index 735409daa5c44..1de5122ac9f6f 100644 --- a/tests/baselines/reference/classStaticBlock13(target=es2015).types +++ b/tests/baselines/reference/classStaticBlock13(target=es2015).types @@ -5,7 +5,7 @@ class C { static #x = 123; >#x : number >123 : 123 - + static { console.log(C.#x) >console.log(C.#x) : void diff --git a/tests/baselines/reference/classStaticBlock13(target=es2022).js b/tests/baselines/reference/classStaticBlock13(target=es2022).js new file mode 100644 index 0000000000000..10bd99ec48105 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock13(target=es2022).js @@ -0,0 +1,24 @@ +//// [classStaticBlock13.ts] +class C { + static #x = 123; + + static { + console.log(C.#x) + } + + foo () { + return C.#x; + } +} + + +//// [classStaticBlock13.js] +class C { + static #x = 123; + static { + console.log(C.#x); + } + foo() { + return C.#x; + } +} diff --git a/tests/baselines/reference/classStaticBlock13(target=es2022).symbols b/tests/baselines/reference/classStaticBlock13(target=es2022).symbols new file mode 100644 index 0000000000000..dec13b283d9bd --- /dev/null +++ b/tests/baselines/reference/classStaticBlock13(target=es2022).symbols @@ -0,0 +1,25 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock13.ts === +class C { +>C : Symbol(C, Decl(classStaticBlock13.ts, 0, 0)) + + static #x = 123; +>#x : Symbol(C.#x, Decl(classStaticBlock13.ts, 0, 9)) + + static { + console.log(C.#x) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>C.#x : Symbol(C.#x, Decl(classStaticBlock13.ts, 0, 9)) +>C : Symbol(C, Decl(classStaticBlock13.ts, 0, 0)) + } + + foo () { +>foo : Symbol(C.foo, Decl(classStaticBlock13.ts, 5, 3)) + + return C.#x; +>C.#x : Symbol(C.#x, Decl(classStaticBlock13.ts, 0, 9)) +>C : Symbol(C, Decl(classStaticBlock13.ts, 0, 0)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock13(target=es2022).types b/tests/baselines/reference/classStaticBlock13(target=es2022).types new file mode 100644 index 0000000000000..1de5122ac9f6f --- /dev/null +++ b/tests/baselines/reference/classStaticBlock13(target=es2022).types @@ -0,0 +1,27 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock13.ts === +class C { +>C : C + + static #x = 123; +>#x : number +>123 : 123 + + static { + console.log(C.#x) +>console.log(C.#x) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>C.#x : number +>C : typeof C + } + + foo () { +>foo : () => number + + return C.#x; +>C.#x : number +>C : typeof C + } +} + diff --git a/tests/baselines/reference/classStaticBlock13(target=esnext).js b/tests/baselines/reference/classStaticBlock13(target=esnext).js index 5821962aee033..10bd99ec48105 100644 --- a/tests/baselines/reference/classStaticBlock13(target=esnext).js +++ b/tests/baselines/reference/classStaticBlock13(target=esnext).js @@ -1,7 +1,7 @@ //// [classStaticBlock13.ts] class C { static #x = 123; - + static { console.log(C.#x) } diff --git a/tests/baselines/reference/classStaticBlock13(target=esnext).symbols b/tests/baselines/reference/classStaticBlock13(target=esnext).symbols index 7f94ddadbe167..dec13b283d9bd 100644 --- a/tests/baselines/reference/classStaticBlock13(target=esnext).symbols +++ b/tests/baselines/reference/classStaticBlock13(target=esnext).symbols @@ -4,7 +4,7 @@ class C { static #x = 123; >#x : Symbol(C.#x, Decl(classStaticBlock13.ts, 0, 9)) - + static { console.log(C.#x) >console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) diff --git a/tests/baselines/reference/classStaticBlock13(target=esnext).types b/tests/baselines/reference/classStaticBlock13(target=esnext).types index 735409daa5c44..1de5122ac9f6f 100644 --- a/tests/baselines/reference/classStaticBlock13(target=esnext).types +++ b/tests/baselines/reference/classStaticBlock13(target=esnext).types @@ -5,7 +5,7 @@ class C { static #x = 123; >#x : number >123 : 123 - + static { console.log(C.#x) >console.log(C.#x) : void diff --git a/tests/baselines/reference/classStaticBlock15(target=es2022).js b/tests/baselines/reference/classStaticBlock15(target=es2022).js new file mode 100644 index 0000000000000..5646a0ef941b3 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock15(target=es2022).js @@ -0,0 +1,33 @@ +//// [classStaticBlock15.ts] +var _C__1; + +class C { + static #_1 = 1; + static #_3 = 3; + static #_5 = 5; + + static {} + static {} + static {} + static {} + static {} + static {} +} + +console.log(_C__1) + + +//// [classStaticBlock15.js] +var _C__1; +class C { + static #_1 = 1; + static #_3 = 3; + static #_5 = 5; + static { } + static { } + static { } + static { } + static { } + static { } +} +console.log(_C__1); diff --git a/tests/baselines/reference/classStaticBlock15(target=es2022).symbols b/tests/baselines/reference/classStaticBlock15(target=es2022).symbols new file mode 100644 index 0000000000000..12ab9dd68059b --- /dev/null +++ b/tests/baselines/reference/classStaticBlock15(target=es2022).symbols @@ -0,0 +1,30 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock15.ts === +var _C__1; +>_C__1 : Symbol(_C__1, Decl(classStaticBlock15.ts, 0, 3)) + +class C { +>C : Symbol(C, Decl(classStaticBlock15.ts, 0, 10)) + + static #_1 = 1; +>#_1 : Symbol(C.#_1, Decl(classStaticBlock15.ts, 2, 9)) + + static #_3 = 3; +>#_3 : Symbol(C.#_3, Decl(classStaticBlock15.ts, 3, 17)) + + static #_5 = 5; +>#_5 : Symbol(C.#_5, Decl(classStaticBlock15.ts, 4, 17)) + + static {} + static {} + static {} + static {} + static {} + static {} +} + +console.log(_C__1) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>_C__1 : Symbol(_C__1, Decl(classStaticBlock15.ts, 0, 3)) + diff --git a/tests/baselines/reference/classStaticBlock15(target=es2022).types b/tests/baselines/reference/classStaticBlock15(target=es2022).types new file mode 100644 index 0000000000000..262ff1a4c2769 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock15(target=es2022).types @@ -0,0 +1,34 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock15.ts === +var _C__1; +>_C__1 : any + +class C { +>C : C + + static #_1 = 1; +>#_1 : number +>1 : 1 + + static #_3 = 3; +>#_3 : number +>3 : 3 + + static #_5 = 5; +>#_5 : number +>5 : 5 + + static {} + static {} + static {} + static {} + static {} + static {} +} + +console.log(_C__1) +>console.log(_C__1) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>_C__1 : any + diff --git a/tests/baselines/reference/classStaticBlock18(target=es2022).js b/tests/baselines/reference/classStaticBlock18(target=es2022).js new file mode 100644 index 0000000000000..ed8123e3e059d --- /dev/null +++ b/tests/baselines/reference/classStaticBlock18(target=es2022).js @@ -0,0 +1,30 @@ +//// [classStaticBlock18.ts] +function foo () { + return class { + static foo = 1; + static { + const c = class { + static bar = 2; + static { + // do + } + } + } + } +} + + +//// [classStaticBlock18.js] +function foo() { + return class { + static foo = 1; + static { + const c = class { + static bar = 2; + static { + // do + } + }; + } + }; +} diff --git a/tests/baselines/reference/classStaticBlock18(target=es2022).symbols b/tests/baselines/reference/classStaticBlock18(target=es2022).symbols new file mode 100644 index 0000000000000..22e9413ef67ef --- /dev/null +++ b/tests/baselines/reference/classStaticBlock18(target=es2022).symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock18.ts === +function foo () { +>foo : Symbol(foo, Decl(classStaticBlock18.ts, 0, 0)) + + return class { + static foo = 1; +>foo : Symbol((Anonymous class).foo, Decl(classStaticBlock18.ts, 1, 16)) + + static { + const c = class { +>c : Symbol(c, Decl(classStaticBlock18.ts, 4, 11)) + + static bar = 2; +>bar : Symbol(c.bar, Decl(classStaticBlock18.ts, 4, 23)) + + static { + // do + } + } + } + } +} + diff --git a/tests/baselines/reference/classStaticBlock18(target=es2022).types b/tests/baselines/reference/classStaticBlock18(target=es2022).types new file mode 100644 index 0000000000000..5bc9155932a2b --- /dev/null +++ b/tests/baselines/reference/classStaticBlock18(target=es2022).types @@ -0,0 +1,28 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock18.ts === +function foo () { +>foo : () => typeof (Anonymous class) + + return class { +>class { static foo = 1; static { const c = class { static bar = 2; static { // do } } } } : typeof (Anonymous class) + + static foo = 1; +>foo : number +>1 : 1 + + static { + const c = class { +>c : typeof c +>class { static bar = 2; static { // do } } : typeof c + + static bar = 2; +>bar : number +>2 : 2 + + static { + // do + } + } + } + } +} + diff --git a/tests/baselines/reference/classStaticBlock2(target=es2022).js b/tests/baselines/reference/classStaticBlock2(target=es2022).js new file mode 100644 index 0000000000000..ccff801b61335 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock2(target=es2022).js @@ -0,0 +1,36 @@ +//// [classStaticBlock2.ts] +const a = 1; +const b = 2; + +class C { + static { + const a = 11; + + a; + b; + } + + static { + const a = 11; + + a; + b; + } +} + + +//// [classStaticBlock2.js] +const a = 1; +const b = 2; +class C { + static { + const a = 11; + a; + b; + } + static { + const a = 11; + a; + b; + } +} diff --git a/tests/baselines/reference/classStaticBlock2(target=es2022).symbols b/tests/baselines/reference/classStaticBlock2(target=es2022).symbols new file mode 100644 index 0000000000000..93bfa964aaeb6 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock2(target=es2022).symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock2.ts === +const a = 1; +>a : Symbol(a, Decl(classStaticBlock2.ts, 0, 5)) + +const b = 2; +>b : Symbol(b, Decl(classStaticBlock2.ts, 1, 5)) + +class C { +>C : Symbol(C, Decl(classStaticBlock2.ts, 1, 12)) + + static { + const a = 11; +>a : Symbol(a, Decl(classStaticBlock2.ts, 5, 13)) + + a; +>a : Symbol(a, Decl(classStaticBlock2.ts, 5, 13)) + + b; +>b : Symbol(b, Decl(classStaticBlock2.ts, 1, 5)) + } + + static { + const a = 11; +>a : Symbol(a, Decl(classStaticBlock2.ts, 12, 13)) + + a; +>a : Symbol(a, Decl(classStaticBlock2.ts, 12, 13)) + + b; +>b : Symbol(b, Decl(classStaticBlock2.ts, 1, 5)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock2(target=es2022).types b/tests/baselines/reference/classStaticBlock2(target=es2022).types new file mode 100644 index 0000000000000..2e22833b22ddf --- /dev/null +++ b/tests/baselines/reference/classStaticBlock2(target=es2022).types @@ -0,0 +1,37 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock2.ts === +const a = 1; +>a : 1 +>1 : 1 + +const b = 2; +>b : 2 +>2 : 2 + +class C { +>C : C + + static { + const a = 11; +>a : 11 +>11 : 11 + + a; +>a : 11 + + b; +>b : 2 + } + + static { + const a = 11; +>a : 11 +>11 : 11 + + a; +>a : 11 + + b; +>b : 2 + } +} + diff --git a/tests/baselines/reference/classStaticBlock22(target=es2022).errors.txt b/tests/baselines/reference/classStaticBlock22(target=es2022).errors.txt new file mode 100644 index 0000000000000..2c4916721197e --- /dev/null +++ b/tests/baselines/reference/classStaticBlock22(target=es2022).errors.txt @@ -0,0 +1,95 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(4,9): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(7,11): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(13,9): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(16,14): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(19,11): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(29,15): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(32,12): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts (7 errors) ==== + let await: "any"; + class C { + static { + let await: any; // illegal, cannot declare a new binding for await + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + let { await } = {} as any; // illegal, cannot declare a new binding for await + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + let { await: other } = {} as any; // legal + } + static { + let await; // illegal, cannot declare a new binding for await + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + function await() { }; // illegal + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + class await { }; // illegal + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + + static { + class D { + await = 1; // legal + x = await; // legal (initializers have an implicit function boundary) + }; + } + static { + (function await() { }); // legal, 'await' in function expression name not bound inside of static block + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + (class await { }); // legal, 'await' in class expression name not bound inside of static block + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + (function () { return await; }); // legal, 'await' is inside of a new function boundary + } + static { + (() => await); // legal, 'await' is inside of a new function boundary + } + + static { + class E { + constructor() { await; } + method() { await; } + get accessor() { + await; + return 1; + } + set accessor(v: any) { + await; + } + propLambda = () => { await; } + propFunc = function () { await; } + } + } + static { + class S { + static method() { await; } + static get accessor() { + await; + return 1; + } + static set accessor(v: any) { + await; + } + static propLambda = () => { await; } + static propFunc = function () { await; } + } + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock22(target=es2022).js b/tests/baselines/reference/classStaticBlock22(target=es2022).js new file mode 100644 index 0000000000000..c148e501751f2 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock22(target=es2022).js @@ -0,0 +1,147 @@ +//// [classStaticBlock22.ts] +let await: "any"; +class C { + static { + let await: any; // illegal, cannot declare a new binding for await + } + static { + let { await } = {} as any; // illegal, cannot declare a new binding for await + } + static { + let { await: other } = {} as any; // legal + } + static { + let await; // illegal, cannot declare a new binding for await + } + static { + function await() { }; // illegal + } + static { + class await { }; // illegal + } + + static { + class D { + await = 1; // legal + x = await; // legal (initializers have an implicit function boundary) + }; + } + static { + (function await() { }); // legal, 'await' in function expression name not bound inside of static block + } + static { + (class await { }); // legal, 'await' in class expression name not bound inside of static block + } + static { + (function () { return await; }); // legal, 'await' is inside of a new function boundary + } + static { + (() => await); // legal, 'await' is inside of a new function boundary + } + + static { + class E { + constructor() { await; } + method() { await; } + get accessor() { + await; + return 1; + } + set accessor(v: any) { + await; + } + propLambda = () => { await; } + propFunc = function () { await; } + } + } + static { + class S { + static method() { await; } + static get accessor() { + await; + return 1; + } + static set accessor(v: any) { + await; + } + static propLambda = () => { await; } + static propFunc = function () { await; } + } + } +} + + +//// [classStaticBlock22.js] +let await; +class C { + static { + let await; // illegal, cannot declare a new binding for await + } + static { + let { await } = {}; // illegal, cannot declare a new binding for await + } + static { + let { await: other } = {}; // legal + } + static { + let await; // illegal, cannot declare a new binding for await + } + static { + function await() { } + ; // illegal + } + static { + class await { + } + ; // illegal + } + static { + class D { + await = 1; // legal + x = await; // legal (initializers have an implicit function boundary) + } + ; + } + static { + (function await() { }); // legal, 'await' in function expression name not bound inside of static block + } + static { + (class await { + }); // legal, 'await' in class expression name not bound inside of static block + } + static { + (function () { return await; }); // legal, 'await' is inside of a new function boundary + } + static { + (() => await); // legal, 'await' is inside of a new function boundary + } + static { + class E { + constructor() { await; } + method() { await; } + get accessor() { + await; + return 1; + } + set accessor(v) { + await; + } + propLambda = () => { await; }; + propFunc = function () { await; }; + } + } + static { + class S { + static method() { await; } + static get accessor() { + await; + return 1; + } + static set accessor(v) { + await; + } + static propLambda = () => { await; }; + static propFunc = function () { await; }; + } + } +} diff --git a/tests/baselines/reference/classStaticBlock22(target=es2022).symbols b/tests/baselines/reference/classStaticBlock22(target=es2022).symbols new file mode 100644 index 0000000000000..6d927f0fe6237 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock22(target=es2022).symbols @@ -0,0 +1,131 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts === +let await: "any"; +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + +class C { +>C : Symbol(C, Decl(classStaticBlock22.ts, 0, 17)) + + static { + let await: any; // illegal, cannot declare a new binding for await +>await : Symbol(await, Decl(classStaticBlock22.ts, 3, 7)) + } + static { + let { await } = {} as any; // illegal, cannot declare a new binding for await +>await : Symbol(await, Decl(classStaticBlock22.ts, 6, 9)) + } + static { + let { await: other } = {} as any; // legal +>other : Symbol(other, Decl(classStaticBlock22.ts, 9, 9)) + } + static { + let await; // illegal, cannot declare a new binding for await +>await : Symbol(await, Decl(classStaticBlock22.ts, 12, 7)) + } + static { + function await() { }; // illegal +>await : Symbol(await, Decl(classStaticBlock22.ts, 14, 10)) + } + static { + class await { }; // illegal +>await : Symbol(await, Decl(classStaticBlock22.ts, 17, 10)) + } + + static { + class D { +>D : Symbol(D, Decl(classStaticBlock22.ts, 21, 10)) + + await = 1; // legal +>await : Symbol(D.await, Decl(classStaticBlock22.ts, 22, 13)) + + x = await; // legal (initializers have an implicit function boundary) +>x : Symbol(D.x, Decl(classStaticBlock22.ts, 23, 16)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + }; + } + static { + (function await() { }); // legal, 'await' in function expression name not bound inside of static block +>await : Symbol(await, Decl(classStaticBlock22.ts, 28, 5)) + } + static { + (class await { }); // legal, 'await' in class expression name not bound inside of static block +>await : Symbol(await, Decl(classStaticBlock22.ts, 31, 5)) + } + static { + (function () { return await; }); // legal, 'await' is inside of a new function boundary +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + static { + (() => await); // legal, 'await' is inside of a new function boundary +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + + static { + class E { +>E : Symbol(E, Decl(classStaticBlock22.ts, 40, 10)) + + constructor() { await; } +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + method() { await; } +>method : Symbol(E.method, Decl(classStaticBlock22.ts, 42, 30)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + get accessor() { +>accessor : Symbol(E.accessor, Decl(classStaticBlock22.ts, 43, 25), Decl(classStaticBlock22.ts, 47, 7)) + + await; +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + return 1; + } + set accessor(v: any) { +>accessor : Symbol(E.accessor, Decl(classStaticBlock22.ts, 43, 25), Decl(classStaticBlock22.ts, 47, 7)) +>v : Symbol(v, Decl(classStaticBlock22.ts, 48, 19)) + + await; +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + propLambda = () => { await; } +>propLambda : Symbol(E.propLambda, Decl(classStaticBlock22.ts, 50, 7)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + propFunc = function () { await; } +>propFunc : Symbol(E.propFunc, Decl(classStaticBlock22.ts, 51, 35)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + } + static { + class S { +>S : Symbol(S, Decl(classStaticBlock22.ts, 55, 10)) + + static method() { await; } +>method : Symbol(S.method, Decl(classStaticBlock22.ts, 56, 13)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + static get accessor() { +>accessor : Symbol(S.accessor, Decl(classStaticBlock22.ts, 57, 32), Decl(classStaticBlock22.ts, 61, 7)) + + await; +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + return 1; + } + static set accessor(v: any) { +>accessor : Symbol(S.accessor, Decl(classStaticBlock22.ts, 57, 32), Decl(classStaticBlock22.ts, 61, 7)) +>v : Symbol(v, Decl(classStaticBlock22.ts, 62, 26)) + + await; +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + static propLambda = () => { await; } +>propLambda : Symbol(S.propLambda, Decl(classStaticBlock22.ts, 64, 7)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + static propFunc = function () { await; } +>propFunc : Symbol(S.propFunc, Decl(classStaticBlock22.ts, 65, 42)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + } +} + diff --git a/tests/baselines/reference/classStaticBlock22(target=es2022).types b/tests/baselines/reference/classStaticBlock22(target=es2022).types new file mode 100644 index 0000000000000..ea9ac111e6129 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock22(target=es2022).types @@ -0,0 +1,151 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts === +let await: "any"; +>await : "any" + +class C { +>C : C + + static { + let await: any; // illegal, cannot declare a new binding for await +>await : any + } + static { + let { await } = {} as any; // illegal, cannot declare a new binding for await +>await : any +>{} as any : any +>{} : {} + } + static { + let { await: other } = {} as any; // legal +>await : any +>other : any +>{} as any : any +>{} : {} + } + static { + let await; // illegal, cannot declare a new binding for await +>await : any + } + static { + function await() { }; // illegal +>await : () => void + } + static { + class await { }; // illegal +>await : await + } + + static { + class D { +>D : D + + await = 1; // legal +>await : number +>1 : 1 + + x = await; // legal (initializers have an implicit function boundary) +>x : "any" +>await : "any" + + }; + } + static { + (function await() { }); // legal, 'await' in function expression name not bound inside of static block +>(function await() { }) : () => void +>function await() { } : () => void +>await : () => void + } + static { + (class await { }); // legal, 'await' in class expression name not bound inside of static block +>(class await { }) : typeof await +>class await { } : typeof await +>await : typeof await + } + static { + (function () { return await; }); // legal, 'await' is inside of a new function boundary +>(function () { return await; }) : () => "any" +>function () { return await; } : () => "any" +>await : "any" + } + static { + (() => await); // legal, 'await' is inside of a new function boundary +>(() => await) : () => "any" +>() => await : () => "any" +>await : "any" + } + + static { + class E { +>E : E + + constructor() { await; } +>await : "any" + + method() { await; } +>method : () => void +>await : "any" + + get accessor() { +>accessor : any + + await; +>await : "any" + + return 1; +>1 : 1 + } + set accessor(v: any) { +>accessor : any +>v : any + + await; +>await : "any" + } + propLambda = () => { await; } +>propLambda : () => void +>() => { await; } : () => void +>await : "any" + + propFunc = function () { await; } +>propFunc : () => void +>function () { await; } : () => void +>await : "any" + } + } + static { + class S { +>S : S + + static method() { await; } +>method : () => void +>await : "any" + + static get accessor() { +>accessor : any + + await; +>await : "any" + + return 1; +>1 : 1 + } + static set accessor(v: any) { +>accessor : any +>v : any + + await; +>await : "any" + } + static propLambda = () => { await; } +>propLambda : () => void +>() => { await; } : () => void +>await : "any" + + static propFunc = function () { await; } +>propFunc : () => void +>function () { await; } : () => void +>await : "any" + } + } +} + diff --git a/tests/baselines/reference/classStaticBlock22(target=esnext).errors.txt b/tests/baselines/reference/classStaticBlock22(target=esnext).errors.txt new file mode 100644 index 0000000000000..2c4916721197e --- /dev/null +++ b/tests/baselines/reference/classStaticBlock22(target=esnext).errors.txt @@ -0,0 +1,95 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(4,9): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(7,11): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(13,9): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(16,14): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(19,11): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(29,15): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts(32,12): error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts (7 errors) ==== + let await: "any"; + class C { + static { + let await: any; // illegal, cannot declare a new binding for await + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + let { await } = {} as any; // illegal, cannot declare a new binding for await + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + let { await: other } = {} as any; // legal + } + static { + let await; // illegal, cannot declare a new binding for await + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + function await() { }; // illegal + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + class await { }; // illegal + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + + static { + class D { + await = 1; // legal + x = await; // legal (initializers have an implicit function boundary) + }; + } + static { + (function await() { }); // legal, 'await' in function expression name not bound inside of static block + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + (class await { }); // legal, 'await' in class expression name not bound inside of static block + ~~~~~ +!!! error TS1359: Identifier expected. 'await' is a reserved word that cannot be used here. + } + static { + (function () { return await; }); // legal, 'await' is inside of a new function boundary + } + static { + (() => await); // legal, 'await' is inside of a new function boundary + } + + static { + class E { + constructor() { await; } + method() { await; } + get accessor() { + await; + return 1; + } + set accessor(v: any) { + await; + } + propLambda = () => { await; } + propFunc = function () { await; } + } + } + static { + class S { + static method() { await; } + static get accessor() { + await; + return 1; + } + static set accessor(v: any) { + await; + } + static propLambda = () => { await; } + static propFunc = function () { await; } + } + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock22(target=esnext).js b/tests/baselines/reference/classStaticBlock22(target=esnext).js new file mode 100644 index 0000000000000..c148e501751f2 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock22(target=esnext).js @@ -0,0 +1,147 @@ +//// [classStaticBlock22.ts] +let await: "any"; +class C { + static { + let await: any; // illegal, cannot declare a new binding for await + } + static { + let { await } = {} as any; // illegal, cannot declare a new binding for await + } + static { + let { await: other } = {} as any; // legal + } + static { + let await; // illegal, cannot declare a new binding for await + } + static { + function await() { }; // illegal + } + static { + class await { }; // illegal + } + + static { + class D { + await = 1; // legal + x = await; // legal (initializers have an implicit function boundary) + }; + } + static { + (function await() { }); // legal, 'await' in function expression name not bound inside of static block + } + static { + (class await { }); // legal, 'await' in class expression name not bound inside of static block + } + static { + (function () { return await; }); // legal, 'await' is inside of a new function boundary + } + static { + (() => await); // legal, 'await' is inside of a new function boundary + } + + static { + class E { + constructor() { await; } + method() { await; } + get accessor() { + await; + return 1; + } + set accessor(v: any) { + await; + } + propLambda = () => { await; } + propFunc = function () { await; } + } + } + static { + class S { + static method() { await; } + static get accessor() { + await; + return 1; + } + static set accessor(v: any) { + await; + } + static propLambda = () => { await; } + static propFunc = function () { await; } + } + } +} + + +//// [classStaticBlock22.js] +let await; +class C { + static { + let await; // illegal, cannot declare a new binding for await + } + static { + let { await } = {}; // illegal, cannot declare a new binding for await + } + static { + let { await: other } = {}; // legal + } + static { + let await; // illegal, cannot declare a new binding for await + } + static { + function await() { } + ; // illegal + } + static { + class await { + } + ; // illegal + } + static { + class D { + await = 1; // legal + x = await; // legal (initializers have an implicit function boundary) + } + ; + } + static { + (function await() { }); // legal, 'await' in function expression name not bound inside of static block + } + static { + (class await { + }); // legal, 'await' in class expression name not bound inside of static block + } + static { + (function () { return await; }); // legal, 'await' is inside of a new function boundary + } + static { + (() => await); // legal, 'await' is inside of a new function boundary + } + static { + class E { + constructor() { await; } + method() { await; } + get accessor() { + await; + return 1; + } + set accessor(v) { + await; + } + propLambda = () => { await; }; + propFunc = function () { await; }; + } + } + static { + class S { + static method() { await; } + static get accessor() { + await; + return 1; + } + static set accessor(v) { + await; + } + static propLambda = () => { await; }; + static propFunc = function () { await; }; + } + } +} diff --git a/tests/baselines/reference/classStaticBlock22(target=esnext).symbols b/tests/baselines/reference/classStaticBlock22(target=esnext).symbols new file mode 100644 index 0000000000000..6d927f0fe6237 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock22(target=esnext).symbols @@ -0,0 +1,131 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts === +let await: "any"; +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + +class C { +>C : Symbol(C, Decl(classStaticBlock22.ts, 0, 17)) + + static { + let await: any; // illegal, cannot declare a new binding for await +>await : Symbol(await, Decl(classStaticBlock22.ts, 3, 7)) + } + static { + let { await } = {} as any; // illegal, cannot declare a new binding for await +>await : Symbol(await, Decl(classStaticBlock22.ts, 6, 9)) + } + static { + let { await: other } = {} as any; // legal +>other : Symbol(other, Decl(classStaticBlock22.ts, 9, 9)) + } + static { + let await; // illegal, cannot declare a new binding for await +>await : Symbol(await, Decl(classStaticBlock22.ts, 12, 7)) + } + static { + function await() { }; // illegal +>await : Symbol(await, Decl(classStaticBlock22.ts, 14, 10)) + } + static { + class await { }; // illegal +>await : Symbol(await, Decl(classStaticBlock22.ts, 17, 10)) + } + + static { + class D { +>D : Symbol(D, Decl(classStaticBlock22.ts, 21, 10)) + + await = 1; // legal +>await : Symbol(D.await, Decl(classStaticBlock22.ts, 22, 13)) + + x = await; // legal (initializers have an implicit function boundary) +>x : Symbol(D.x, Decl(classStaticBlock22.ts, 23, 16)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + }; + } + static { + (function await() { }); // legal, 'await' in function expression name not bound inside of static block +>await : Symbol(await, Decl(classStaticBlock22.ts, 28, 5)) + } + static { + (class await { }); // legal, 'await' in class expression name not bound inside of static block +>await : Symbol(await, Decl(classStaticBlock22.ts, 31, 5)) + } + static { + (function () { return await; }); // legal, 'await' is inside of a new function boundary +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + static { + (() => await); // legal, 'await' is inside of a new function boundary +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + + static { + class E { +>E : Symbol(E, Decl(classStaticBlock22.ts, 40, 10)) + + constructor() { await; } +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + method() { await; } +>method : Symbol(E.method, Decl(classStaticBlock22.ts, 42, 30)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + get accessor() { +>accessor : Symbol(E.accessor, Decl(classStaticBlock22.ts, 43, 25), Decl(classStaticBlock22.ts, 47, 7)) + + await; +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + return 1; + } + set accessor(v: any) { +>accessor : Symbol(E.accessor, Decl(classStaticBlock22.ts, 43, 25), Decl(classStaticBlock22.ts, 47, 7)) +>v : Symbol(v, Decl(classStaticBlock22.ts, 48, 19)) + + await; +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + propLambda = () => { await; } +>propLambda : Symbol(E.propLambda, Decl(classStaticBlock22.ts, 50, 7)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + propFunc = function () { await; } +>propFunc : Symbol(E.propFunc, Decl(classStaticBlock22.ts, 51, 35)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + } + static { + class S { +>S : Symbol(S, Decl(classStaticBlock22.ts, 55, 10)) + + static method() { await; } +>method : Symbol(S.method, Decl(classStaticBlock22.ts, 56, 13)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + static get accessor() { +>accessor : Symbol(S.accessor, Decl(classStaticBlock22.ts, 57, 32), Decl(classStaticBlock22.ts, 61, 7)) + + await; +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + return 1; + } + static set accessor(v: any) { +>accessor : Symbol(S.accessor, Decl(classStaticBlock22.ts, 57, 32), Decl(classStaticBlock22.ts, 61, 7)) +>v : Symbol(v, Decl(classStaticBlock22.ts, 62, 26)) + + await; +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + static propLambda = () => { await; } +>propLambda : Symbol(S.propLambda, Decl(classStaticBlock22.ts, 64, 7)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + + static propFunc = function () { await; } +>propFunc : Symbol(S.propFunc, Decl(classStaticBlock22.ts, 65, 42)) +>await : Symbol(await, Decl(classStaticBlock22.ts, 0, 3)) + } + } +} + diff --git a/tests/baselines/reference/classStaticBlock22(target=esnext).types b/tests/baselines/reference/classStaticBlock22(target=esnext).types new file mode 100644 index 0000000000000..ea9ac111e6129 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock22(target=esnext).types @@ -0,0 +1,151 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts === +let await: "any"; +>await : "any" + +class C { +>C : C + + static { + let await: any; // illegal, cannot declare a new binding for await +>await : any + } + static { + let { await } = {} as any; // illegal, cannot declare a new binding for await +>await : any +>{} as any : any +>{} : {} + } + static { + let { await: other } = {} as any; // legal +>await : any +>other : any +>{} as any : any +>{} : {} + } + static { + let await; // illegal, cannot declare a new binding for await +>await : any + } + static { + function await() { }; // illegal +>await : () => void + } + static { + class await { }; // illegal +>await : await + } + + static { + class D { +>D : D + + await = 1; // legal +>await : number +>1 : 1 + + x = await; // legal (initializers have an implicit function boundary) +>x : "any" +>await : "any" + + }; + } + static { + (function await() { }); // legal, 'await' in function expression name not bound inside of static block +>(function await() { }) : () => void +>function await() { } : () => void +>await : () => void + } + static { + (class await { }); // legal, 'await' in class expression name not bound inside of static block +>(class await { }) : typeof await +>class await { } : typeof await +>await : typeof await + } + static { + (function () { return await; }); // legal, 'await' is inside of a new function boundary +>(function () { return await; }) : () => "any" +>function () { return await; } : () => "any" +>await : "any" + } + static { + (() => await); // legal, 'await' is inside of a new function boundary +>(() => await) : () => "any" +>() => await : () => "any" +>await : "any" + } + + static { + class E { +>E : E + + constructor() { await; } +>await : "any" + + method() { await; } +>method : () => void +>await : "any" + + get accessor() { +>accessor : any + + await; +>await : "any" + + return 1; +>1 : 1 + } + set accessor(v: any) { +>accessor : any +>v : any + + await; +>await : "any" + } + propLambda = () => { await; } +>propLambda : () => void +>() => { await; } : () => void +>await : "any" + + propFunc = function () { await; } +>propFunc : () => void +>function () { await; } : () => void +>await : "any" + } + } + static { + class S { +>S : S + + static method() { await; } +>method : () => void +>await : "any" + + static get accessor() { +>accessor : any + + await; +>await : "any" + + return 1; +>1 : 1 + } + static set accessor(v: any) { +>accessor : any +>v : any + + await; +>await : "any" + } + static propLambda = () => { await; } +>propLambda : () => void +>() => { await; } : () => void +>await : "any" + + static propFunc = function () { await; } +>propFunc : () => void +>function () { await; } : () => void +>await : "any" + } + } +} + diff --git a/tests/baselines/reference/classStaticBlock23(target=es2022).errors.txt b/tests/baselines/reference/classStaticBlock23(target=es2022).errors.txt new file mode 100644 index 0000000000000..7e13f7c9e3f54 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock23(target=es2022).errors.txt @@ -0,0 +1,29 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts(5,9): error TS18038: 'For await' loops cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts(14,11): error TS18038: 'For await' loops cannot be used inside a class static block. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts (2 errors) ==== + const nums = [1, 2, 3].map(n => Promise.resolve(n)) + + class C { + static { + for await (const nn of nums) { + ~~~~~ +!!! error TS18038: 'For await' loops cannot be used inside a class static block. + console.log(nn) + } + } + } + + async function foo () { + class C { + static { + for await (const nn of nums) { + ~~~~~ +!!! error TS18038: 'For await' loops cannot be used inside a class static block. + console.log(nn) + } + } + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock23(target=es2022).js b/tests/baselines/reference/classStaticBlock23(target=es2022).js new file mode 100644 index 0000000000000..9795859bc39bd --- /dev/null +++ b/tests/baselines/reference/classStaticBlock23(target=es2022).js @@ -0,0 +1,40 @@ +//// [classStaticBlock23.ts] +const nums = [1, 2, 3].map(n => Promise.resolve(n)) + +class C { + static { + for await (const nn of nums) { + console.log(nn) + } + } +} + +async function foo () { + class C { + static { + for await (const nn of nums) { + console.log(nn) + } + } + } +} + + +//// [classStaticBlock23.js] +const nums = [1, 2, 3].map(n => Promise.resolve(n)); +class C { + static { + for await (const nn of nums) { + console.log(nn); + } + } +} +async function foo() { + class C { + static { + for await (const nn of nums) { + console.log(nn); + } + } + } +} diff --git a/tests/baselines/reference/classStaticBlock23(target=es2022).symbols b/tests/baselines/reference/classStaticBlock23(target=es2022).symbols new file mode 100644 index 0000000000000..2e15bade3be31 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock23(target=es2022).symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts === +const nums = [1, 2, 3].map(n => Promise.resolve(n)) +>nums : Symbol(nums, Decl(classStaticBlock23.ts, 0, 5)) +>[1, 2, 3].map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>n : Symbol(n, Decl(classStaticBlock23.ts, 0, 27)) +>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>n : Symbol(n, Decl(classStaticBlock23.ts, 0, 27)) + +class C { +>C : Symbol(C, Decl(classStaticBlock23.ts, 0, 51)) + + static { + for await (const nn of nums) { +>nn : Symbol(nn, Decl(classStaticBlock23.ts, 4, 20)) +>nums : Symbol(nums, Decl(classStaticBlock23.ts, 0, 5)) + + console.log(nn) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>nn : Symbol(nn, Decl(classStaticBlock23.ts, 4, 20)) + } + } +} + +async function foo () { +>foo : Symbol(foo, Decl(classStaticBlock23.ts, 8, 1)) + + class C { +>C : Symbol(C, Decl(classStaticBlock23.ts, 10, 23)) + + static { + for await (const nn of nums) { +>nn : Symbol(nn, Decl(classStaticBlock23.ts, 13, 22)) +>nums : Symbol(nums, Decl(classStaticBlock23.ts, 0, 5)) + + console.log(nn) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>nn : Symbol(nn, Decl(classStaticBlock23.ts, 13, 22)) + } + } + } +} + diff --git a/tests/baselines/reference/classStaticBlock23(target=es2022).types b/tests/baselines/reference/classStaticBlock23(target=es2022).types new file mode 100644 index 0000000000000..421336fa087c9 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock23(target=es2022).types @@ -0,0 +1,58 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts === +const nums = [1, 2, 3].map(n => Promise.resolve(n)) +>nums : Promise[] +>[1, 2, 3].map(n => Promise.resolve(n)) : Promise[] +>[1, 2, 3].map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>n => Promise.resolve(n) : (n: number) => Promise +>n : number +>Promise.resolve(n) : Promise +>Promise.resolve : { (): Promise; (value: T | PromiseLike): Promise; } +>Promise : PromiseConstructor +>resolve : { (): Promise; (value: T | PromiseLike): Promise; } +>n : number + +class C { +>C : C + + static { + for await (const nn of nums) { +>nn : number +>nums : Promise[] + + console.log(nn) +>console.log(nn) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>nn : number + } + } +} + +async function foo () { +>foo : () => Promise + + class C { +>C : C + + static { + for await (const nn of nums) { +>nn : number +>nums : Promise[] + + console.log(nn) +>console.log(nn) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>nn : number + } + } + } +} + diff --git a/tests/baselines/reference/classStaticBlock23(target=esnext).errors.txt b/tests/baselines/reference/classStaticBlock23(target=esnext).errors.txt new file mode 100644 index 0000000000000..7e13f7c9e3f54 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock23(target=esnext).errors.txt @@ -0,0 +1,29 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts(5,9): error TS18038: 'For await' loops cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts(14,11): error TS18038: 'For await' loops cannot be used inside a class static block. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts (2 errors) ==== + const nums = [1, 2, 3].map(n => Promise.resolve(n)) + + class C { + static { + for await (const nn of nums) { + ~~~~~ +!!! error TS18038: 'For await' loops cannot be used inside a class static block. + console.log(nn) + } + } + } + + async function foo () { + class C { + static { + for await (const nn of nums) { + ~~~~~ +!!! error TS18038: 'For await' loops cannot be used inside a class static block. + console.log(nn) + } + } + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock23(target=esnext).js b/tests/baselines/reference/classStaticBlock23(target=esnext).js new file mode 100644 index 0000000000000..9795859bc39bd --- /dev/null +++ b/tests/baselines/reference/classStaticBlock23(target=esnext).js @@ -0,0 +1,40 @@ +//// [classStaticBlock23.ts] +const nums = [1, 2, 3].map(n => Promise.resolve(n)) + +class C { + static { + for await (const nn of nums) { + console.log(nn) + } + } +} + +async function foo () { + class C { + static { + for await (const nn of nums) { + console.log(nn) + } + } + } +} + + +//// [classStaticBlock23.js] +const nums = [1, 2, 3].map(n => Promise.resolve(n)); +class C { + static { + for await (const nn of nums) { + console.log(nn); + } + } +} +async function foo() { + class C { + static { + for await (const nn of nums) { + console.log(nn); + } + } + } +} diff --git a/tests/baselines/reference/classStaticBlock23(target=esnext).symbols b/tests/baselines/reference/classStaticBlock23(target=esnext).symbols new file mode 100644 index 0000000000000..2e15bade3be31 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock23(target=esnext).symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts === +const nums = [1, 2, 3].map(n => Promise.resolve(n)) +>nums : Symbol(nums, Decl(classStaticBlock23.ts, 0, 5)) +>[1, 2, 3].map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>map : Symbol(Array.map, Decl(lib.es5.d.ts, --, --)) +>n : Symbol(n, Decl(classStaticBlock23.ts, 0, 27)) +>Promise.resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.iterable.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2018.promise.d.ts, --, --)) +>resolve : Symbol(PromiseConstructor.resolve, Decl(lib.es2015.promise.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --)) +>n : Symbol(n, Decl(classStaticBlock23.ts, 0, 27)) + +class C { +>C : Symbol(C, Decl(classStaticBlock23.ts, 0, 51)) + + static { + for await (const nn of nums) { +>nn : Symbol(nn, Decl(classStaticBlock23.ts, 4, 20)) +>nums : Symbol(nums, Decl(classStaticBlock23.ts, 0, 5)) + + console.log(nn) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>nn : Symbol(nn, Decl(classStaticBlock23.ts, 4, 20)) + } + } +} + +async function foo () { +>foo : Symbol(foo, Decl(classStaticBlock23.ts, 8, 1)) + + class C { +>C : Symbol(C, Decl(classStaticBlock23.ts, 10, 23)) + + static { + for await (const nn of nums) { +>nn : Symbol(nn, Decl(classStaticBlock23.ts, 13, 22)) +>nums : Symbol(nums, Decl(classStaticBlock23.ts, 0, 5)) + + console.log(nn) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>nn : Symbol(nn, Decl(classStaticBlock23.ts, 13, 22)) + } + } + } +} + diff --git a/tests/baselines/reference/classStaticBlock23(target=esnext).types b/tests/baselines/reference/classStaticBlock23(target=esnext).types new file mode 100644 index 0000000000000..421336fa087c9 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock23(target=esnext).types @@ -0,0 +1,58 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts === +const nums = [1, 2, 3].map(n => Promise.resolve(n)) +>nums : Promise[] +>[1, 2, 3].map(n => Promise.resolve(n)) : Promise[] +>[1, 2, 3].map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>[1, 2, 3] : number[] +>1 : 1 +>2 : 2 +>3 : 3 +>map : (callbackfn: (value: number, index: number, array: number[]) => U, thisArg?: any) => U[] +>n => Promise.resolve(n) : (n: number) => Promise +>n : number +>Promise.resolve(n) : Promise +>Promise.resolve : { (): Promise; (value: T | PromiseLike): Promise; } +>Promise : PromiseConstructor +>resolve : { (): Promise; (value: T | PromiseLike): Promise; } +>n : number + +class C { +>C : C + + static { + for await (const nn of nums) { +>nn : number +>nums : Promise[] + + console.log(nn) +>console.log(nn) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>nn : number + } + } +} + +async function foo () { +>foo : () => Promise + + class C { +>C : C + + static { + for await (const nn of nums) { +>nn : number +>nums : Promise[] + + console.log(nn) +>console.log(nn) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>nn : number + } + } + } +} + diff --git a/tests/baselines/reference/classStaticBlock24(module=es2022).js b/tests/baselines/reference/classStaticBlock24(module=es2022).js new file mode 100644 index 0000000000000..450e53df8a141 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock24(module=es2022).js @@ -0,0 +1,19 @@ +//// [classStaticBlock24.ts] +export class C { + static x: number; + static { + C.x = 1; + } +} + + +//// [classStaticBlock24.js] +var C = /** @class */ (function () { + function C() { + } + return C; +}()); +export { C }; +(function () { + C.x = 1; +})(); diff --git a/tests/baselines/reference/classStaticBlock24(module=es2022).symbols b/tests/baselines/reference/classStaticBlock24(module=es2022).symbols new file mode 100644 index 0000000000000..41b09da5f7732 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock24(module=es2022).symbols @@ -0,0 +1,15 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock24.ts === +export class C { +>C : Symbol(C, Decl(classStaticBlock24.ts, 0, 0)) + + static x: number; +>x : Symbol(C.x, Decl(classStaticBlock24.ts, 0, 16)) + + static { + C.x = 1; +>C.x : Symbol(C.x, Decl(classStaticBlock24.ts, 0, 16)) +>C : Symbol(C, Decl(classStaticBlock24.ts, 0, 0)) +>x : Symbol(C.x, Decl(classStaticBlock24.ts, 0, 16)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock24(module=es2022).types b/tests/baselines/reference/classStaticBlock24(module=es2022).types new file mode 100644 index 0000000000000..15bf228fcc593 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock24(module=es2022).types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock24.ts === +export class C { +>C : C + + static x: number; +>x : number + + static { + C.x = 1; +>C.x = 1 : 1 +>C.x : number +>C : typeof C +>x : number +>1 : 1 + } +} + diff --git a/tests/baselines/reference/classStaticBlock25(target=es2022).js b/tests/baselines/reference/classStaticBlock25(target=es2022).js new file mode 100644 index 0000000000000..79864030028c1 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock25(target=es2022).js @@ -0,0 +1,44 @@ +//// [classStaticBlock25.ts] +const a = 1; +const b = 2; + +class C { + static { + const a = 11; + + a; + b; + } + + static { + const a = 11; + + a; + b; + } +} + + +//// [classStaticBlock25.js] +const a = 1; +const b = 2; +class C { + static { + const a = 11; + a; + b; + } + static { + const a = 11; + a; + b; + } +} +//# sourceMappingURL=classStaticBlock25.js.map + +//// [classStaticBlock25.d.ts] +declare const a = 1; +declare const b = 2; +declare class C { +} +//# sourceMappingURL=classStaticBlock25.d.ts.map \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock25(target=es2022).js.map b/tests/baselines/reference/classStaticBlock25(target=es2022).js.map new file mode 100644 index 0000000000000..f3bccac8cb86f --- /dev/null +++ b/tests/baselines/reference/classStaticBlock25(target=es2022).js.map @@ -0,0 +1,7 @@ +//// [classStaticBlock25.js.map] +{"version":3,"file":"classStaticBlock25.js","sourceRoot":"","sources":["classStaticBlock25.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,GAAG,CAAC,CAAC;AACZ,MAAM,CAAC,GAAG,CAAC,CAAC;AAEZ,MAAM,CAAC;IACH;QACI,MAAM,CAAC,GAAG,EAAE,CAAC;QAEb,CAAC,CAAC;QACF,CAAC,CAAC;IACN,CAAC;IAED;QACI,MAAM,CAAC,GAAG,EAAE,CAAC;QAEb,CAAC,CAAC;QACF,CAAC,CAAC;IACN,CAAC;CACJ"} +//// https://sokra.github.io/source-map-visualization#base64,Y29uc3QgYSA9IDE7DQpjb25zdCBiID0gMjsNCmNsYXNzIEMgew0KICAgIHN0YXRpYyB7DQogICAgICAgIGNvbnN0IGEgPSAxMTsNCiAgICAgICAgYTsNCiAgICAgICAgYjsNCiAgICB9DQogICAgc3RhdGljIHsNCiAgICAgICAgY29uc3QgYSA9IDExOw0KICAgICAgICBhOw0KICAgICAgICBiOw0KICAgIH0NCn0NCi8vIyBzb3VyY2VNYXBwaW5nVVJMPWNsYXNzU3RhdGljQmxvY2syNS5qcy5tYXA=,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3NTdGF0aWNCbG9jazI1LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiY2xhc3NTdGF0aWNCbG9jazI1LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNaLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUVaLE1BQU0sQ0FBQztJQUNIO1FBQ0ksTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBRWIsQ0FBQyxDQUFDO1FBQ0YsQ0FBQyxDQUFDO0lBQ04sQ0FBQztJQUVEO1FBQ0ksTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBRWIsQ0FBQyxDQUFDO1FBQ0YsQ0FBQyxDQUFDO0lBQ04sQ0FBQztDQUNKIn0=,Y29uc3QgYSA9IDE7CmNvbnN0IGIgPSAyOwoKY2xhc3MgQyB7CiAgICBzdGF0aWMgewogICAgICAgIGNvbnN0IGEgPSAxMTsKCiAgICAgICAgYTsKICAgICAgICBiOwogICAgfQoKICAgIHN0YXRpYyB7CiAgICAgICAgY29uc3QgYSA9IDExOwoKICAgICAgICBhOwogICAgICAgIGI7CiAgICB9Cn0K + +//// [classStaticBlock25.d.ts.map] +{"version":3,"file":"classStaticBlock25.d.ts","sourceRoot":"","sources":["classStaticBlock25.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,CAAC,IAAI,CAAC;AACZ,QAAA,MAAM,CAAC,IAAI,CAAC;AAEZ,cAAM,CAAC;CAcN"} +//// https://sokra.github.io/source-map-visualization#base64,ZGVjbGFyZSBjb25zdCBhID0gMTsNCmRlY2xhcmUgY29uc3QgYiA9IDI7DQpkZWNsYXJlIGNsYXNzIEMgew0KfQ0KLy8jIHNvdXJjZU1hcHBpbmdVUkw9Y2xhc3NTdGF0aWNCbG9jazI1LmQudHMubWFw,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3NTdGF0aWNCbG9jazI1LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjbGFzc1N0YXRpY0Jsb2NrMjUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsUUFBQSxNQUFNLENBQUMsSUFBSSxDQUFDO0FBQ1osUUFBQSxNQUFNLENBQUMsSUFBSSxDQUFDO0FBRVosY0FBTSxDQUFDO0NBY04ifQ==,Y29uc3QgYSA9IDE7CmNvbnN0IGIgPSAyOwoKY2xhc3MgQyB7CiAgICBzdGF0aWMgewogICAgICAgIGNvbnN0IGEgPSAxMTsKCiAgICAgICAgYTsKICAgICAgICBiOwogICAgfQoKICAgIHN0YXRpYyB7CiAgICAgICAgY29uc3QgYSA9IDExOwoKICAgICAgICBhOwogICAgICAgIGI7CiAgICB9Cn0K diff --git a/tests/baselines/reference/classStaticBlock25(target=es2022).sourcemap.txt b/tests/baselines/reference/classStaticBlock25(target=es2022).sourcemap.txt new file mode 100644 index 0000000000000..91f7b7913f116 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock25(target=es2022).sourcemap.txt @@ -0,0 +1,287 @@ +=================================================================== +JsFile: classStaticBlock25.js +mapUrl: classStaticBlock25.js.map +sourceRoot: +sources: classStaticBlock25.ts +=================================================================== +------------------------------------------------------------------- +emittedFile:tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.js +sourceFile:classStaticBlock25.ts +------------------------------------------------------------------- +>>>const a = 1; +1 > +2 >^^^^^^ +3 > ^ +4 > ^^^ +5 > ^ +6 > ^ +7 > ^-> +1 > +2 >const +3 > a +4 > = +5 > 1 +6 > ; +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 7) Source(1, 7) + SourceIndex(0) +3 >Emitted(1, 8) Source(1, 8) + SourceIndex(0) +4 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +5 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) +6 >Emitted(1, 13) Source(1, 13) + SourceIndex(0) +--- +>>>const b = 2; +1-> +2 >^^^^^^ +3 > ^ +4 > ^^^ +5 > ^ +6 > ^ +1-> + > +2 >const +3 > b +4 > = +5 > 2 +6 > ; +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 7) Source(2, 7) + SourceIndex(0) +3 >Emitted(2, 8) Source(2, 8) + SourceIndex(0) +4 >Emitted(2, 11) Source(2, 11) + SourceIndex(0) +5 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) +6 >Emitted(2, 13) Source(2, 13) + SourceIndex(0) +--- +>>>class C { +1 > +2 >^^^^^^ +3 > ^ +4 > ^^^^^^-> +1 > + > + > +2 >class +3 > C +1 >Emitted(3, 1) Source(4, 1) + SourceIndex(0) +2 >Emitted(3, 7) Source(4, 7) + SourceIndex(0) +3 >Emitted(3, 8) Source(4, 8) + SourceIndex(0) +--- +>>> static { +1->^^^^ +2 > ^^^^^^^^^^^^^^^^^^-> +1-> { + > +1->Emitted(4, 5) Source(5, 5) + SourceIndex(0) +--- +>>> const a = 11; +1->^^^^^^^^ +2 > ^^^^^^ +3 > ^ +4 > ^^^ +5 > ^^ +6 > ^ +1->static { + > +2 > const +3 > a +4 > = +5 > 11 +6 > ; +1->Emitted(5, 9) Source(6, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(6, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(6, 16) + SourceIndex(0) +4 >Emitted(5, 19) Source(6, 19) + SourceIndex(0) +5 >Emitted(5, 21) Source(6, 21) + SourceIndex(0) +6 >Emitted(5, 22) Source(6, 22) + SourceIndex(0) +--- +>>> a; +1 >^^^^^^^^ +2 > ^ +3 > ^ +4 > ^-> +1 > + > + > +2 > a +3 > ; +1 >Emitted(6, 9) Source(8, 9) + SourceIndex(0) +2 >Emitted(6, 10) Source(8, 10) + SourceIndex(0) +3 >Emitted(6, 11) Source(8, 11) + SourceIndex(0) +--- +>>> b; +1->^^^^^^^^ +2 > ^ +3 > ^ +1-> + > +2 > b +3 > ; +1->Emitted(7, 9) Source(9, 9) + SourceIndex(0) +2 >Emitted(7, 10) Source(9, 10) + SourceIndex(0) +3 >Emitted(7, 11) Source(9, 11) + SourceIndex(0) +--- +>>> } +1 >^^^^ +2 > ^ +3 > ^^^^^^^^-> +1 > + > +2 > } +1 >Emitted(8, 5) Source(10, 5) + SourceIndex(0) +2 >Emitted(8, 6) Source(10, 6) + SourceIndex(0) +--- +>>> static { +1->^^^^ +2 > ^^^^^^^^^^^^^^^^^^-> +1-> + > + > +1->Emitted(9, 5) Source(12, 5) + SourceIndex(0) +--- +>>> const a = 11; +1->^^^^^^^^ +2 > ^^^^^^ +3 > ^ +4 > ^^^ +5 > ^^ +6 > ^ +1->static { + > +2 > const +3 > a +4 > = +5 > 11 +6 > ; +1->Emitted(10, 9) Source(13, 9) + SourceIndex(0) +2 >Emitted(10, 15) Source(13, 15) + SourceIndex(0) +3 >Emitted(10, 16) Source(13, 16) + SourceIndex(0) +4 >Emitted(10, 19) Source(13, 19) + SourceIndex(0) +5 >Emitted(10, 21) Source(13, 21) + SourceIndex(0) +6 >Emitted(10, 22) Source(13, 22) + SourceIndex(0) +--- +>>> a; +1 >^^^^^^^^ +2 > ^ +3 > ^ +4 > ^-> +1 > + > + > +2 > a +3 > ; +1 >Emitted(11, 9) Source(15, 9) + SourceIndex(0) +2 >Emitted(11, 10) Source(15, 10) + SourceIndex(0) +3 >Emitted(11, 11) Source(15, 11) + SourceIndex(0) +--- +>>> b; +1->^^^^^^^^ +2 > ^ +3 > ^ +1-> + > +2 > b +3 > ; +1->Emitted(12, 9) Source(16, 9) + SourceIndex(0) +2 >Emitted(12, 10) Source(16, 10) + SourceIndex(0) +3 >Emitted(12, 11) Source(16, 11) + SourceIndex(0) +--- +>>> } +1 >^^^^ +2 > ^ +1 > + > +2 > } +1 >Emitted(13, 5) Source(17, 5) + SourceIndex(0) +2 >Emitted(13, 6) Source(17, 6) + SourceIndex(0) +--- +>>>} +1 >^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> +1 > + >} +1 >Emitted(14, 2) Source(18, 2) + SourceIndex(0) +--- +>>>//# sourceMappingURL=classStaticBlock25.js.map=================================================================== +JsFile: classStaticBlock25.d.ts +mapUrl: classStaticBlock25.d.ts.map +sourceRoot: +sources: classStaticBlock25.ts +=================================================================== +------------------------------------------------------------------- +emittedFile:tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.d.ts +sourceFile:classStaticBlock25.ts +------------------------------------------------------------------- +>>>declare const a = 1; +1 > +2 >^^^^^^^^ +3 > ^^^^^^ +4 > ^ +5 > ^^^^ +6 > ^ +7 > ^-> +1 > +2 > +3 > const +4 > a +5 > = 1 +6 > ; +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 9) Source(1, 1) + SourceIndex(0) +3 >Emitted(1, 15) Source(1, 7) + SourceIndex(0) +4 >Emitted(1, 16) Source(1, 8) + SourceIndex(0) +5 >Emitted(1, 20) Source(1, 12) + SourceIndex(0) +6 >Emitted(1, 21) Source(1, 13) + SourceIndex(0) +--- +>>>declare const b = 2; +1-> +2 >^^^^^^^^ +3 > ^^^^^^ +4 > ^ +5 > ^^^^ +6 > ^ +1-> + > +2 > +3 > const +4 > b +5 > = 2 +6 > ; +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 9) Source(2, 1) + SourceIndex(0) +3 >Emitted(2, 15) Source(2, 7) + SourceIndex(0) +4 >Emitted(2, 16) Source(2, 8) + SourceIndex(0) +5 >Emitted(2, 20) Source(2, 12) + SourceIndex(0) +6 >Emitted(2, 21) Source(2, 13) + SourceIndex(0) +--- +>>>declare class C { +1 > +2 >^^^^^^^^^^^^^^ +3 > ^ +1 > + > + > +2 >class +3 > C +1 >Emitted(3, 1) Source(4, 1) + SourceIndex(0) +2 >Emitted(3, 15) Source(4, 7) + SourceIndex(0) +3 >Emitted(3, 16) Source(4, 8) + SourceIndex(0) +--- +>>>} +1 >^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> +1 > { + > static { + > const a = 11; + > + > a; + > b; + > } + > + > static { + > const a = 11; + > + > a; + > b; + > } + >} +1 >Emitted(4, 2) Source(18, 2) + SourceIndex(0) +--- +>>>//# sourceMappingURL=classStaticBlock25.d.ts.map \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock25(target=es2022).symbols b/tests/baselines/reference/classStaticBlock25(target=es2022).symbols new file mode 100644 index 0000000000000..034fa041ed6d4 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock25(target=es2022).symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.ts === +const a = 1; +>a : Symbol(a, Decl(classStaticBlock25.ts, 0, 5)) + +const b = 2; +>b : Symbol(b, Decl(classStaticBlock25.ts, 1, 5)) + +class C { +>C : Symbol(C, Decl(classStaticBlock25.ts, 1, 12)) + + static { + const a = 11; +>a : Symbol(a, Decl(classStaticBlock25.ts, 5, 13)) + + a; +>a : Symbol(a, Decl(classStaticBlock25.ts, 5, 13)) + + b; +>b : Symbol(b, Decl(classStaticBlock25.ts, 1, 5)) + } + + static { + const a = 11; +>a : Symbol(a, Decl(classStaticBlock25.ts, 12, 13)) + + a; +>a : Symbol(a, Decl(classStaticBlock25.ts, 12, 13)) + + b; +>b : Symbol(b, Decl(classStaticBlock25.ts, 1, 5)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock25(target=es2022).types b/tests/baselines/reference/classStaticBlock25(target=es2022).types new file mode 100644 index 0000000000000..dd78af7dda7e6 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock25(target=es2022).types @@ -0,0 +1,37 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.ts === +const a = 1; +>a : 1 +>1 : 1 + +const b = 2; +>b : 2 +>2 : 2 + +class C { +>C : C + + static { + const a = 11; +>a : 11 +>11 : 11 + + a; +>a : 11 + + b; +>b : 2 + } + + static { + const a = 11; +>a : 11 +>11 : 11 + + a; +>a : 11 + + b; +>b : 2 + } +} + diff --git a/tests/baselines/reference/classStaticBlock25(target=esnext).js b/tests/baselines/reference/classStaticBlock25(target=esnext).js new file mode 100644 index 0000000000000..79864030028c1 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock25(target=esnext).js @@ -0,0 +1,44 @@ +//// [classStaticBlock25.ts] +const a = 1; +const b = 2; + +class C { + static { + const a = 11; + + a; + b; + } + + static { + const a = 11; + + a; + b; + } +} + + +//// [classStaticBlock25.js] +const a = 1; +const b = 2; +class C { + static { + const a = 11; + a; + b; + } + static { + const a = 11; + a; + b; + } +} +//# sourceMappingURL=classStaticBlock25.js.map + +//// [classStaticBlock25.d.ts] +declare const a = 1; +declare const b = 2; +declare class C { +} +//# sourceMappingURL=classStaticBlock25.d.ts.map \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock25(target=esnext).js.map b/tests/baselines/reference/classStaticBlock25(target=esnext).js.map new file mode 100644 index 0000000000000..f3bccac8cb86f --- /dev/null +++ b/tests/baselines/reference/classStaticBlock25(target=esnext).js.map @@ -0,0 +1,7 @@ +//// [classStaticBlock25.js.map] +{"version":3,"file":"classStaticBlock25.js","sourceRoot":"","sources":["classStaticBlock25.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,GAAG,CAAC,CAAC;AACZ,MAAM,CAAC,GAAG,CAAC,CAAC;AAEZ,MAAM,CAAC;IACH;QACI,MAAM,CAAC,GAAG,EAAE,CAAC;QAEb,CAAC,CAAC;QACF,CAAC,CAAC;IACN,CAAC;IAED;QACI,MAAM,CAAC,GAAG,EAAE,CAAC;QAEb,CAAC,CAAC;QACF,CAAC,CAAC;IACN,CAAC;CACJ"} +//// https://sokra.github.io/source-map-visualization#base64,Y29uc3QgYSA9IDE7DQpjb25zdCBiID0gMjsNCmNsYXNzIEMgew0KICAgIHN0YXRpYyB7DQogICAgICAgIGNvbnN0IGEgPSAxMTsNCiAgICAgICAgYTsNCiAgICAgICAgYjsNCiAgICB9DQogICAgc3RhdGljIHsNCiAgICAgICAgY29uc3QgYSA9IDExOw0KICAgICAgICBhOw0KICAgICAgICBiOw0KICAgIH0NCn0NCi8vIyBzb3VyY2VNYXBwaW5nVVJMPWNsYXNzU3RhdGljQmxvY2syNS5qcy5tYXA=,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3NTdGF0aWNCbG9jazI1LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiY2xhc3NTdGF0aWNCbG9jazI1LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNaLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUVaLE1BQU0sQ0FBQztJQUNIO1FBQ0ksTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBRWIsQ0FBQyxDQUFDO1FBQ0YsQ0FBQyxDQUFDO0lBQ04sQ0FBQztJQUVEO1FBQ0ksTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDO1FBRWIsQ0FBQyxDQUFDO1FBQ0YsQ0FBQyxDQUFDO0lBQ04sQ0FBQztDQUNKIn0=,Y29uc3QgYSA9IDE7CmNvbnN0IGIgPSAyOwoKY2xhc3MgQyB7CiAgICBzdGF0aWMgewogICAgICAgIGNvbnN0IGEgPSAxMTsKCiAgICAgICAgYTsKICAgICAgICBiOwogICAgfQoKICAgIHN0YXRpYyB7CiAgICAgICAgY29uc3QgYSA9IDExOwoKICAgICAgICBhOwogICAgICAgIGI7CiAgICB9Cn0K + +//// [classStaticBlock25.d.ts.map] +{"version":3,"file":"classStaticBlock25.d.ts","sourceRoot":"","sources":["classStaticBlock25.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,CAAC,IAAI,CAAC;AACZ,QAAA,MAAM,CAAC,IAAI,CAAC;AAEZ,cAAM,CAAC;CAcN"} +//// https://sokra.github.io/source-map-visualization#base64,ZGVjbGFyZSBjb25zdCBhID0gMTsNCmRlY2xhcmUgY29uc3QgYiA9IDI7DQpkZWNsYXJlIGNsYXNzIEMgew0KfQ0KLy8jIHNvdXJjZU1hcHBpbmdVUkw9Y2xhc3NTdGF0aWNCbG9jazI1LmQudHMubWFw,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3NTdGF0aWNCbG9jazI1LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJjbGFzc1N0YXRpY0Jsb2NrMjUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsUUFBQSxNQUFNLENBQUMsSUFBSSxDQUFDO0FBQ1osUUFBQSxNQUFNLENBQUMsSUFBSSxDQUFDO0FBRVosY0FBTSxDQUFDO0NBY04ifQ==,Y29uc3QgYSA9IDE7CmNvbnN0IGIgPSAyOwoKY2xhc3MgQyB7CiAgICBzdGF0aWMgewogICAgICAgIGNvbnN0IGEgPSAxMTsKCiAgICAgICAgYTsKICAgICAgICBiOwogICAgfQoKICAgIHN0YXRpYyB7CiAgICAgICAgY29uc3QgYSA9IDExOwoKICAgICAgICBhOwogICAgICAgIGI7CiAgICB9Cn0K diff --git a/tests/baselines/reference/classStaticBlock25(target=esnext).sourcemap.txt b/tests/baselines/reference/classStaticBlock25(target=esnext).sourcemap.txt new file mode 100644 index 0000000000000..91f7b7913f116 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock25(target=esnext).sourcemap.txt @@ -0,0 +1,287 @@ +=================================================================== +JsFile: classStaticBlock25.js +mapUrl: classStaticBlock25.js.map +sourceRoot: +sources: classStaticBlock25.ts +=================================================================== +------------------------------------------------------------------- +emittedFile:tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.js +sourceFile:classStaticBlock25.ts +------------------------------------------------------------------- +>>>const a = 1; +1 > +2 >^^^^^^ +3 > ^ +4 > ^^^ +5 > ^ +6 > ^ +7 > ^-> +1 > +2 >const +3 > a +4 > = +5 > 1 +6 > ; +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 7) Source(1, 7) + SourceIndex(0) +3 >Emitted(1, 8) Source(1, 8) + SourceIndex(0) +4 >Emitted(1, 11) Source(1, 11) + SourceIndex(0) +5 >Emitted(1, 12) Source(1, 12) + SourceIndex(0) +6 >Emitted(1, 13) Source(1, 13) + SourceIndex(0) +--- +>>>const b = 2; +1-> +2 >^^^^^^ +3 > ^ +4 > ^^^ +5 > ^ +6 > ^ +1-> + > +2 >const +3 > b +4 > = +5 > 2 +6 > ; +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 7) Source(2, 7) + SourceIndex(0) +3 >Emitted(2, 8) Source(2, 8) + SourceIndex(0) +4 >Emitted(2, 11) Source(2, 11) + SourceIndex(0) +5 >Emitted(2, 12) Source(2, 12) + SourceIndex(0) +6 >Emitted(2, 13) Source(2, 13) + SourceIndex(0) +--- +>>>class C { +1 > +2 >^^^^^^ +3 > ^ +4 > ^^^^^^-> +1 > + > + > +2 >class +3 > C +1 >Emitted(3, 1) Source(4, 1) + SourceIndex(0) +2 >Emitted(3, 7) Source(4, 7) + SourceIndex(0) +3 >Emitted(3, 8) Source(4, 8) + SourceIndex(0) +--- +>>> static { +1->^^^^ +2 > ^^^^^^^^^^^^^^^^^^-> +1-> { + > +1->Emitted(4, 5) Source(5, 5) + SourceIndex(0) +--- +>>> const a = 11; +1->^^^^^^^^ +2 > ^^^^^^ +3 > ^ +4 > ^^^ +5 > ^^ +6 > ^ +1->static { + > +2 > const +3 > a +4 > = +5 > 11 +6 > ; +1->Emitted(5, 9) Source(6, 9) + SourceIndex(0) +2 >Emitted(5, 15) Source(6, 15) + SourceIndex(0) +3 >Emitted(5, 16) Source(6, 16) + SourceIndex(0) +4 >Emitted(5, 19) Source(6, 19) + SourceIndex(0) +5 >Emitted(5, 21) Source(6, 21) + SourceIndex(0) +6 >Emitted(5, 22) Source(6, 22) + SourceIndex(0) +--- +>>> a; +1 >^^^^^^^^ +2 > ^ +3 > ^ +4 > ^-> +1 > + > + > +2 > a +3 > ; +1 >Emitted(6, 9) Source(8, 9) + SourceIndex(0) +2 >Emitted(6, 10) Source(8, 10) + SourceIndex(0) +3 >Emitted(6, 11) Source(8, 11) + SourceIndex(0) +--- +>>> b; +1->^^^^^^^^ +2 > ^ +3 > ^ +1-> + > +2 > b +3 > ; +1->Emitted(7, 9) Source(9, 9) + SourceIndex(0) +2 >Emitted(7, 10) Source(9, 10) + SourceIndex(0) +3 >Emitted(7, 11) Source(9, 11) + SourceIndex(0) +--- +>>> } +1 >^^^^ +2 > ^ +3 > ^^^^^^^^-> +1 > + > +2 > } +1 >Emitted(8, 5) Source(10, 5) + SourceIndex(0) +2 >Emitted(8, 6) Source(10, 6) + SourceIndex(0) +--- +>>> static { +1->^^^^ +2 > ^^^^^^^^^^^^^^^^^^-> +1-> + > + > +1->Emitted(9, 5) Source(12, 5) + SourceIndex(0) +--- +>>> const a = 11; +1->^^^^^^^^ +2 > ^^^^^^ +3 > ^ +4 > ^^^ +5 > ^^ +6 > ^ +1->static { + > +2 > const +3 > a +4 > = +5 > 11 +6 > ; +1->Emitted(10, 9) Source(13, 9) + SourceIndex(0) +2 >Emitted(10, 15) Source(13, 15) + SourceIndex(0) +3 >Emitted(10, 16) Source(13, 16) + SourceIndex(0) +4 >Emitted(10, 19) Source(13, 19) + SourceIndex(0) +5 >Emitted(10, 21) Source(13, 21) + SourceIndex(0) +6 >Emitted(10, 22) Source(13, 22) + SourceIndex(0) +--- +>>> a; +1 >^^^^^^^^ +2 > ^ +3 > ^ +4 > ^-> +1 > + > + > +2 > a +3 > ; +1 >Emitted(11, 9) Source(15, 9) + SourceIndex(0) +2 >Emitted(11, 10) Source(15, 10) + SourceIndex(0) +3 >Emitted(11, 11) Source(15, 11) + SourceIndex(0) +--- +>>> b; +1->^^^^^^^^ +2 > ^ +3 > ^ +1-> + > +2 > b +3 > ; +1->Emitted(12, 9) Source(16, 9) + SourceIndex(0) +2 >Emitted(12, 10) Source(16, 10) + SourceIndex(0) +3 >Emitted(12, 11) Source(16, 11) + SourceIndex(0) +--- +>>> } +1 >^^^^ +2 > ^ +1 > + > +2 > } +1 >Emitted(13, 5) Source(17, 5) + SourceIndex(0) +2 >Emitted(13, 6) Source(17, 6) + SourceIndex(0) +--- +>>>} +1 >^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> +1 > + >} +1 >Emitted(14, 2) Source(18, 2) + SourceIndex(0) +--- +>>>//# sourceMappingURL=classStaticBlock25.js.map=================================================================== +JsFile: classStaticBlock25.d.ts +mapUrl: classStaticBlock25.d.ts.map +sourceRoot: +sources: classStaticBlock25.ts +=================================================================== +------------------------------------------------------------------- +emittedFile:tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.d.ts +sourceFile:classStaticBlock25.ts +------------------------------------------------------------------- +>>>declare const a = 1; +1 > +2 >^^^^^^^^ +3 > ^^^^^^ +4 > ^ +5 > ^^^^ +6 > ^ +7 > ^-> +1 > +2 > +3 > const +4 > a +5 > = 1 +6 > ; +1 >Emitted(1, 1) Source(1, 1) + SourceIndex(0) +2 >Emitted(1, 9) Source(1, 1) + SourceIndex(0) +3 >Emitted(1, 15) Source(1, 7) + SourceIndex(0) +4 >Emitted(1, 16) Source(1, 8) + SourceIndex(0) +5 >Emitted(1, 20) Source(1, 12) + SourceIndex(0) +6 >Emitted(1, 21) Source(1, 13) + SourceIndex(0) +--- +>>>declare const b = 2; +1-> +2 >^^^^^^^^ +3 > ^^^^^^ +4 > ^ +5 > ^^^^ +6 > ^ +1-> + > +2 > +3 > const +4 > b +5 > = 2 +6 > ; +1->Emitted(2, 1) Source(2, 1) + SourceIndex(0) +2 >Emitted(2, 9) Source(2, 1) + SourceIndex(0) +3 >Emitted(2, 15) Source(2, 7) + SourceIndex(0) +4 >Emitted(2, 16) Source(2, 8) + SourceIndex(0) +5 >Emitted(2, 20) Source(2, 12) + SourceIndex(0) +6 >Emitted(2, 21) Source(2, 13) + SourceIndex(0) +--- +>>>declare class C { +1 > +2 >^^^^^^^^^^^^^^ +3 > ^ +1 > + > + > +2 >class +3 > C +1 >Emitted(3, 1) Source(4, 1) + SourceIndex(0) +2 >Emitted(3, 15) Source(4, 7) + SourceIndex(0) +3 >Emitted(3, 16) Source(4, 8) + SourceIndex(0) +--- +>>>} +1 >^ +2 > ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-> +1 > { + > static { + > const a = 11; + > + > a; + > b; + > } + > + > static { + > const a = 11; + > + > a; + > b; + > } + >} +1 >Emitted(4, 2) Source(18, 2) + SourceIndex(0) +--- +>>>//# sourceMappingURL=classStaticBlock25.d.ts.map \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock25(target=esnext).symbols b/tests/baselines/reference/classStaticBlock25(target=esnext).symbols new file mode 100644 index 0000000000000..034fa041ed6d4 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock25(target=esnext).symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.ts === +const a = 1; +>a : Symbol(a, Decl(classStaticBlock25.ts, 0, 5)) + +const b = 2; +>b : Symbol(b, Decl(classStaticBlock25.ts, 1, 5)) + +class C { +>C : Symbol(C, Decl(classStaticBlock25.ts, 1, 12)) + + static { + const a = 11; +>a : Symbol(a, Decl(classStaticBlock25.ts, 5, 13)) + + a; +>a : Symbol(a, Decl(classStaticBlock25.ts, 5, 13)) + + b; +>b : Symbol(b, Decl(classStaticBlock25.ts, 1, 5)) + } + + static { + const a = 11; +>a : Symbol(a, Decl(classStaticBlock25.ts, 12, 13)) + + a; +>a : Symbol(a, Decl(classStaticBlock25.ts, 12, 13)) + + b; +>b : Symbol(b, Decl(classStaticBlock25.ts, 1, 5)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock25(target=esnext).types b/tests/baselines/reference/classStaticBlock25(target=esnext).types new file mode 100644 index 0000000000000..dd78af7dda7e6 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock25(target=esnext).types @@ -0,0 +1,37 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.ts === +const a = 1; +>a : 1 +>1 : 1 + +const b = 2; +>b : 2 +>2 : 2 + +class C { +>C : C + + static { + const a = 11; +>a : 11 +>11 : 11 + + a; +>a : 11 + + b; +>b : 2 + } + + static { + const a = 11; +>a : 11 +>11 : 11 + + a; +>a : 11 + + b; +>b : 2 + } +} + diff --git a/tests/baselines/reference/classStaticBlock26(target=es2022).errors.txt b/tests/baselines/reference/classStaticBlock26(target=es2022).errors.txt new file mode 100644 index 0000000000000..3c5eb52fb8f34 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock26(target=es2022).errors.txt @@ -0,0 +1,86 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(3,9): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(3,14): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(6,9): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(9,13): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(9,18): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(13,14): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(13,19): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(17,18): error TS1005: ':' expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(20,9): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(20,14): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(21,15): error TS1003: Identifier expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(21,15): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(21,20): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(25,21): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(25,26): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(25,28): error TS1005: ';' expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(26,21): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(26,27): error TS1109: Expression expected. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts (18 errors) ==== + class C { + static { + await; // illegal + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + } + static { + await (1); // illegal + ~~~~~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + } + static { + ({ [await]: 1 }); // illegal + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + } + static { + class D { + [await] = 1; // illegal (computed property names are evaluated outside of a class body + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + }; + } + static { + ({ await }); // illegal short-hand property reference + ~ +!!! error TS1005: ':' expected. + } + static { + await: // illegal, 'await' cannot be used as a label + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + break await; // illegal, 'await' cannot be used as a label + ~~~~~ +!!! error TS1003: Identifier expected. + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + } + static { + function f(await) { } + const ff = (await) => { } + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + ~~ +!!! error TS1005: ';' expected. + const fff = await => { } + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~~ +!!! error TS1109: Expression expected. + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock26(target=es2022).js b/tests/baselines/reference/classStaticBlock26(target=es2022).js new file mode 100644 index 0000000000000..ababa6abf24ac --- /dev/null +++ b/tests/baselines/reference/classStaticBlock26(target=es2022).js @@ -0,0 +1,64 @@ +//// [classStaticBlock26.ts] +class C { + static { + await; // illegal + } + static { + await (1); // illegal + } + static { + ({ [await]: 1 }); // illegal + } + static { + class D { + [await] = 1; // illegal (computed property names are evaluated outside of a class body + }; + } + static { + ({ await }); // illegal short-hand property reference + } + static { + await: // illegal, 'await' cannot be used as a label + break await; // illegal, 'await' cannot be used as a label + } + static { + function f(await) { } + const ff = (await) => { } + const fff = await => { } + } +} + + +//// [classStaticBlock26.js] +class C { + static { + await ; // illegal + } + static { + await (1); // illegal + } + static { + ({ [await ]: 1 }); // illegal + } + static { + class D { + [await ] = 1; // illegal (computed property names are evaluated outside of a class body + } + ; + } + static { + ({ await: }); // illegal short-hand property reference + } + static { + await ; + break ; + await ; // illegal, 'await' cannot be used as a label + } + static { + function f(await) { } + const ff = (await ); + { } + const fff = await ; + { } + } +} diff --git a/tests/baselines/reference/classStaticBlock26(target=es2022).symbols b/tests/baselines/reference/classStaticBlock26(target=es2022).symbols new file mode 100644 index 0000000000000..2d3b2717ba213 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock26(target=es2022).symbols @@ -0,0 +1,44 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts === +class C { +>C : Symbol(C, Decl(classStaticBlock26.ts, 0, 0)) + + static { + await; // illegal + } + static { + await (1); // illegal + } + static { + ({ [await]: 1 }); // illegal +>[await] : Symbol([await], Decl(classStaticBlock26.ts, 8, 10)) + } + static { + class D { +>D : Symbol(D, Decl(classStaticBlock26.ts, 10, 12)) + + [await] = 1; // illegal (computed property names are evaluated outside of a class body +>[await] : Symbol(D[await], Decl(classStaticBlock26.ts, 11, 17)) + + }; + } + static { + ({ await }); // illegal short-hand property reference +>await : Symbol(await, Decl(classStaticBlock26.ts, 16, 10)) + } + static { + await: // illegal, 'await' cannot be used as a label + break await; // illegal, 'await' cannot be used as a label + } + static { + function f(await) { } +>f : Symbol(f, Decl(classStaticBlock26.ts, 22, 12)) +>await : Symbol(await, Decl(classStaticBlock26.ts, 23, 19)) + + const ff = (await) => { } +>ff : Symbol(ff, Decl(classStaticBlock26.ts, 24, 13)) + + const fff = await => { } +>fff : Symbol(fff, Decl(classStaticBlock26.ts, 25, 13)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock26(target=es2022).types b/tests/baselines/reference/classStaticBlock26(target=es2022).types new file mode 100644 index 0000000000000..0922330a47533 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock26(target=es2022).types @@ -0,0 +1,71 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts === +class C { +>C : C + + static { + await; // illegal +>await : any +> : any + } + static { + await (1); // illegal +>await (1) : 1 +>(1) : 1 +>1 : 1 + } + static { + ({ [await]: 1 }); // illegal +>({ [await]: 1 }) : { [x: number]: number; } +>{ [await]: 1 } : { [x: number]: number; } +>[await] : number +>await : any +> : any +>1 : 1 + } + static { + class D { +>D : D + + [await] = 1; // illegal (computed property names are evaluated outside of a class body +>[await] : number +>await : any +> : any +>1 : 1 + + }; + } + static { + ({ await }); // illegal short-hand property reference +>({ await }) : { await: any; } +>{ await } : { await: any; } +>await : any +> : any + } + static { + await: // illegal, 'await' cannot be used as a label +>await : any +> : any + + break await; // illegal, 'await' cannot be used as a label +> : any +>await : any +> : any + } + static { + function f(await) { } +>f : (await: any) => void +>await : any + + const ff = (await) => { } +>ff : any +>(await) : any +>await : any +> : any + + const fff = await => { } +>fff : any +>await : any +> : any + } +} + diff --git a/tests/baselines/reference/classStaticBlock26(target=esnext).errors.txt b/tests/baselines/reference/classStaticBlock26(target=esnext).errors.txt new file mode 100644 index 0000000000000..3c5eb52fb8f34 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock26(target=esnext).errors.txt @@ -0,0 +1,86 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(3,9): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(3,14): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(6,9): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(9,13): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(9,18): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(13,14): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(13,19): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(17,18): error TS1005: ':' expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(20,9): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(20,14): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(21,15): error TS1003: Identifier expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(21,15): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(21,20): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(25,21): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(25,26): error TS1109: Expression expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(25,28): error TS1005: ';' expected. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(26,21): error TS18037: Await expression cannot be used inside a class static block. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts(26,27): error TS1109: Expression expected. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts (18 errors) ==== + class C { + static { + await; // illegal + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + } + static { + await (1); // illegal + ~~~~~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + } + static { + ({ [await]: 1 }); // illegal + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + } + static { + class D { + [await] = 1; // illegal (computed property names are evaluated outside of a class body + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + }; + } + static { + ({ await }); // illegal short-hand property reference + ~ +!!! error TS1005: ':' expected. + } + static { + await: // illegal, 'await' cannot be used as a label + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + break await; // illegal, 'await' cannot be used as a label + ~~~~~ +!!! error TS1003: Identifier expected. + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + } + static { + function f(await) { } + const ff = (await) => { } + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~ +!!! error TS1109: Expression expected. + ~~ +!!! error TS1005: ';' expected. + const fff = await => { } + ~~~~~ +!!! error TS18037: Await expression cannot be used inside a class static block. + ~~ +!!! error TS1109: Expression expected. + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock26(target=esnext).js b/tests/baselines/reference/classStaticBlock26(target=esnext).js new file mode 100644 index 0000000000000..ababa6abf24ac --- /dev/null +++ b/tests/baselines/reference/classStaticBlock26(target=esnext).js @@ -0,0 +1,64 @@ +//// [classStaticBlock26.ts] +class C { + static { + await; // illegal + } + static { + await (1); // illegal + } + static { + ({ [await]: 1 }); // illegal + } + static { + class D { + [await] = 1; // illegal (computed property names are evaluated outside of a class body + }; + } + static { + ({ await }); // illegal short-hand property reference + } + static { + await: // illegal, 'await' cannot be used as a label + break await; // illegal, 'await' cannot be used as a label + } + static { + function f(await) { } + const ff = (await) => { } + const fff = await => { } + } +} + + +//// [classStaticBlock26.js] +class C { + static { + await ; // illegal + } + static { + await (1); // illegal + } + static { + ({ [await ]: 1 }); // illegal + } + static { + class D { + [await ] = 1; // illegal (computed property names are evaluated outside of a class body + } + ; + } + static { + ({ await: }); // illegal short-hand property reference + } + static { + await ; + break ; + await ; // illegal, 'await' cannot be used as a label + } + static { + function f(await) { } + const ff = (await ); + { } + const fff = await ; + { } + } +} diff --git a/tests/baselines/reference/classStaticBlock26(target=esnext).symbols b/tests/baselines/reference/classStaticBlock26(target=esnext).symbols new file mode 100644 index 0000000000000..2d3b2717ba213 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock26(target=esnext).symbols @@ -0,0 +1,44 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts === +class C { +>C : Symbol(C, Decl(classStaticBlock26.ts, 0, 0)) + + static { + await; // illegal + } + static { + await (1); // illegal + } + static { + ({ [await]: 1 }); // illegal +>[await] : Symbol([await], Decl(classStaticBlock26.ts, 8, 10)) + } + static { + class D { +>D : Symbol(D, Decl(classStaticBlock26.ts, 10, 12)) + + [await] = 1; // illegal (computed property names are evaluated outside of a class body +>[await] : Symbol(D[await], Decl(classStaticBlock26.ts, 11, 17)) + + }; + } + static { + ({ await }); // illegal short-hand property reference +>await : Symbol(await, Decl(classStaticBlock26.ts, 16, 10)) + } + static { + await: // illegal, 'await' cannot be used as a label + break await; // illegal, 'await' cannot be used as a label + } + static { + function f(await) { } +>f : Symbol(f, Decl(classStaticBlock26.ts, 22, 12)) +>await : Symbol(await, Decl(classStaticBlock26.ts, 23, 19)) + + const ff = (await) => { } +>ff : Symbol(ff, Decl(classStaticBlock26.ts, 24, 13)) + + const fff = await => { } +>fff : Symbol(fff, Decl(classStaticBlock26.ts, 25, 13)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock26(target=esnext).types b/tests/baselines/reference/classStaticBlock26(target=esnext).types new file mode 100644 index 0000000000000..0922330a47533 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock26(target=esnext).types @@ -0,0 +1,71 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts === +class C { +>C : C + + static { + await; // illegal +>await : any +> : any + } + static { + await (1); // illegal +>await (1) : 1 +>(1) : 1 +>1 : 1 + } + static { + ({ [await]: 1 }); // illegal +>({ [await]: 1 }) : { [x: number]: number; } +>{ [await]: 1 } : { [x: number]: number; } +>[await] : number +>await : any +> : any +>1 : 1 + } + static { + class D { +>D : D + + [await] = 1; // illegal (computed property names are evaluated outside of a class body +>[await] : number +>await : any +> : any +>1 : 1 + + }; + } + static { + ({ await }); // illegal short-hand property reference +>({ await }) : { await: any; } +>{ await } : { await: any; } +>await : any +> : any + } + static { + await: // illegal, 'await' cannot be used as a label +>await : any +> : any + + break await; // illegal, 'await' cannot be used as a label +> : any +>await : any +> : any + } + static { + function f(await) { } +>f : (await: any) => void +>await : any + + const ff = (await) => { } +>ff : any +>(await) : any +>await : any +> : any + + const fff = await => { } +>fff : any +>await : any +> : any + } +} + diff --git a/tests/baselines/reference/classStaticBlock3(target=es2022).errors.txt b/tests/baselines/reference/classStaticBlock3(target=es2022).errors.txt new file mode 100644 index 0000000000000..bf01354e1405f --- /dev/null +++ b/tests/baselines/reference/classStaticBlock3(target=es2022).errors.txt @@ -0,0 +1,33 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts(7,29): error TS2729: Property 'f2' is used before its initialization. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts(7,35): error TS2729: Property 'f3' is used before its initialization. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts(13,35): error TS2729: Property 'f3' is used before its initialization. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts (3 errors) ==== + const a = 1; + + class C { + static f1 = 1; + + static { + console.log(C.f1, C.f2, C.f3) + ~~ +!!! error TS2729: Property 'f2' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts:10:12: 'f2' is declared here. + ~~ +!!! error TS2729: Property 'f3' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts:16:12: 'f3' is declared here. + } + + static f2 = 2; + + static { + console.log(C.f1, C.f2, C.f3) + ~~ +!!! error TS2729: Property 'f3' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts:16:12: 'f3' is declared here. + } + + static f3 = 3; + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock3(target=es2022).js b/tests/baselines/reference/classStaticBlock3(target=es2022).js new file mode 100644 index 0000000000000..99fe38cf28e28 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock3(target=es2022).js @@ -0,0 +1,33 @@ +//// [classStaticBlock3.ts] +const a = 1; + +class C { + static f1 = 1; + + static { + console.log(C.f1, C.f2, C.f3) + } + + static f2 = 2; + + static { + console.log(C.f1, C.f2, C.f3) + } + + static f3 = 3; +} + + +//// [classStaticBlock3.js] +const a = 1; +class C { + static f1 = 1; + static { + console.log(C.f1, C.f2, C.f3); + } + static f2 = 2; + static { + console.log(C.f1, C.f2, C.f3); + } + static f3 = 3; +} diff --git a/tests/baselines/reference/classStaticBlock3(target=es2022).symbols b/tests/baselines/reference/classStaticBlock3(target=es2022).symbols new file mode 100644 index 0000000000000..758fa0790609a --- /dev/null +++ b/tests/baselines/reference/classStaticBlock3(target=es2022).symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts === +const a = 1; +>a : Symbol(a, Decl(classStaticBlock3.ts, 0, 5)) + +class C { +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) + + static f1 = 1; +>f1 : Symbol(C.f1, Decl(classStaticBlock3.ts, 2, 9)) + + static { + console.log(C.f1, C.f2, C.f3) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>C.f1 : Symbol(C.f1, Decl(classStaticBlock3.ts, 2, 9)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f1 : Symbol(C.f1, Decl(classStaticBlock3.ts, 2, 9)) +>C.f2 : Symbol(C.f2, Decl(classStaticBlock3.ts, 7, 5)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f2 : Symbol(C.f2, Decl(classStaticBlock3.ts, 7, 5)) +>C.f3 : Symbol(C.f3, Decl(classStaticBlock3.ts, 13, 5)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f3 : Symbol(C.f3, Decl(classStaticBlock3.ts, 13, 5)) + } + + static f2 = 2; +>f2 : Symbol(C.f2, Decl(classStaticBlock3.ts, 7, 5)) + + static { + console.log(C.f1, C.f2, C.f3) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>C.f1 : Symbol(C.f1, Decl(classStaticBlock3.ts, 2, 9)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f1 : Symbol(C.f1, Decl(classStaticBlock3.ts, 2, 9)) +>C.f2 : Symbol(C.f2, Decl(classStaticBlock3.ts, 7, 5)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f2 : Symbol(C.f2, Decl(classStaticBlock3.ts, 7, 5)) +>C.f3 : Symbol(C.f3, Decl(classStaticBlock3.ts, 13, 5)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f3 : Symbol(C.f3, Decl(classStaticBlock3.ts, 13, 5)) + } + + static f3 = 3; +>f3 : Symbol(C.f3, Decl(classStaticBlock3.ts, 13, 5)) +} + diff --git a/tests/baselines/reference/classStaticBlock3(target=es2022).types b/tests/baselines/reference/classStaticBlock3(target=es2022).types new file mode 100644 index 0000000000000..d5705a72e8775 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock3(target=es2022).types @@ -0,0 +1,55 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts === +const a = 1; +>a : 1 +>1 : 1 + +class C { +>C : C + + static f1 = 1; +>f1 : number +>1 : 1 + + static { + console.log(C.f1, C.f2, C.f3) +>console.log(C.f1, C.f2, C.f3) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>C.f1 : number +>C : typeof C +>f1 : number +>C.f2 : number +>C : typeof C +>f2 : number +>C.f3 : number +>C : typeof C +>f3 : number + } + + static f2 = 2; +>f2 : number +>2 : 2 + + static { + console.log(C.f1, C.f2, C.f3) +>console.log(C.f1, C.f2, C.f3) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>C.f1 : number +>C : typeof C +>f1 : number +>C.f2 : number +>C : typeof C +>f2 : number +>C.f3 : number +>C : typeof C +>f3 : number + } + + static f3 = 3; +>f3 : number +>3 : 3 +} + diff --git a/tests/baselines/reference/classStaticBlock3(target=esnext).errors.txt b/tests/baselines/reference/classStaticBlock3(target=esnext).errors.txt new file mode 100644 index 0000000000000..bf01354e1405f --- /dev/null +++ b/tests/baselines/reference/classStaticBlock3(target=esnext).errors.txt @@ -0,0 +1,33 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts(7,29): error TS2729: Property 'f2' is used before its initialization. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts(7,35): error TS2729: Property 'f3' is used before its initialization. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts(13,35): error TS2729: Property 'f3' is used before its initialization. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts (3 errors) ==== + const a = 1; + + class C { + static f1 = 1; + + static { + console.log(C.f1, C.f2, C.f3) + ~~ +!!! error TS2729: Property 'f2' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts:10:12: 'f2' is declared here. + ~~ +!!! error TS2729: Property 'f3' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts:16:12: 'f3' is declared here. + } + + static f2 = 2; + + static { + console.log(C.f1, C.f2, C.f3) + ~~ +!!! error TS2729: Property 'f3' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts:16:12: 'f3' is declared here. + } + + static f3 = 3; + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock3(target=esnext).js b/tests/baselines/reference/classStaticBlock3(target=esnext).js new file mode 100644 index 0000000000000..99fe38cf28e28 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock3(target=esnext).js @@ -0,0 +1,33 @@ +//// [classStaticBlock3.ts] +const a = 1; + +class C { + static f1 = 1; + + static { + console.log(C.f1, C.f2, C.f3) + } + + static f2 = 2; + + static { + console.log(C.f1, C.f2, C.f3) + } + + static f3 = 3; +} + + +//// [classStaticBlock3.js] +const a = 1; +class C { + static f1 = 1; + static { + console.log(C.f1, C.f2, C.f3); + } + static f2 = 2; + static { + console.log(C.f1, C.f2, C.f3); + } + static f3 = 3; +} diff --git a/tests/baselines/reference/classStaticBlock3(target=esnext).symbols b/tests/baselines/reference/classStaticBlock3(target=esnext).symbols new file mode 100644 index 0000000000000..758fa0790609a --- /dev/null +++ b/tests/baselines/reference/classStaticBlock3(target=esnext).symbols @@ -0,0 +1,49 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts === +const a = 1; +>a : Symbol(a, Decl(classStaticBlock3.ts, 0, 5)) + +class C { +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) + + static f1 = 1; +>f1 : Symbol(C.f1, Decl(classStaticBlock3.ts, 2, 9)) + + static { + console.log(C.f1, C.f2, C.f3) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>C.f1 : Symbol(C.f1, Decl(classStaticBlock3.ts, 2, 9)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f1 : Symbol(C.f1, Decl(classStaticBlock3.ts, 2, 9)) +>C.f2 : Symbol(C.f2, Decl(classStaticBlock3.ts, 7, 5)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f2 : Symbol(C.f2, Decl(classStaticBlock3.ts, 7, 5)) +>C.f3 : Symbol(C.f3, Decl(classStaticBlock3.ts, 13, 5)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f3 : Symbol(C.f3, Decl(classStaticBlock3.ts, 13, 5)) + } + + static f2 = 2; +>f2 : Symbol(C.f2, Decl(classStaticBlock3.ts, 7, 5)) + + static { + console.log(C.f1, C.f2, C.f3) +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>C.f1 : Symbol(C.f1, Decl(classStaticBlock3.ts, 2, 9)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f1 : Symbol(C.f1, Decl(classStaticBlock3.ts, 2, 9)) +>C.f2 : Symbol(C.f2, Decl(classStaticBlock3.ts, 7, 5)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f2 : Symbol(C.f2, Decl(classStaticBlock3.ts, 7, 5)) +>C.f3 : Symbol(C.f3, Decl(classStaticBlock3.ts, 13, 5)) +>C : Symbol(C, Decl(classStaticBlock3.ts, 0, 12)) +>f3 : Symbol(C.f3, Decl(classStaticBlock3.ts, 13, 5)) + } + + static f3 = 3; +>f3 : Symbol(C.f3, Decl(classStaticBlock3.ts, 13, 5)) +} + diff --git a/tests/baselines/reference/classStaticBlock3(target=esnext).types b/tests/baselines/reference/classStaticBlock3(target=esnext).types new file mode 100644 index 0000000000000..d5705a72e8775 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock3(target=esnext).types @@ -0,0 +1,55 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts === +const a = 1; +>a : 1 +>1 : 1 + +class C { +>C : C + + static f1 = 1; +>f1 : number +>1 : 1 + + static { + console.log(C.f1, C.f2, C.f3) +>console.log(C.f1, C.f2, C.f3) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>C.f1 : number +>C : typeof C +>f1 : number +>C.f2 : number +>C : typeof C +>f2 : number +>C.f3 : number +>C : typeof C +>f3 : number + } + + static f2 = 2; +>f2 : number +>2 : 2 + + static { + console.log(C.f1, C.f2, C.f3) +>console.log(C.f1, C.f2, C.f3) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>C.f1 : number +>C : typeof C +>f1 : number +>C.f2 : number +>C : typeof C +>f2 : number +>C.f3 : number +>C : typeof C +>f3 : number + } + + static f3 = 3; +>f3 : number +>3 : 3 +} + diff --git a/tests/baselines/reference/classStaticBlock4(target=es2022).errors.txt b/tests/baselines/reference/classStaticBlock4(target=es2022).errors.txt new file mode 100644 index 0000000000000..d4ec1db72f646 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock4(target=es2022).errors.txt @@ -0,0 +1,26 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts(8,14): error TS2729: Property 's2' is used before its initialization. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts(9,11): error TS2729: Property 's2' is used before its initialization. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts (2 errors) ==== + class C { + static s1 = 1; + + static { + this.s1; + C.s1; + + this.s2; + ~~ +!!! error TS2729: Property 's2' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts:12:12: 's2' is declared here. + C.s2; + ~~ +!!! error TS2729: Property 's2' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts:12:12: 's2' is declared here. + } + + static s2 = 2; + static ss2 = this.s1; + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock4(target=es2022).js b/tests/baselines/reference/classStaticBlock4(target=es2022).js new file mode 100644 index 0000000000000..b8821bc0f36c4 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock4(target=es2022).js @@ -0,0 +1,29 @@ +//// [classStaticBlock4.ts] +class C { + static s1 = 1; + + static { + this.s1; + C.s1; + + this.s2; + C.s2; + } + + static s2 = 2; + static ss2 = this.s1; +} + + +//// [classStaticBlock4.js] +class C { + static s1 = 1; + static { + this.s1; + C.s1; + this.s2; + C.s2; + } + static s2 = 2; + static ss2 = this.s1; +} diff --git a/tests/baselines/reference/classStaticBlock4(target=es2022).symbols b/tests/baselines/reference/classStaticBlock4(target=es2022).symbols new file mode 100644 index 0000000000000..fd412244fbe0e --- /dev/null +++ b/tests/baselines/reference/classStaticBlock4(target=es2022).symbols @@ -0,0 +1,39 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts === +class C { +>C : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) + + static s1 = 1; +>s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) + + static { + this.s1; +>this.s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) +>this : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) +>s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) + + C.s1; +>C.s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) +>C : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) +>s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) + + this.s2; +>this.s2 : Symbol(C.s2, Decl(classStaticBlock4.ts, 9, 5)) +>this : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) +>s2 : Symbol(C.s2, Decl(classStaticBlock4.ts, 9, 5)) + + C.s2; +>C.s2 : Symbol(C.s2, Decl(classStaticBlock4.ts, 9, 5)) +>C : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) +>s2 : Symbol(C.s2, Decl(classStaticBlock4.ts, 9, 5)) + } + + static s2 = 2; +>s2 : Symbol(C.s2, Decl(classStaticBlock4.ts, 9, 5)) + + static ss2 = this.s1; +>ss2 : Symbol(C.ss2, Decl(classStaticBlock4.ts, 11, 18)) +>this.s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) +>this : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) +>s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) +} + diff --git a/tests/baselines/reference/classStaticBlock4(target=es2022).types b/tests/baselines/reference/classStaticBlock4(target=es2022).types new file mode 100644 index 0000000000000..db068a795397c --- /dev/null +++ b/tests/baselines/reference/classStaticBlock4(target=es2022).types @@ -0,0 +1,41 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts === +class C { +>C : C + + static s1 = 1; +>s1 : number +>1 : 1 + + static { + this.s1; +>this.s1 : number +>this : typeof C +>s1 : number + + C.s1; +>C.s1 : number +>C : typeof C +>s1 : number + + this.s2; +>this.s2 : number +>this : typeof C +>s2 : number + + C.s2; +>C.s2 : number +>C : typeof C +>s2 : number + } + + static s2 = 2; +>s2 : number +>2 : 2 + + static ss2 = this.s1; +>ss2 : number +>this.s1 : number +>this : typeof C +>s1 : number +} + diff --git a/tests/baselines/reference/classStaticBlock4(target=esnext).errors.txt b/tests/baselines/reference/classStaticBlock4(target=esnext).errors.txt new file mode 100644 index 0000000000000..d4ec1db72f646 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock4(target=esnext).errors.txt @@ -0,0 +1,26 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts(8,14): error TS2729: Property 's2' is used before its initialization. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts(9,11): error TS2729: Property 's2' is used before its initialization. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts (2 errors) ==== + class C { + static s1 = 1; + + static { + this.s1; + C.s1; + + this.s2; + ~~ +!!! error TS2729: Property 's2' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts:12:12: 's2' is declared here. + C.s2; + ~~ +!!! error TS2729: Property 's2' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts:12:12: 's2' is declared here. + } + + static s2 = 2; + static ss2 = this.s1; + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock4(target=esnext).js b/tests/baselines/reference/classStaticBlock4(target=esnext).js new file mode 100644 index 0000000000000..b8821bc0f36c4 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock4(target=esnext).js @@ -0,0 +1,29 @@ +//// [classStaticBlock4.ts] +class C { + static s1 = 1; + + static { + this.s1; + C.s1; + + this.s2; + C.s2; + } + + static s2 = 2; + static ss2 = this.s1; +} + + +//// [classStaticBlock4.js] +class C { + static s1 = 1; + static { + this.s1; + C.s1; + this.s2; + C.s2; + } + static s2 = 2; + static ss2 = this.s1; +} diff --git a/tests/baselines/reference/classStaticBlock4(target=esnext).symbols b/tests/baselines/reference/classStaticBlock4(target=esnext).symbols new file mode 100644 index 0000000000000..fd412244fbe0e --- /dev/null +++ b/tests/baselines/reference/classStaticBlock4(target=esnext).symbols @@ -0,0 +1,39 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts === +class C { +>C : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) + + static s1 = 1; +>s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) + + static { + this.s1; +>this.s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) +>this : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) +>s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) + + C.s1; +>C.s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) +>C : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) +>s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) + + this.s2; +>this.s2 : Symbol(C.s2, Decl(classStaticBlock4.ts, 9, 5)) +>this : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) +>s2 : Symbol(C.s2, Decl(classStaticBlock4.ts, 9, 5)) + + C.s2; +>C.s2 : Symbol(C.s2, Decl(classStaticBlock4.ts, 9, 5)) +>C : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) +>s2 : Symbol(C.s2, Decl(classStaticBlock4.ts, 9, 5)) + } + + static s2 = 2; +>s2 : Symbol(C.s2, Decl(classStaticBlock4.ts, 9, 5)) + + static ss2 = this.s1; +>ss2 : Symbol(C.ss2, Decl(classStaticBlock4.ts, 11, 18)) +>this.s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) +>this : Symbol(C, Decl(classStaticBlock4.ts, 0, 0)) +>s1 : Symbol(C.s1, Decl(classStaticBlock4.ts, 0, 9)) +} + diff --git a/tests/baselines/reference/classStaticBlock4(target=esnext).types b/tests/baselines/reference/classStaticBlock4(target=esnext).types new file mode 100644 index 0000000000000..db068a795397c --- /dev/null +++ b/tests/baselines/reference/classStaticBlock4(target=esnext).types @@ -0,0 +1,41 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts === +class C { +>C : C + + static s1 = 1; +>s1 : number +>1 : 1 + + static { + this.s1; +>this.s1 : number +>this : typeof C +>s1 : number + + C.s1; +>C.s1 : number +>C : typeof C +>s1 : number + + this.s2; +>this.s2 : number +>this : typeof C +>s2 : number + + C.s2; +>C.s2 : number +>C : typeof C +>s2 : number + } + + static s2 = 2; +>s2 : number +>2 : 2 + + static ss2 = this.s1; +>ss2 : number +>this.s1 : number +>this : typeof C +>s1 : number +} + diff --git a/tests/baselines/reference/classStaticBlock5(target=es2022).js b/tests/baselines/reference/classStaticBlock5(target=es2022).js new file mode 100644 index 0000000000000..84fece2b40219 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock5(target=es2022).js @@ -0,0 +1,32 @@ +//// [classStaticBlock5.ts] +class B { + static a = 1; + static b = 2; +} + +class C extends B { + static b = 3; + static c = super.a + + static { + this.b; + super.b; + super.a; + } +} + + +//// [classStaticBlock5.js] +class B { + static a = 1; + static b = 2; +} +class C extends B { + static b = 3; + static c = super.a; + static { + this.b; + super.b; + super.a; + } +} diff --git a/tests/baselines/reference/classStaticBlock5(target=es2022).symbols b/tests/baselines/reference/classStaticBlock5(target=es2022).symbols new file mode 100644 index 0000000000000..4559a1eaaf287 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock5(target=es2022).symbols @@ -0,0 +1,42 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock5.ts === +class B { +>B : Symbol(B, Decl(classStaticBlock5.ts, 0, 0)) + + static a = 1; +>a : Symbol(B.a, Decl(classStaticBlock5.ts, 0, 9)) + + static b = 2; +>b : Symbol(B.b, Decl(classStaticBlock5.ts, 1, 17)) +} + +class C extends B { +>C : Symbol(C, Decl(classStaticBlock5.ts, 3, 1)) +>B : Symbol(B, Decl(classStaticBlock5.ts, 0, 0)) + + static b = 3; +>b : Symbol(C.b, Decl(classStaticBlock5.ts, 5, 19)) + + static c = super.a +>c : Symbol(C.c, Decl(classStaticBlock5.ts, 6, 17)) +>super.a : Symbol(B.a, Decl(classStaticBlock5.ts, 0, 9)) +>super : Symbol(B, Decl(classStaticBlock5.ts, 0, 0)) +>a : Symbol(B.a, Decl(classStaticBlock5.ts, 0, 9)) + + static { + this.b; +>this.b : Symbol(C.b, Decl(classStaticBlock5.ts, 5, 19)) +>this : Symbol(C, Decl(classStaticBlock5.ts, 3, 1)) +>b : Symbol(C.b, Decl(classStaticBlock5.ts, 5, 19)) + + super.b; +>super.b : Symbol(B.b, Decl(classStaticBlock5.ts, 1, 17)) +>super : Symbol(B, Decl(classStaticBlock5.ts, 0, 0)) +>b : Symbol(B.b, Decl(classStaticBlock5.ts, 1, 17)) + + super.a; +>super.a : Symbol(B.a, Decl(classStaticBlock5.ts, 0, 9)) +>super : Symbol(B, Decl(classStaticBlock5.ts, 0, 0)) +>a : Symbol(B.a, Decl(classStaticBlock5.ts, 0, 9)) + } +} + diff --git a/tests/baselines/reference/classStaticBlock5(target=es2022).types b/tests/baselines/reference/classStaticBlock5(target=es2022).types new file mode 100644 index 0000000000000..8aebace4d70e3 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock5(target=es2022).types @@ -0,0 +1,45 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock5.ts === +class B { +>B : B + + static a = 1; +>a : number +>1 : 1 + + static b = 2; +>b : number +>2 : 2 +} + +class C extends B { +>C : C +>B : B + + static b = 3; +>b : number +>3 : 3 + + static c = super.a +>c : number +>super.a : number +>super : typeof B +>a : number + + static { + this.b; +>this.b : number +>this : typeof C +>b : number + + super.b; +>super.b : number +>super : typeof B +>b : number + + super.a; +>super.a : number +>super : typeof B +>a : number + } +} + diff --git a/tests/baselines/reference/classStaticBlock9(target=es2022).errors.txt b/tests/baselines/reference/classStaticBlock9(target=es2022).errors.txt new file mode 100644 index 0000000000000..4e8572da31914 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock9(target=es2022).errors.txt @@ -0,0 +1,19 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts(2,20): error TS2729: Property 'foo' is used before its initialization. +tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts(4,11): error TS2729: Property 'foo' is used before its initialization. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts (2 errors) ==== + class A { + static bar = A.foo + 1 + ~~~ +!!! error TS2729: Property 'foo' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts:6:12: 'foo' is declared here. + static { + A.foo + 2; + ~~~ +!!! error TS2729: Property 'foo' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts:6:12: 'foo' is declared here. + } + static foo = 1; + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlock9(target=es2022).js b/tests/baselines/reference/classStaticBlock9(target=es2022).js new file mode 100644 index 0000000000000..de762275b1eec --- /dev/null +++ b/tests/baselines/reference/classStaticBlock9(target=es2022).js @@ -0,0 +1,18 @@ +//// [classStaticBlock9.ts] +class A { + static bar = A.foo + 1 + static { + A.foo + 2; + } + static foo = 1; +} + + +//// [classStaticBlock9.js] +class A { + static bar = A.foo + 1; + static { + A.foo + 2; + } + static foo = 1; +} diff --git a/tests/baselines/reference/classStaticBlock9(target=es2022).symbols b/tests/baselines/reference/classStaticBlock9(target=es2022).symbols new file mode 100644 index 0000000000000..2cb44695c8328 --- /dev/null +++ b/tests/baselines/reference/classStaticBlock9(target=es2022).symbols @@ -0,0 +1,20 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts === +class A { +>A : Symbol(A, Decl(classStaticBlock9.ts, 0, 0)) + + static bar = A.foo + 1 +>bar : Symbol(A.bar, Decl(classStaticBlock9.ts, 0, 9)) +>A.foo : Symbol(A.foo, Decl(classStaticBlock9.ts, 4, 5)) +>A : Symbol(A, Decl(classStaticBlock9.ts, 0, 0)) +>foo : Symbol(A.foo, Decl(classStaticBlock9.ts, 4, 5)) + + static { + A.foo + 2; +>A.foo : Symbol(A.foo, Decl(classStaticBlock9.ts, 4, 5)) +>A : Symbol(A, Decl(classStaticBlock9.ts, 0, 0)) +>foo : Symbol(A.foo, Decl(classStaticBlock9.ts, 4, 5)) + } + static foo = 1; +>foo : Symbol(A.foo, Decl(classStaticBlock9.ts, 4, 5)) +} + diff --git a/tests/baselines/reference/classStaticBlock9(target=es2022).types b/tests/baselines/reference/classStaticBlock9(target=es2022).types new file mode 100644 index 0000000000000..9ac192ac54bed --- /dev/null +++ b/tests/baselines/reference/classStaticBlock9(target=es2022).types @@ -0,0 +1,25 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts === +class A { +>A : A + + static bar = A.foo + 1 +>bar : number +>A.foo + 1 : number +>A.foo : number +>A : typeof A +>foo : number +>1 : 1 + + static { + A.foo + 2; +>A.foo + 2 : number +>A.foo : number +>A : typeof A +>foo : number +>2 : 2 + } + static foo = 1; +>foo : number +>1 : 1 +} + diff --git a/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=es2022).symbols b/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=es2022).symbols new file mode 100644 index 0000000000000..991c2c6e6bfaa --- /dev/null +++ b/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=es2022).symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef1.ts === +class C { +>C : Symbol(C, Decl(classStaticBlockUseBeforeDef1.ts, 0, 0)) + + static x; +>x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef1.ts, 0, 9)) + + static { + this.x = 1; +>this.x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef1.ts, 0, 9)) +>this : Symbol(C, Decl(classStaticBlockUseBeforeDef1.ts, 0, 0)) +>x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef1.ts, 0, 9)) + } + static y = this.x; +>y : Symbol(C.y, Decl(classStaticBlockUseBeforeDef1.ts, 4, 5)) +>this.x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef1.ts, 0, 9)) +>this : Symbol(C, Decl(classStaticBlockUseBeforeDef1.ts, 0, 0)) +>x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef1.ts, 0, 9)) + + static z; +>z : Symbol(C.z, Decl(classStaticBlockUseBeforeDef1.ts, 5, 22)) + + static { + this.z = this.y; +>this.z : Symbol(C.z, Decl(classStaticBlockUseBeforeDef1.ts, 5, 22)) +>this : Symbol(C, Decl(classStaticBlockUseBeforeDef1.ts, 0, 0)) +>z : Symbol(C.z, Decl(classStaticBlockUseBeforeDef1.ts, 5, 22)) +>this.y : Symbol(C.y, Decl(classStaticBlockUseBeforeDef1.ts, 4, 5)) +>this : Symbol(C, Decl(classStaticBlockUseBeforeDef1.ts, 0, 0)) +>y : Symbol(C.y, Decl(classStaticBlockUseBeforeDef1.ts, 4, 5)) + } +} + diff --git a/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=es2022).types b/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=es2022).types new file mode 100644 index 0000000000000..3d94fcee3940e --- /dev/null +++ b/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=es2022).types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef1.ts === +class C { +>C : C + + static x; +>x : number + + static { + this.x = 1; +>this.x = 1 : 1 +>this.x : number +>this : typeof C +>x : number +>1 : 1 + } + static y = this.x; +>y : number +>this.x : number +>this : typeof C +>x : number + + static z; +>z : number + + static { + this.z = this.y; +>this.z = this.y : number +>this.z : number +>this : typeof C +>z : number +>this.y : number +>this : typeof C +>y : number + } +} + diff --git a/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=esnext).symbols b/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=esnext).symbols new file mode 100644 index 0000000000000..991c2c6e6bfaa --- /dev/null +++ b/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=esnext).symbols @@ -0,0 +1,33 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef1.ts === +class C { +>C : Symbol(C, Decl(classStaticBlockUseBeforeDef1.ts, 0, 0)) + + static x; +>x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef1.ts, 0, 9)) + + static { + this.x = 1; +>this.x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef1.ts, 0, 9)) +>this : Symbol(C, Decl(classStaticBlockUseBeforeDef1.ts, 0, 0)) +>x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef1.ts, 0, 9)) + } + static y = this.x; +>y : Symbol(C.y, Decl(classStaticBlockUseBeforeDef1.ts, 4, 5)) +>this.x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef1.ts, 0, 9)) +>this : Symbol(C, Decl(classStaticBlockUseBeforeDef1.ts, 0, 0)) +>x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef1.ts, 0, 9)) + + static z; +>z : Symbol(C.z, Decl(classStaticBlockUseBeforeDef1.ts, 5, 22)) + + static { + this.z = this.y; +>this.z : Symbol(C.z, Decl(classStaticBlockUseBeforeDef1.ts, 5, 22)) +>this : Symbol(C, Decl(classStaticBlockUseBeforeDef1.ts, 0, 0)) +>z : Symbol(C.z, Decl(classStaticBlockUseBeforeDef1.ts, 5, 22)) +>this.y : Symbol(C.y, Decl(classStaticBlockUseBeforeDef1.ts, 4, 5)) +>this : Symbol(C, Decl(classStaticBlockUseBeforeDef1.ts, 0, 0)) +>y : Symbol(C.y, Decl(classStaticBlockUseBeforeDef1.ts, 4, 5)) + } +} + diff --git a/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=esnext).types b/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=esnext).types new file mode 100644 index 0000000000000..3d94fcee3940e --- /dev/null +++ b/tests/baselines/reference/classStaticBlockUseBeforeDef1(target=esnext).types @@ -0,0 +1,36 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef1.ts === +class C { +>C : C + + static x; +>x : number + + static { + this.x = 1; +>this.x = 1 : 1 +>this.x : number +>this : typeof C +>x : number +>1 : 1 + } + static y = this.x; +>y : number +>this.x : number +>this : typeof C +>x : number + + static z; +>z : number + + static { + this.z = this.y; +>this.z = this.y : number +>this.z : number +>this : typeof C +>z : number +>this.y : number +>this : typeof C +>y : number + } +} + diff --git a/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=es2022).errors.txt b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=es2022).errors.txt new file mode 100644 index 0000000000000..e95cceef97526 --- /dev/null +++ b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=es2022).errors.txt @@ -0,0 +1,14 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts(3,14): error TS2729: Property 'x' is used before its initialization. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts (1 errors) ==== + class C { + static { + this.x = 1; + ~ +!!! error TS2729: Property 'x' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts:5:12: 'x' is declared here. + } + static x; + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=es2022).symbols b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=es2022).symbols new file mode 100644 index 0000000000000..9781ba0779193 --- /dev/null +++ b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=es2022).symbols @@ -0,0 +1,14 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts === +class C { +>C : Symbol(C, Decl(classStaticBlockUseBeforeDef2.ts, 0, 0)) + + static { + this.x = 1; +>this.x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef2.ts, 3, 5)) +>this : Symbol(C, Decl(classStaticBlockUseBeforeDef2.ts, 0, 0)) +>x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef2.ts, 3, 5)) + } + static x; +>x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef2.ts, 3, 5)) +} + diff --git a/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=es2022).types b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=es2022).types new file mode 100644 index 0000000000000..bae1432f62e0f --- /dev/null +++ b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=es2022).types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts === +class C { +>C : C + + static { + this.x = 1; +>this.x = 1 : 1 +>this.x : number +>this : typeof C +>x : number +>1 : 1 + } + static x; +>x : number +} + diff --git a/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=esnext).errors.txt b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=esnext).errors.txt new file mode 100644 index 0000000000000..e95cceef97526 --- /dev/null +++ b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=esnext).errors.txt @@ -0,0 +1,14 @@ +tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts(3,14): error TS2729: Property 'x' is used before its initialization. + + +==== tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts (1 errors) ==== + class C { + static { + this.x = 1; + ~ +!!! error TS2729: Property 'x' is used before its initialization. +!!! related TS2728 tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts:5:12: 'x' is declared here. + } + static x; + } + \ No newline at end of file diff --git a/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=esnext).symbols b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=esnext).symbols new file mode 100644 index 0000000000000..9781ba0779193 --- /dev/null +++ b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=esnext).symbols @@ -0,0 +1,14 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts === +class C { +>C : Symbol(C, Decl(classStaticBlockUseBeforeDef2.ts, 0, 0)) + + static { + this.x = 1; +>this.x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef2.ts, 3, 5)) +>this : Symbol(C, Decl(classStaticBlockUseBeforeDef2.ts, 0, 0)) +>x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef2.ts, 3, 5)) + } + static x; +>x : Symbol(C.x, Decl(classStaticBlockUseBeforeDef2.ts, 3, 5)) +} + diff --git a/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=esnext).types b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=esnext).types new file mode 100644 index 0000000000000..bae1432f62e0f --- /dev/null +++ b/tests/baselines/reference/classStaticBlockUseBeforeDef2(target=esnext).types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts === +class C { +>C : C + + static { + this.x = 1; +>this.x = 1 : 1 +>this.x : number +>this : typeof C +>x : number +>1 : 1 + } + static x; +>x : number +} + diff --git a/tests/baselines/reference/privateNameAndStaticInitializer(target=es2022).js b/tests/baselines/reference/privateNameAndStaticInitializer(target=es2022).js new file mode 100644 index 0000000000000..12690344bab46 --- /dev/null +++ b/tests/baselines/reference/privateNameAndStaticInitializer(target=es2022).js @@ -0,0 +1,15 @@ +//// [privateNameAndStaticInitializer.ts] +class A { + #foo = 1; + static inst = new A(); + #prop = 2; +} + + + +//// [privateNameAndStaticInitializer.js] +class A { + #foo = 1; + static inst = new A(); + #prop = 2; +} diff --git a/tests/baselines/reference/privateNameAndStaticInitializer(target=es2022).symbols b/tests/baselines/reference/privateNameAndStaticInitializer(target=es2022).symbols new file mode 100644 index 0000000000000..2c6f3a53aeae5 --- /dev/null +++ b/tests/baselines/reference/privateNameAndStaticInitializer(target=es2022).symbols @@ -0,0 +1,16 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameAndStaticInitializer.ts === +class A { +>A : Symbol(A, Decl(privateNameAndStaticInitializer.ts, 0, 0)) + + #foo = 1; +>#foo : Symbol(A.#foo, Decl(privateNameAndStaticInitializer.ts, 0, 9)) + + static inst = new A(); +>inst : Symbol(A.inst, Decl(privateNameAndStaticInitializer.ts, 1, 11)) +>A : Symbol(A, Decl(privateNameAndStaticInitializer.ts, 0, 0)) + + #prop = 2; +>#prop : Symbol(A.#prop, Decl(privateNameAndStaticInitializer.ts, 2, 24)) +} + + diff --git a/tests/baselines/reference/privateNameAndStaticInitializer(target=es2022).types b/tests/baselines/reference/privateNameAndStaticInitializer(target=es2022).types new file mode 100644 index 0000000000000..1c6267617ac9d --- /dev/null +++ b/tests/baselines/reference/privateNameAndStaticInitializer(target=es2022).types @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameAndStaticInitializer.ts === +class A { +>A : A + + #foo = 1; +>#foo : number +>1 : 1 + + static inst = new A(); +>inst : A +>new A() : A +>A : typeof A + + #prop = 2; +>#prop : number +>2 : 2 +} + + diff --git a/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).errors.txt b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).errors.txt new file mode 100644 index 0000000000000..976e71e8d06cf --- /dev/null +++ b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).errors.txt @@ -0,0 +1,18 @@ +tests/cases/conformance/classes/members/privateNames/privateNameBadSuperUseDefineForClassFields.ts(4,5): error TS2376: A 'super' call must be the first statement in the constructor when a class contains initialized properties, parameter properties, or private identifiers. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameBadSuperUseDefineForClassFields.ts (1 errors) ==== + class B {}; + class A extends B { + #x; + constructor() { + ~~~~~~~~~~~~~~~ + void 0; // Error: 'super' call must come first + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + super(); + ~~~~~~~~~~~~~~~~ + } + ~~~~~ +!!! error TS2376: A 'super' call must be the first statement in the constructor when a class contains initialized properties, parameter properties, or private identifiers. + } + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).js b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).js new file mode 100644 index 0000000000000..018c1eaaecedb --- /dev/null +++ b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).js @@ -0,0 +1,22 @@ +//// [privateNameBadSuperUseDefineForClassFields.ts] +class B {}; +class A extends B { + #x; + constructor() { + void 0; // Error: 'super' call must come first + super(); + } +} + + +//// [privateNameBadSuperUseDefineForClassFields.js] +class B { +} +; +class A extends B { + #x; + constructor() { + void 0; // Error: 'super' call must come first + super(); + } +} diff --git a/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).symbols b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).symbols new file mode 100644 index 0000000000000..5e5115d741790 --- /dev/null +++ b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameBadSuperUseDefineForClassFields.ts === +class B {}; +>B : Symbol(B, Decl(privateNameBadSuperUseDefineForClassFields.ts, 0, 0)) + +class A extends B { +>A : Symbol(A, Decl(privateNameBadSuperUseDefineForClassFields.ts, 0, 11)) +>B : Symbol(B, Decl(privateNameBadSuperUseDefineForClassFields.ts, 0, 0)) + + #x; +>#x : Symbol(A.#x, Decl(privateNameBadSuperUseDefineForClassFields.ts, 1, 19)) + + constructor() { + void 0; // Error: 'super' call must come first + super(); +>super : Symbol(B, Decl(privateNameBadSuperUseDefineForClassFields.ts, 0, 0)) + } +} + diff --git a/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).types b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).types new file mode 100644 index 0000000000000..55432691aece8 --- /dev/null +++ b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=es2022).types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameBadSuperUseDefineForClassFields.ts === +class B {}; +>B : B + +class A extends B { +>A : A +>B : B + + #x; +>#x : any + + constructor() { + void 0; // Error: 'super' call must come first +>void 0 : undefined +>0 : 0 + + super(); +>super() : void +>super : typeof B + } +} + diff --git a/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=esnext).js b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=esnext).js new file mode 100644 index 0000000000000..018c1eaaecedb --- /dev/null +++ b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=esnext).js @@ -0,0 +1,22 @@ +//// [privateNameBadSuperUseDefineForClassFields.ts] +class B {}; +class A extends B { + #x; + constructor() { + void 0; // Error: 'super' call must come first + super(); + } +} + + +//// [privateNameBadSuperUseDefineForClassFields.js] +class B { +} +; +class A extends B { + #x; + constructor() { + void 0; // Error: 'super' call must come first + super(); + } +} diff --git a/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=esnext).symbols b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=esnext).symbols new file mode 100644 index 0000000000000..5e5115d741790 --- /dev/null +++ b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=esnext).symbols @@ -0,0 +1,18 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameBadSuperUseDefineForClassFields.ts === +class B {}; +>B : Symbol(B, Decl(privateNameBadSuperUseDefineForClassFields.ts, 0, 0)) + +class A extends B { +>A : Symbol(A, Decl(privateNameBadSuperUseDefineForClassFields.ts, 0, 11)) +>B : Symbol(B, Decl(privateNameBadSuperUseDefineForClassFields.ts, 0, 0)) + + #x; +>#x : Symbol(A.#x, Decl(privateNameBadSuperUseDefineForClassFields.ts, 1, 19)) + + constructor() { + void 0; // Error: 'super' call must come first + super(); +>super : Symbol(B, Decl(privateNameBadSuperUseDefineForClassFields.ts, 0, 0)) + } +} + diff --git a/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=esnext).types b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=esnext).types new file mode 100644 index 0000000000000..55432691aece8 --- /dev/null +++ b/tests/baselines/reference/privateNameBadSuperUseDefineForClassFields(target=esnext).types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameBadSuperUseDefineForClassFields.ts === +class B {}; +>B : B + +class A extends B { +>A : A +>B : B + + #x; +>#x : any + + constructor() { + void 0; // Error: 'super' call must come first +>void 0 : undefined +>0 : 0 + + super(); +>super() : void +>super : typeof B + } +} + diff --git a/tests/baselines/reference/privateNameComputedPropertyName1(target=es2022).js b/tests/baselines/reference/privateNameComputedPropertyName1(target=es2022).js new file mode 100644 index 0000000000000..971dd46b00aa3 --- /dev/null +++ b/tests/baselines/reference/privateNameComputedPropertyName1(target=es2022).js @@ -0,0 +1,63 @@ +//// [privateNameComputedPropertyName1.ts] +class A { + #a = 'a'; + #b: string; + + readonly #c = 'c'; + readonly #d: string; + + #e = ''; + + constructor() { + this.#b = 'b'; + this.#d = 'd'; + } + + test() { + const data: Record = { a: 'a', b: 'b', c: 'c', d: 'd', e: 'e' }; + const { + [this.#a]: a, + [this.#b]: b, + [this.#c]: c, + [this.#d]: d, + [this.#e = 'e']: e, + } = data; + console.log(a, b, c, d, e); + + const a1 = data[this.#a]; + const b1 = data[this.#b]; + const c1 = data[this.#c]; + const d1 = data[this.#d]; + const e1 = data[this.#e]; + console.log(a1, b1, c1, d1); + } +} + +new A().test(); + + + +//// [privateNameComputedPropertyName1.js] +class A { + #a = 'a'; + #b; + #c = 'c'; + #d; + #e = ''; + constructor() { + this.#b = 'b'; + this.#d = 'd'; + } + test() { + const data = { a: 'a', b: 'b', c: 'c', d: 'd', e: 'e' }; + const { [this.#a]: a, [this.#b]: b, [this.#c]: c, [this.#d]: d, [this.#e = 'e']: e, } = data; + console.log(a, b, c, d, e); + const a1 = data[this.#a]; + const b1 = data[this.#b]; + const c1 = data[this.#c]; + const d1 = data[this.#d]; + const e1 = data[this.#e]; + console.log(a1, b1, c1, d1); + } +} +new A().test(); diff --git a/tests/baselines/reference/privateNameComputedPropertyName1(target=es2022).symbols b/tests/baselines/reference/privateNameComputedPropertyName1(target=es2022).symbols new file mode 100644 index 0000000000000..b7aa24012d799 --- /dev/null +++ b/tests/baselines/reference/privateNameComputedPropertyName1(target=es2022).symbols @@ -0,0 +1,127 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName1.ts === +class A { +>A : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) + + #a = 'a'; +>#a : Symbol(A.#a, Decl(privateNameComputedPropertyName1.ts, 0, 9)) + + #b: string; +>#b : Symbol(A.#b, Decl(privateNameComputedPropertyName1.ts, 1, 13)) + + readonly #c = 'c'; +>#c : Symbol(A.#c, Decl(privateNameComputedPropertyName1.ts, 2, 15)) + + readonly #d: string; +>#d : Symbol(A.#d, Decl(privateNameComputedPropertyName1.ts, 4, 22)) + + #e = ''; +>#e : Symbol(A.#e, Decl(privateNameComputedPropertyName1.ts, 5, 24)) + + constructor() { + this.#b = 'b'; +>this.#b : Symbol(A.#b, Decl(privateNameComputedPropertyName1.ts, 1, 13)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) + + this.#d = 'd'; +>this.#d : Symbol(A.#d, Decl(privateNameComputedPropertyName1.ts, 4, 22)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) + } + + test() { +>test : Symbol(A.test, Decl(privateNameComputedPropertyName1.ts, 12, 5)) + + const data: Record = { a: 'a', b: 'b', c: 'c', d: 'd', e: 'e' }; +>data : Symbol(data, Decl(privateNameComputedPropertyName1.ts, 15, 13)) +>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --)) +>a : Symbol(a, Decl(privateNameComputedPropertyName1.ts, 15, 46)) +>b : Symbol(b, Decl(privateNameComputedPropertyName1.ts, 15, 54)) +>c : Symbol(c, Decl(privateNameComputedPropertyName1.ts, 15, 62)) +>d : Symbol(d, Decl(privateNameComputedPropertyName1.ts, 15, 70)) +>e : Symbol(e, Decl(privateNameComputedPropertyName1.ts, 15, 78)) + + const { + [this.#a]: a, +>this.#a : Symbol(A.#a, Decl(privateNameComputedPropertyName1.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) +>a : Symbol(a, Decl(privateNameComputedPropertyName1.ts, 16, 15)) + + [this.#b]: b, +>this.#b : Symbol(A.#b, Decl(privateNameComputedPropertyName1.ts, 1, 13)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) +>b : Symbol(b, Decl(privateNameComputedPropertyName1.ts, 17, 25)) + + [this.#c]: c, +>this.#c : Symbol(A.#c, Decl(privateNameComputedPropertyName1.ts, 2, 15)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) +>c : Symbol(c, Decl(privateNameComputedPropertyName1.ts, 18, 25)) + + [this.#d]: d, +>this.#d : Symbol(A.#d, Decl(privateNameComputedPropertyName1.ts, 4, 22)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) +>d : Symbol(d, Decl(privateNameComputedPropertyName1.ts, 19, 25)) + + [this.#e = 'e']: e, +>this.#e : Symbol(A.#e, Decl(privateNameComputedPropertyName1.ts, 5, 24)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) +>e : Symbol(e, Decl(privateNameComputedPropertyName1.ts, 20, 25)) + + } = data; +>data : Symbol(data, Decl(privateNameComputedPropertyName1.ts, 15, 13)) + + console.log(a, b, c, d, e); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>a : Symbol(a, Decl(privateNameComputedPropertyName1.ts, 16, 15)) +>b : Symbol(b, Decl(privateNameComputedPropertyName1.ts, 17, 25)) +>c : Symbol(c, Decl(privateNameComputedPropertyName1.ts, 18, 25)) +>d : Symbol(d, Decl(privateNameComputedPropertyName1.ts, 19, 25)) +>e : Symbol(e, Decl(privateNameComputedPropertyName1.ts, 20, 25)) + + const a1 = data[this.#a]; +>a1 : Symbol(a1, Decl(privateNameComputedPropertyName1.ts, 25, 13)) +>data : Symbol(data, Decl(privateNameComputedPropertyName1.ts, 15, 13)) +>this.#a : Symbol(A.#a, Decl(privateNameComputedPropertyName1.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) + + const b1 = data[this.#b]; +>b1 : Symbol(b1, Decl(privateNameComputedPropertyName1.ts, 26, 13)) +>data : Symbol(data, Decl(privateNameComputedPropertyName1.ts, 15, 13)) +>this.#b : Symbol(A.#b, Decl(privateNameComputedPropertyName1.ts, 1, 13)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) + + const c1 = data[this.#c]; +>c1 : Symbol(c1, Decl(privateNameComputedPropertyName1.ts, 27, 13)) +>data : Symbol(data, Decl(privateNameComputedPropertyName1.ts, 15, 13)) +>this.#c : Symbol(A.#c, Decl(privateNameComputedPropertyName1.ts, 2, 15)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) + + const d1 = data[this.#d]; +>d1 : Symbol(d1, Decl(privateNameComputedPropertyName1.ts, 28, 13)) +>data : Symbol(data, Decl(privateNameComputedPropertyName1.ts, 15, 13)) +>this.#d : Symbol(A.#d, Decl(privateNameComputedPropertyName1.ts, 4, 22)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) + + const e1 = data[this.#e]; +>e1 : Symbol(e1, Decl(privateNameComputedPropertyName1.ts, 29, 13)) +>data : Symbol(data, Decl(privateNameComputedPropertyName1.ts, 15, 13)) +>this.#e : Symbol(A.#e, Decl(privateNameComputedPropertyName1.ts, 5, 24)) +>this : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) + + console.log(a1, b1, c1, d1); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>a1 : Symbol(a1, Decl(privateNameComputedPropertyName1.ts, 25, 13)) +>b1 : Symbol(b1, Decl(privateNameComputedPropertyName1.ts, 26, 13)) +>c1 : Symbol(c1, Decl(privateNameComputedPropertyName1.ts, 27, 13)) +>d1 : Symbol(d1, Decl(privateNameComputedPropertyName1.ts, 28, 13)) + } +} + +new A().test(); +>new A().test : Symbol(A.test, Decl(privateNameComputedPropertyName1.ts, 12, 5)) +>A : Symbol(A, Decl(privateNameComputedPropertyName1.ts, 0, 0)) +>test : Symbol(A.test, Decl(privateNameComputedPropertyName1.ts, 12, 5)) + + diff --git a/tests/baselines/reference/privateNameComputedPropertyName1(target=es2022).types b/tests/baselines/reference/privateNameComputedPropertyName1(target=es2022).types new file mode 100644 index 0000000000000..f8b24c7ecd898 --- /dev/null +++ b/tests/baselines/reference/privateNameComputedPropertyName1(target=es2022).types @@ -0,0 +1,150 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName1.ts === +class A { +>A : A + + #a = 'a'; +>#a : string +>'a' : "a" + + #b: string; +>#b : string + + readonly #c = 'c'; +>#c : "c" +>'c' : "c" + + readonly #d: string; +>#d : string + + #e = ''; +>#e : string +>'' : "" + + constructor() { + this.#b = 'b'; +>this.#b = 'b' : "b" +>this.#b : string +>this : this +>'b' : "b" + + this.#d = 'd'; +>this.#d = 'd' : "d" +>this.#d : string +>this : this +>'d' : "d" + } + + test() { +>test : () => void + + const data: Record = { a: 'a', b: 'b', c: 'c', d: 'd', e: 'e' }; +>data : Record +>{ a: 'a', b: 'b', c: 'c', d: 'd', e: 'e' } : { a: string; b: string; c: string; d: string; e: string; } +>a : string +>'a' : "a" +>b : string +>'b' : "b" +>c : string +>'c' : "c" +>d : string +>'d' : "d" +>e : string +>'e' : "e" + + const { + [this.#a]: a, +>this.#a : string +>this : this +>a : string + + [this.#b]: b, +>this.#b : string +>this : this +>b : string + + [this.#c]: c, +>this.#c : "c" +>this : this +>c : string + + [this.#d]: d, +>this.#d : string +>this : this +>d : string + + [this.#e = 'e']: e, +>this.#e = 'e' : "e" +>this.#e : string +>this : this +>'e' : "e" +>e : string + + } = data; +>data : Record + + console.log(a, b, c, d, e); +>console.log(a, b, c, d, e) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>a : string +>b : string +>c : string +>d : string +>e : string + + const a1 = data[this.#a]; +>a1 : string +>data[this.#a] : string +>data : Record +>this.#a : string +>this : this + + const b1 = data[this.#b]; +>b1 : string +>data[this.#b] : string +>data : Record +>this.#b : string +>this : this + + const c1 = data[this.#c]; +>c1 : string +>data[this.#c] : string +>data : Record +>this.#c : "c" +>this : this + + const d1 = data[this.#d]; +>d1 : string +>data[this.#d] : string +>data : Record +>this.#d : string +>this : this + + const e1 = data[this.#e]; +>e1 : string +>data[this.#e] : string +>data : Record +>this.#e : string +>this : this + + console.log(a1, b1, c1, d1); +>console.log(a1, b1, c1, d1) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>a1 : string +>b1 : string +>c1 : string +>d1 : string + } +} + +new A().test(); +>new A().test() : void +>new A().test : () => void +>new A() : A +>A : typeof A +>test : () => void + + diff --git a/tests/baselines/reference/privateNameComputedPropertyName2(target=es2022).js b/tests/baselines/reference/privateNameComputedPropertyName2(target=es2022).js new file mode 100644 index 0000000000000..e2c4addd45e60 --- /dev/null +++ b/tests/baselines/reference/privateNameComputedPropertyName2(target=es2022).js @@ -0,0 +1,18 @@ +//// [privateNameComputedPropertyName2.ts] +let getX: (a: A) => number; + +class A { + #x = 100; + [(getX = (a: A) => a.#x, "_")]() {} +} + +console.log(getX(new A)); + + +//// [privateNameComputedPropertyName2.js] +let getX; +class A { + #x = 100; + [(getX = (a) => a.#x, "_")]() { } +} +console.log(getX(new A)); diff --git a/tests/baselines/reference/privateNameComputedPropertyName2(target=es2022).symbols b/tests/baselines/reference/privateNameComputedPropertyName2(target=es2022).symbols new file mode 100644 index 0000000000000..8c4bcf6d8916e --- /dev/null +++ b/tests/baselines/reference/privateNameComputedPropertyName2(target=es2022).symbols @@ -0,0 +1,28 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName2.ts === +let getX: (a: A) => number; +>getX : Symbol(getX, Decl(privateNameComputedPropertyName2.ts, 0, 3)) +>a : Symbol(a, Decl(privateNameComputedPropertyName2.ts, 0, 11)) +>A : Symbol(A, Decl(privateNameComputedPropertyName2.ts, 0, 27)) + +class A { +>A : Symbol(A, Decl(privateNameComputedPropertyName2.ts, 0, 27)) + + #x = 100; +>#x : Symbol(A.#x, Decl(privateNameComputedPropertyName2.ts, 2, 9)) + + [(getX = (a: A) => a.#x, "_")]() {} +>[(getX = (a: A) => a.#x, "_")] : Symbol(A[(getX = (a: A) => a.#x, "_")], Decl(privateNameComputedPropertyName2.ts, 3, 13)) +>getX : Symbol(getX, Decl(privateNameComputedPropertyName2.ts, 0, 3)) +>a : Symbol(a, Decl(privateNameComputedPropertyName2.ts, 4, 14)) +>A : Symbol(A, Decl(privateNameComputedPropertyName2.ts, 0, 27)) +>a.#x : Symbol(A.#x, Decl(privateNameComputedPropertyName2.ts, 2, 9)) +>a : Symbol(a, Decl(privateNameComputedPropertyName2.ts, 4, 14)) +} + +console.log(getX(new A)); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>getX : Symbol(getX, Decl(privateNameComputedPropertyName2.ts, 0, 3)) +>A : Symbol(A, Decl(privateNameComputedPropertyName2.ts, 0, 27)) + diff --git a/tests/baselines/reference/privateNameComputedPropertyName2(target=es2022).types b/tests/baselines/reference/privateNameComputedPropertyName2(target=es2022).types new file mode 100644 index 0000000000000..8d9cd2378bb0f --- /dev/null +++ b/tests/baselines/reference/privateNameComputedPropertyName2(target=es2022).types @@ -0,0 +1,35 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName2.ts === +let getX: (a: A) => number; +>getX : (a: A) => number +>a : A + +class A { +>A : A + + #x = 100; +>#x : number +>100 : 100 + + [(getX = (a: A) => a.#x, "_")]() {} +>[(getX = (a: A) => a.#x, "_")] : () => void +>(getX = (a: A) => a.#x, "_") : "_" +>getX = (a: A) => a.#x, "_" : "_" +>getX = (a: A) => a.#x : (a: A) => number +>getX : (a: A) => number +>(a: A) => a.#x : (a: A) => number +>a : A +>a.#x : number +>a : A +>"_" : "_" +} + +console.log(getX(new A)); +>console.log(getX(new A)) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>getX(new A) : number +>getX : (a: A) => number +>new A : A +>A : typeof A + diff --git a/tests/baselines/reference/privateNameComputedPropertyName3(target=es2022).js b/tests/baselines/reference/privateNameComputedPropertyName3(target=es2022).js new file mode 100644 index 0000000000000..56fbda76b4922 --- /dev/null +++ b/tests/baselines/reference/privateNameComputedPropertyName3(target=es2022).js @@ -0,0 +1,44 @@ +//// [privateNameComputedPropertyName3.ts] +class Foo { + #name; + + constructor(name) { + this.#name = name; + } + + getValue(x) { + const obj = this; + + class Bar { + #y = 100; + + [obj.#name]() { + return x + this.#y; + } + } + + return new Bar()[obj.#name](); + } +} + +console.log(new Foo("NAME").getValue(100)); + + +//// [privateNameComputedPropertyName3.js] +class Foo { + #name; + constructor(name) { + this.#name = name; + } + getValue(x) { + const obj = this; + class Bar { + #y = 100; + [obj.#name]() { + return x + this.#y; + } + } + return new Bar()[obj.#name](); + } +} +console.log(new Foo("NAME").getValue(100)); diff --git a/tests/baselines/reference/privateNameComputedPropertyName3(target=es2022).symbols b/tests/baselines/reference/privateNameComputedPropertyName3(target=es2022).symbols new file mode 100644 index 0000000000000..59403f53b88f2 --- /dev/null +++ b/tests/baselines/reference/privateNameComputedPropertyName3(target=es2022).symbols @@ -0,0 +1,57 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName3.ts === +class Foo { +>Foo : Symbol(Foo, Decl(privateNameComputedPropertyName3.ts, 0, 0)) + + #name; +>#name : Symbol(Foo.#name, Decl(privateNameComputedPropertyName3.ts, 0, 11)) + + constructor(name) { +>name : Symbol(name, Decl(privateNameComputedPropertyName3.ts, 3, 16)) + + this.#name = name; +>this.#name : Symbol(Foo.#name, Decl(privateNameComputedPropertyName3.ts, 0, 11)) +>this : Symbol(Foo, Decl(privateNameComputedPropertyName3.ts, 0, 0)) +>name : Symbol(name, Decl(privateNameComputedPropertyName3.ts, 3, 16)) + } + + getValue(x) { +>getValue : Symbol(Foo.getValue, Decl(privateNameComputedPropertyName3.ts, 5, 5)) +>x : Symbol(x, Decl(privateNameComputedPropertyName3.ts, 7, 13)) + + const obj = this; +>obj : Symbol(obj, Decl(privateNameComputedPropertyName3.ts, 8, 13)) +>this : Symbol(Foo, Decl(privateNameComputedPropertyName3.ts, 0, 0)) + + class Bar { +>Bar : Symbol(Bar, Decl(privateNameComputedPropertyName3.ts, 8, 25)) + + #y = 100; +>#y : Symbol(Bar.#y, Decl(privateNameComputedPropertyName3.ts, 10, 19)) + + [obj.#name]() { +>[obj.#name] : Symbol(Bar[obj.#name], Decl(privateNameComputedPropertyName3.ts, 11, 21)) +>obj.#name : Symbol(Foo.#name, Decl(privateNameComputedPropertyName3.ts, 0, 11)) +>obj : Symbol(obj, Decl(privateNameComputedPropertyName3.ts, 8, 13)) + + return x + this.#y; +>x : Symbol(x, Decl(privateNameComputedPropertyName3.ts, 7, 13)) +>this.#y : Symbol(Bar.#y, Decl(privateNameComputedPropertyName3.ts, 10, 19)) +>this : Symbol(Bar, Decl(privateNameComputedPropertyName3.ts, 8, 25)) + } + } + + return new Bar()[obj.#name](); +>Bar : Symbol(Bar, Decl(privateNameComputedPropertyName3.ts, 8, 25)) +>obj.#name : Symbol(Foo.#name, Decl(privateNameComputedPropertyName3.ts, 0, 11)) +>obj : Symbol(obj, Decl(privateNameComputedPropertyName3.ts, 8, 13)) + } +} + +console.log(new Foo("NAME").getValue(100)); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>new Foo("NAME").getValue : Symbol(Foo.getValue, Decl(privateNameComputedPropertyName3.ts, 5, 5)) +>Foo : Symbol(Foo, Decl(privateNameComputedPropertyName3.ts, 0, 0)) +>getValue : Symbol(Foo.getValue, Decl(privateNameComputedPropertyName3.ts, 5, 5)) + diff --git a/tests/baselines/reference/privateNameComputedPropertyName3(target=es2022).types b/tests/baselines/reference/privateNameComputedPropertyName3(target=es2022).types new file mode 100644 index 0000000000000..6bffb1abbae5a --- /dev/null +++ b/tests/baselines/reference/privateNameComputedPropertyName3(target=es2022).types @@ -0,0 +1,68 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName3.ts === +class Foo { +>Foo : Foo + + #name; +>#name : any + + constructor(name) { +>name : any + + this.#name = name; +>this.#name = name : any +>this.#name : any +>this : this +>name : any + } + + getValue(x) { +>getValue : (x: any) => any +>x : any + + const obj = this; +>obj : this +>this : this + + class Bar { +>Bar : Bar + + #y = 100; +>#y : number +>100 : 100 + + [obj.#name]() { +>[obj.#name] : () => any +>obj.#name : any +>obj : this + + return x + this.#y; +>x + this.#y : any +>x : any +>this.#y : number +>this : this + } + } + + return new Bar()[obj.#name](); +>new Bar()[obj.#name]() : error +>new Bar()[obj.#name] : error +>new Bar() : Bar +>Bar : typeof Bar +>obj.#name : any +>obj : this + } +} + +console.log(new Foo("NAME").getValue(100)); +>console.log(new Foo("NAME").getValue(100)) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>new Foo("NAME").getValue(100) : error +>new Foo("NAME").getValue : (x: any) => any +>new Foo("NAME") : Foo +>Foo : typeof Foo +>"NAME" : "NAME" +>getValue : (x: any) => any +>100 : 100 + diff --git a/tests/baselines/reference/privateNameComputedPropertyName4(target=es2022).js b/tests/baselines/reference/privateNameComputedPropertyName4(target=es2022).js new file mode 100644 index 0000000000000..26190d3042c21 --- /dev/null +++ b/tests/baselines/reference/privateNameComputedPropertyName4(target=es2022).js @@ -0,0 +1,30 @@ +//// [privateNameComputedPropertyName4.ts] +// https://github.com/microsoft/TypeScript/issues/44113 +class C1 { + static #qux = 42; + ["bar"] () {} +} +class C2 { + static #qux = 42; + static ["bar"] () {} +} +class C3 { + static #qux = 42; + static ["bar"] = "test"; +} + + +//// [privateNameComputedPropertyName4.js] +// https://github.com/microsoft/TypeScript/issues/44113 +class C1 { + static #qux = 42; + ["bar"]() { } +} +class C2 { + static #qux = 42; + static ["bar"]() { } +} +class C3 { + static #qux = 42; + static ["bar"] = "test"; +} diff --git a/tests/baselines/reference/privateNameFieldDestructuredBinding(target=es2022).js b/tests/baselines/reference/privateNameFieldDestructuredBinding(target=es2022).js new file mode 100644 index 0000000000000..1ce8eb6433ea7 --- /dev/null +++ b/tests/baselines/reference/privateNameFieldDestructuredBinding(target=es2022).js @@ -0,0 +1,50 @@ +//// [privateNameFieldDestructuredBinding.ts] +class A { + #field = 1; + otherObject = new A(); + testObject() { + return { x: 10, y: 6 }; + } + testArray() { + return [10, 11]; + } + constructor() { + let y: number; + ({ x: this.#field, y } = this.testObject()); + ([this.#field, y] = this.testArray()); + ({ a: this.#field, b: [this.#field] } = { a: 1, b: [2] }); + [this.#field, [this.#field]] = [1, [2]]; + ({ a: this.#field = 1, b: [this.#field = 1] } = { b: [] }); + [this.#field = 2] = []; + [this.otherObject.#field = 2] = []; + } + static test(_a: A) { + [_a.#field] = [2]; + } +} + + +//// [privateNameFieldDestructuredBinding.js] +class A { + #field = 1; + otherObject = new A(); + testObject() { + return { x: 10, y: 6 }; + } + testArray() { + return [10, 11]; + } + constructor() { + let y; + ({ x: this.#field, y } = this.testObject()); + ([this.#field, y] = this.testArray()); + ({ a: this.#field, b: [this.#field] } = { a: 1, b: [2] }); + [this.#field, [this.#field]] = [1, [2]]; + ({ a: this.#field = 1, b: [this.#field = 1] } = { b: [] }); + [this.#field = 2] = []; + [this.otherObject.#field = 2] = []; + } + static test(_a) { + [_a.#field] = [2]; + } +} diff --git a/tests/baselines/reference/privateNameFieldDestructuredBinding(target=es2022).symbols b/tests/baselines/reference/privateNameFieldDestructuredBinding(target=es2022).symbols new file mode 100644 index 0000000000000..670e8b8c7d018 --- /dev/null +++ b/tests/baselines/reference/privateNameFieldDestructuredBinding(target=es2022).symbols @@ -0,0 +1,90 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameFieldDestructuredBinding.ts === +class A { +>A : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) + + #field = 1; +>#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) + + otherObject = new A(); +>otherObject : Symbol(A.otherObject, Decl(privateNameFieldDestructuredBinding.ts, 1, 15)) +>A : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) + + testObject() { +>testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 2, 26)) + + return { x: 10, y: 6 }; +>x : Symbol(x, Decl(privateNameFieldDestructuredBinding.ts, 4, 16)) +>y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 4, 23)) + } + testArray() { +>testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 5, 5)) + + return [10, 11]; + } + constructor() { + let y: number; +>y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 10, 11)) + + ({ x: this.#field, y } = this.testObject()); +>x : Symbol(x, Decl(privateNameFieldDestructuredBinding.ts, 11, 10)) +>this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 11, 26)) +>this.testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 2, 26)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>testObject : Symbol(A.testObject, Decl(privateNameFieldDestructuredBinding.ts, 2, 26)) + + ([this.#field, y] = this.testArray()); +>this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>y : Symbol(y, Decl(privateNameFieldDestructuredBinding.ts, 10, 11)) +>this.testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 5, 5)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>testArray : Symbol(A.testArray, Decl(privateNameFieldDestructuredBinding.ts, 5, 5)) + + ({ a: this.#field, b: [this.#field] } = { a: 1, b: [2] }); +>a : Symbol(a, Decl(privateNameFieldDestructuredBinding.ts, 13, 10)) +>this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>b : Symbol(b, Decl(privateNameFieldDestructuredBinding.ts, 13, 26)) +>this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>a : Symbol(a, Decl(privateNameFieldDestructuredBinding.ts, 13, 49)) +>b : Symbol(b, Decl(privateNameFieldDestructuredBinding.ts, 13, 55)) + + [this.#field, [this.#field]] = [1, [2]]; +>this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) + + ({ a: this.#field = 1, b: [this.#field = 1] } = { b: [] }); +>a : Symbol(a, Decl(privateNameFieldDestructuredBinding.ts, 15, 10)) +>this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>b : Symbol(b, Decl(privateNameFieldDestructuredBinding.ts, 15, 30)) +>this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>b : Symbol(b, Decl(privateNameFieldDestructuredBinding.ts, 15, 57)) + + [this.#field = 2] = []; +>this.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) + + [this.otherObject.#field = 2] = []; +>this.otherObject.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>this.otherObject : Symbol(A.otherObject, Decl(privateNameFieldDestructuredBinding.ts, 1, 15)) +>this : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) +>otherObject : Symbol(A.otherObject, Decl(privateNameFieldDestructuredBinding.ts, 1, 15)) + } + static test(_a: A) { +>test : Symbol(A.test, Decl(privateNameFieldDestructuredBinding.ts, 18, 5)) +>_a : Symbol(_a, Decl(privateNameFieldDestructuredBinding.ts, 19, 16)) +>A : Symbol(A, Decl(privateNameFieldDestructuredBinding.ts, 0, 0)) + + [_a.#field] = [2]; +>_a.#field : Symbol(A.#field, Decl(privateNameFieldDestructuredBinding.ts, 0, 9)) +>_a : Symbol(_a, Decl(privateNameFieldDestructuredBinding.ts, 19, 16)) + } +} + diff --git a/tests/baselines/reference/privateNameFieldDestructuredBinding(target=es2022).types b/tests/baselines/reference/privateNameFieldDestructuredBinding(target=es2022).types new file mode 100644 index 0000000000000..d361e73d3829d --- /dev/null +++ b/tests/baselines/reference/privateNameFieldDestructuredBinding(target=es2022).types @@ -0,0 +1,144 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameFieldDestructuredBinding.ts === +class A { +>A : A + + #field = 1; +>#field : number +>1 : 1 + + otherObject = new A(); +>otherObject : A +>new A() : A +>A : typeof A + + testObject() { +>testObject : () => { x: number; y: number; } + + return { x: 10, y: 6 }; +>{ x: 10, y: 6 } : { x: number; y: number; } +>x : number +>10 : 10 +>y : number +>6 : 6 + } + testArray() { +>testArray : () => number[] + + return [10, 11]; +>[10, 11] : number[] +>10 : 10 +>11 : 11 + } + constructor() { + let y: number; +>y : number + + ({ x: this.#field, y } = this.testObject()); +>({ x: this.#field, y } = this.testObject()) : { x: number; y: number; } +>{ x: this.#field, y } = this.testObject() : { x: number; y: number; } +>{ x: this.#field, y } : { x: number; y: number; } +>x : number +>this.#field : number +>this : this +>y : number +>this.testObject() : { x: number; y: number; } +>this.testObject : () => { x: number; y: number; } +>this : this +>testObject : () => { x: number; y: number; } + + ([this.#field, y] = this.testArray()); +>([this.#field, y] = this.testArray()) : number[] +>[this.#field, y] = this.testArray() : number[] +>[this.#field, y] : [number, number] +>this.#field : number +>this : this +>y : number +>this.testArray() : number[] +>this.testArray : () => number[] +>this : this +>testArray : () => number[] + + ({ a: this.#field, b: [this.#field] } = { a: 1, b: [2] }); +>({ a: this.#field, b: [this.#field] } = { a: 1, b: [2] }) : { a: number; b: [number]; } +>{ a: this.#field, b: [this.#field] } = { a: 1, b: [2] } : { a: number; b: [number]; } +>{ a: this.#field, b: [this.#field] } : { a: number; b: [number]; } +>a : number +>this.#field : number +>this : this +>b : [number] +>[this.#field] : [number] +>this.#field : number +>this : this +>{ a: 1, b: [2] } : { a: number; b: [number]; } +>a : number +>1 : 1 +>b : [number] +>[2] : [number] +>2 : 2 + + [this.#field, [this.#field]] = [1, [2]]; +>[this.#field, [this.#field]] = [1, [2]] : [number, [number]] +>[this.#field, [this.#field]] : [number, [number]] +>this.#field : number +>this : this +>[this.#field] : [number] +>this.#field : number +>this : this +>[1, [2]] : [number, [number]] +>1 : 1 +>[2] : [number] +>2 : 2 + + ({ a: this.#field = 1, b: [this.#field = 1] } = { b: [] }); +>({ a: this.#field = 1, b: [this.#field = 1] } = { b: [] }) : { b: []; a?: number; } +>{ a: this.#field = 1, b: [this.#field = 1] } = { b: [] } : { b: []; a?: number; } +>{ a: this.#field = 1, b: [this.#field = 1] } : { a?: number; b: [number]; } +>a : number +>this.#field = 1 : 1 +>this.#field : number +>this : this +>1 : 1 +>b : [number] +>[this.#field = 1] : [number] +>this.#field = 1 : 1 +>this.#field : number +>this : this +>1 : 1 +>{ b: [] } : { b: []; a?: number; } +>b : [] +>[] : [] + + [this.#field = 2] = []; +>[this.#field = 2] = [] : [] +>[this.#field = 2] : [number] +>this.#field = 2 : 2 +>this.#field : number +>this : this +>2 : 2 +>[] : [] + + [this.otherObject.#field = 2] = []; +>[this.otherObject.#field = 2] = [] : [] +>[this.otherObject.#field = 2] : [number] +>this.otherObject.#field = 2 : 2 +>this.otherObject.#field : number +>this.otherObject : A +>this : this +>otherObject : A +>2 : 2 +>[] : [] + } + static test(_a: A) { +>test : (_a: A) => void +>_a : A + + [_a.#field] = [2]; +>[_a.#field] = [2] : [number] +>[_a.#field] : [number] +>_a.#field : number +>_a : A +>[2] : [number] +>2 : 2 + } +} + diff --git a/tests/baselines/reference/privateNameFieldsESNext(target=es2022).errors.txt b/tests/baselines/reference/privateNameFieldsESNext(target=es2022).errors.txt new file mode 100644 index 0000000000000..28f283e66a817 --- /dev/null +++ b/tests/baselines/reference/privateNameFieldsESNext(target=es2022).errors.txt @@ -0,0 +1,26 @@ +tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts(8,9): error TS2322: Type 'string' is not assignable to type 'number'. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts (1 errors) ==== + class C { + a = 123; + #a = 10; + c = "hello"; + #b; + method() { + console.log(this.#a); + this.#a = "hello"; + ~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + console.log(this.#b); + } + static #m = "test"; + static #x; + static test() { + console.log(this.#m); + console.log(this.#x = "test"); + } + #something = () => 1234; + } + + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameFieldsESNext(target=es2022).js b/tests/baselines/reference/privateNameFieldsESNext(target=es2022).js new file mode 100644 index 0000000000000..acc37caa3cc8f --- /dev/null +++ b/tests/baselines/reference/privateNameFieldsESNext(target=es2022).js @@ -0,0 +1,46 @@ +//// [privateNameFieldsESNext.ts] +class C { + a = 123; + #a = 10; + c = "hello"; + #b; + method() { + console.log(this.#a); + this.#a = "hello"; + console.log(this.#b); + } + static #m = "test"; + static #x; + static test() { + console.log(this.#m); + console.log(this.#x = "test"); + } + #something = () => 1234; +} + + + +//// [privateNameFieldsESNext.js] +class C { + constructor() { + this.a = 123; + this.#a = 10; + this.c = "hello"; + this.#something = () => 1234; + } + #a; + #b; + method() { + console.log(this.#a); + this.#a = "hello"; + console.log(this.#b); + } + static #m; + static #x; + static test() { + console.log(this.#m); + console.log(this.#x = "test"); + } + #something; +} +C.#m = "test"; diff --git a/tests/baselines/reference/privateNameFieldsESNext(target=es2022).symbols b/tests/baselines/reference/privateNameFieldsESNext(target=es2022).symbols new file mode 100644 index 0000000000000..5ed63d12d2fef --- /dev/null +++ b/tests/baselines/reference/privateNameFieldsESNext(target=es2022).symbols @@ -0,0 +1,65 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts === +class C { +>C : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + + a = 123; +>a : Symbol(C.a, Decl(privateNameFieldsESNext.ts, 0, 9)) + + #a = 10; +>#a : Symbol(C.#a, Decl(privateNameFieldsESNext.ts, 1, 12)) + + c = "hello"; +>c : Symbol(C.c, Decl(privateNameFieldsESNext.ts, 2, 12)) + + #b; +>#b : Symbol(C.#b, Decl(privateNameFieldsESNext.ts, 3, 16)) + + method() { +>method : Symbol(C.method, Decl(privateNameFieldsESNext.ts, 4, 7)) + + console.log(this.#a); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>this.#a : Symbol(C.#a, Decl(privateNameFieldsESNext.ts, 1, 12)) +>this : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + + this.#a = "hello"; +>this.#a : Symbol(C.#a, Decl(privateNameFieldsESNext.ts, 1, 12)) +>this : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + + console.log(this.#b); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>this.#b : Symbol(C.#b, Decl(privateNameFieldsESNext.ts, 3, 16)) +>this : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + } + static #m = "test"; +>#m : Symbol(C.#m, Decl(privateNameFieldsESNext.ts, 9, 5)) + + static #x; +>#x : Symbol(C.#x, Decl(privateNameFieldsESNext.ts, 10, 23)) + + static test() { +>test : Symbol(C.test, Decl(privateNameFieldsESNext.ts, 11, 14)) + + console.log(this.#m); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>this.#m : Symbol(C.#m, Decl(privateNameFieldsESNext.ts, 9, 5)) +>this : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + + console.log(this.#x = "test"); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>this.#x : Symbol(C.#x, Decl(privateNameFieldsESNext.ts, 10, 23)) +>this : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + } + #something = () => 1234; +>#something : Symbol(C.#something, Decl(privateNameFieldsESNext.ts, 15, 5)) +} + + diff --git a/tests/baselines/reference/privateNameFieldsESNext(target=es2022).types b/tests/baselines/reference/privateNameFieldsESNext(target=es2022).types new file mode 100644 index 0000000000000..8496622cbe357 --- /dev/null +++ b/tests/baselines/reference/privateNameFieldsESNext(target=es2022).types @@ -0,0 +1,79 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts === +class C { +>C : C + + a = 123; +>a : number +>123 : 123 + + #a = 10; +>#a : number +>10 : 10 + + c = "hello"; +>c : string +>"hello" : "hello" + + #b; +>#b : any + + method() { +>method : () => void + + console.log(this.#a); +>console.log(this.#a) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>this.#a : number +>this : this + + this.#a = "hello"; +>this.#a = "hello" : "hello" +>this.#a : number +>this : this +>"hello" : "hello" + + console.log(this.#b); +>console.log(this.#b) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>this.#b : any +>this : this + } + static #m = "test"; +>#m : string +>"test" : "test" + + static #x; +>#x : any + + static test() { +>test : () => void + + console.log(this.#m); +>console.log(this.#m) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>this.#m : string +>this : typeof C + + console.log(this.#x = "test"); +>console.log(this.#x = "test") : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>this.#x = "test" : "test" +>this.#x : any +>this : typeof C +>"test" : "test" + } + #something = () => 1234; +>#something : () => number +>() => 1234 : () => number +>1234 : 1234 +} + + diff --git a/tests/baselines/reference/privateNameFieldsESNext(target=esnext).errors.txt b/tests/baselines/reference/privateNameFieldsESNext(target=esnext).errors.txt new file mode 100644 index 0000000000000..10288bc30085d --- /dev/null +++ b/tests/baselines/reference/privateNameFieldsESNext(target=esnext).errors.txt @@ -0,0 +1,29 @@ +tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts(8,9): error TS2322: Type 'string' is not assignable to type 'number'. +tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts(11,17): error TS2805: Static fields with private names can't have initializers when the '--useDefineForClassFields' flag is not specified with a '--target' of 'esnext'. Consider adding the '--useDefineForClassFields' flag. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts (2 errors) ==== + class C { + a = 123; + #a = 10; + c = "hello"; + #b; + method() { + console.log(this.#a); + this.#a = "hello"; + ~~~~~~~ +!!! error TS2322: Type 'string' is not assignable to type 'number'. + console.log(this.#b); + } + static #m = "test"; + ~~~~~~ +!!! error TS2805: Static fields with private names can't have initializers when the '--useDefineForClassFields' flag is not specified with a '--target' of 'esnext'. Consider adding the '--useDefineForClassFields' flag. + static #x; + static test() { + console.log(this.#m); + console.log(this.#x = "test"); + } + #something = () => 1234; + } + + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameFieldsESNext(target=esnext).js b/tests/baselines/reference/privateNameFieldsESNext(target=esnext).js new file mode 100644 index 0000000000000..acc37caa3cc8f --- /dev/null +++ b/tests/baselines/reference/privateNameFieldsESNext(target=esnext).js @@ -0,0 +1,46 @@ +//// [privateNameFieldsESNext.ts] +class C { + a = 123; + #a = 10; + c = "hello"; + #b; + method() { + console.log(this.#a); + this.#a = "hello"; + console.log(this.#b); + } + static #m = "test"; + static #x; + static test() { + console.log(this.#m); + console.log(this.#x = "test"); + } + #something = () => 1234; +} + + + +//// [privateNameFieldsESNext.js] +class C { + constructor() { + this.a = 123; + this.#a = 10; + this.c = "hello"; + this.#something = () => 1234; + } + #a; + #b; + method() { + console.log(this.#a); + this.#a = "hello"; + console.log(this.#b); + } + static #m; + static #x; + static test() { + console.log(this.#m); + console.log(this.#x = "test"); + } + #something; +} +C.#m = "test"; diff --git a/tests/baselines/reference/privateNameFieldsESNext(target=esnext).symbols b/tests/baselines/reference/privateNameFieldsESNext(target=esnext).symbols new file mode 100644 index 0000000000000..5ed63d12d2fef --- /dev/null +++ b/tests/baselines/reference/privateNameFieldsESNext(target=esnext).symbols @@ -0,0 +1,65 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts === +class C { +>C : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + + a = 123; +>a : Symbol(C.a, Decl(privateNameFieldsESNext.ts, 0, 9)) + + #a = 10; +>#a : Symbol(C.#a, Decl(privateNameFieldsESNext.ts, 1, 12)) + + c = "hello"; +>c : Symbol(C.c, Decl(privateNameFieldsESNext.ts, 2, 12)) + + #b; +>#b : Symbol(C.#b, Decl(privateNameFieldsESNext.ts, 3, 16)) + + method() { +>method : Symbol(C.method, Decl(privateNameFieldsESNext.ts, 4, 7)) + + console.log(this.#a); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>this.#a : Symbol(C.#a, Decl(privateNameFieldsESNext.ts, 1, 12)) +>this : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + + this.#a = "hello"; +>this.#a : Symbol(C.#a, Decl(privateNameFieldsESNext.ts, 1, 12)) +>this : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + + console.log(this.#b); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>this.#b : Symbol(C.#b, Decl(privateNameFieldsESNext.ts, 3, 16)) +>this : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + } + static #m = "test"; +>#m : Symbol(C.#m, Decl(privateNameFieldsESNext.ts, 9, 5)) + + static #x; +>#x : Symbol(C.#x, Decl(privateNameFieldsESNext.ts, 10, 23)) + + static test() { +>test : Symbol(C.test, Decl(privateNameFieldsESNext.ts, 11, 14)) + + console.log(this.#m); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>this.#m : Symbol(C.#m, Decl(privateNameFieldsESNext.ts, 9, 5)) +>this : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + + console.log(this.#x = "test"); +>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>console : Symbol(console, Decl(lib.dom.d.ts, --, --)) +>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --)) +>this.#x : Symbol(C.#x, Decl(privateNameFieldsESNext.ts, 10, 23)) +>this : Symbol(C, Decl(privateNameFieldsESNext.ts, 0, 0)) + } + #something = () => 1234; +>#something : Symbol(C.#something, Decl(privateNameFieldsESNext.ts, 15, 5)) +} + + diff --git a/tests/baselines/reference/privateNameFieldsESNext(target=esnext).types b/tests/baselines/reference/privateNameFieldsESNext(target=esnext).types new file mode 100644 index 0000000000000..8496622cbe357 --- /dev/null +++ b/tests/baselines/reference/privateNameFieldsESNext(target=esnext).types @@ -0,0 +1,79 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts === +class C { +>C : C + + a = 123; +>a : number +>123 : 123 + + #a = 10; +>#a : number +>10 : 10 + + c = "hello"; +>c : string +>"hello" : "hello" + + #b; +>#b : any + + method() { +>method : () => void + + console.log(this.#a); +>console.log(this.#a) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>this.#a : number +>this : this + + this.#a = "hello"; +>this.#a = "hello" : "hello" +>this.#a : number +>this : this +>"hello" : "hello" + + console.log(this.#b); +>console.log(this.#b) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>this.#b : any +>this : this + } + static #m = "test"; +>#m : string +>"test" : "test" + + static #x; +>#x : any + + static test() { +>test : () => void + + console.log(this.#m); +>console.log(this.#m) : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>this.#m : string +>this : typeof C + + console.log(this.#x = "test"); +>console.log(this.#x = "test") : void +>console.log : (...data: any[]) => void +>console : Console +>log : (...data: any[]) => void +>this.#x = "test" : "test" +>this.#x : any +>this : typeof C +>"test" : "test" + } + #something = () => 1234; +>#something : () => number +>() => 1234 : () => number +>1234 : 1234 +} + + diff --git a/tests/baselines/reference/privateNameInInExpression(target=es2022).errors.txt b/tests/baselines/reference/privateNameInInExpression(target=es2022).errors.txt new file mode 100644 index 0000000000000..d4ba5f81e9fdc --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpression(target=es2022).errors.txt @@ -0,0 +1,146 @@ +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(21,29): error TS2571: Object is of type 'unknown'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(23,19): error TS2304: Cannot find name '#fiel'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(23,19): error TS2339: Property '#fiel' does not exist on type 'any'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(25,20): error TS1451: Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(27,14): error TS1451: Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(27,14): error TS2406: The left-hand side of a 'for...in' statement must be a variable or a property access. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(29,23): error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type 'boolean'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(43,27): error TS2531: Object is possibly 'null'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(114,12): error TS18016: Private identifiers are not allowed outside class bodies. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts (9 errors) ==== + class Foo { + #field = 1; + static #staticField = 2; + #method() {} + static #staticMethod() {} + + goodRhs(v: any) { + const a = #field in v; + + const b = #field in v.p1.p2; + + const c = #field in (v as {}); + + const d = #field in (v as Foo); + + const e = #field in (v as never); + + for (let f in #field in v as any) { /**/ } // unlikely but valid + } + badRhs(v: any) { + const a = #field in (v as unknown); // Bad - RHS of in must be object type or any + ~~~~~~~~~~~~~~ +!!! error TS2571: Object is of type 'unknown'. + + const b = #fiel in v; // Bad - typo in privateID + ~~~~~ +!!! error TS2304: Cannot find name '#fiel'. + ~~~~~ +!!! error TS2339: Property '#fiel' does not exist on type 'any'. + + const c = (#field) in v; // Bad - privateID is not an expression on its own + ~~~~~~ +!!! error TS1451: Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression + + for (#field in v) { /**/ } // Bad - 'in' not allowed + ~~~~~~ +!!! error TS1451: Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression + ~~~~~~ +!!! error TS2406: The left-hand side of a 'for...in' statement must be a variable or a property access. + + for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any + ~~~~~~~~~~~ +!!! error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type 'boolean'. + } + whitespace(v: any) { + const a = v && /*0*/#field/*1*/ + /*2*/in/*3*/ + /*4*/v/*5*/ + } + flow(u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) { + + if (typeof u === 'object') { + if (#field in n) { + n; // good n is never + } + + if (#field in u) { + ~ +!!! error TS2531: Object is possibly 'null'. + u; // good u is Foo + } else { + u; // good u is object | null + } + + if (u !== null) { + if (#field in u) { + u; // good u is Foo + } else { + u; // good u is object + } + + if (#method in u) { + u; // good u is Foo + } + + if (#staticField in u) { + u; // good u is typeof Foo + } + + if (#staticMethod in u) { + u; // good u is typeof Foo + } + } + } + + if (#field in fb) { + fb; // good fb is Foo + } else { + fb; // good fb is Bar + } + + if (#field in fs) { + fs; // good fs is FooSub + } else { + fs; // good fs is never + } + + if (#field in b) { + b; // good b is 'Bar & Foo' + } else { + b; // good b is Bar + } + + if (#field in fsb) { + fsb; // good fsb is FooSub + } else { + fsb; // good fsb is Bar + } + + if (#field in fsfb) { + fsfb; // good fsfb is 'Foo | FooSub' + } else { + fsfb; // good fsfb is Bar + } + + class Nested { + m(v: any) { + if (#field in v) { + v; // good v is Foo + } + } + } + } + } + + class FooSub extends Foo { subTypeOfFoo = true } + class Bar { notFoo = true } + + function badSyntax(v: Foo) { + return #field in v; // Bad - outside of class + ~~~~~~ +!!! error TS18016: Private identifiers are not allowed outside class bodies. + } + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameInInExpression(target=es2022).js b/tests/baselines/reference/privateNameInInExpression(target=es2022).js new file mode 100644 index 0000000000000..a57d640c8d664 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpression(target=es2022).js @@ -0,0 +1,222 @@ +//// [privateNameInInExpression.ts] +class Foo { + #field = 1; + static #staticField = 2; + #method() {} + static #staticMethod() {} + + goodRhs(v: any) { + const a = #field in v; + + const b = #field in v.p1.p2; + + const c = #field in (v as {}); + + const d = #field in (v as Foo); + + const e = #field in (v as never); + + for (let f in #field in v as any) { /**/ } // unlikely but valid + } + badRhs(v: any) { + const a = #field in (v as unknown); // Bad - RHS of in must be object type or any + + const b = #fiel in v; // Bad - typo in privateID + + const c = (#field) in v; // Bad - privateID is not an expression on its own + + for (#field in v) { /**/ } // Bad - 'in' not allowed + + for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any + } + whitespace(v: any) { + const a = v && /*0*/#field/*1*/ + /*2*/in/*3*/ + /*4*/v/*5*/ + } + flow(u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) { + + if (typeof u === 'object') { + if (#field in n) { + n; // good n is never + } + + if (#field in u) { + u; // good u is Foo + } else { + u; // good u is object | null + } + + if (u !== null) { + if (#field in u) { + u; // good u is Foo + } else { + u; // good u is object + } + + if (#method in u) { + u; // good u is Foo + } + + if (#staticField in u) { + u; // good u is typeof Foo + } + + if (#staticMethod in u) { + u; // good u is typeof Foo + } + } + } + + if (#field in fb) { + fb; // good fb is Foo + } else { + fb; // good fb is Bar + } + + if (#field in fs) { + fs; // good fs is FooSub + } else { + fs; // good fs is never + } + + if (#field in b) { + b; // good b is 'Bar & Foo' + } else { + b; // good b is Bar + } + + if (#field in fsb) { + fsb; // good fsb is FooSub + } else { + fsb; // good fsb is Bar + } + + if (#field in fsfb) { + fsfb; // good fsfb is 'Foo | FooSub' + } else { + fsfb; // good fsfb is Bar + } + + class Nested { + m(v: any) { + if (#field in v) { + v; // good v is Foo + } + } + } + } +} + +class FooSub extends Foo { subTypeOfFoo = true } +class Bar { notFoo = true } + +function badSyntax(v: Foo) { + return #field in v; // Bad - outside of class +} + + +//// [privateNameInInExpression.js] +"use strict"; +class Foo { + #field = 1; + static #staticField = 2; + #method() { } + static #staticMethod() { } + goodRhs(v) { + const a = #field in v; + const b = #field in v.p1.p2; + const c = #field in v; + const d = #field in v; + const e = #field in v; + for (let f in #field in v) { /**/ } // unlikely but valid + } + badRhs(v) { + const a = #field in v; // Bad - RHS of in must be object type or any + const b = #fiel in v; // Bad - typo in privateID + const c = (#field) in v; // Bad - privateID is not an expression on its own + for (#field in v) { /**/ } // Bad - 'in' not allowed + for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any + } + whitespace(v) { + const a = v && /*0*/ #field /*1*/ + /*2*/ in /*3*/ + /*4*/ v; /*5*/ + } + flow(u, n, fb, fs, b, fsb, fsfb) { + if (typeof u === 'object') { + if (#field in n) { + n; // good n is never + } + if (#field in u) { + u; // good u is Foo + } + else { + u; // good u is object | null + } + if (u !== null) { + if (#field in u) { + u; // good u is Foo + } + else { + u; // good u is object + } + if (#method in u) { + u; // good u is Foo + } + if (#staticField in u) { + u; // good u is typeof Foo + } + if (#staticMethod in u) { + u; // good u is typeof Foo + } + } + } + if (#field in fb) { + fb; // good fb is Foo + } + else { + fb; // good fb is Bar + } + if (#field in fs) { + fs; // good fs is FooSub + } + else { + fs; // good fs is never + } + if (#field in b) { + b; // good b is 'Bar & Foo' + } + else { + b; // good b is Bar + } + if (#field in fsb) { + fsb; // good fsb is FooSub + } + else { + fsb; // good fsb is Bar + } + if (#field in fsfb) { + fsfb; // good fsfb is 'Foo | FooSub' + } + else { + fsfb; // good fsfb is Bar + } + class Nested { + m(v) { + if (#field in v) { + v; // good v is Foo + } + } + } + } +} +class FooSub extends Foo { + subTypeOfFoo = true; +} +class Bar { + notFoo = true; +} +function badSyntax(v) { + return #field in v; // Bad - outside of class +} diff --git a/tests/baselines/reference/privateNameInInExpression(target=es2022).symbols b/tests/baselines/reference/privateNameInInExpression(target=es2022).symbols new file mode 100644 index 0000000000000..2827e42d11150 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpression(target=es2022).symbols @@ -0,0 +1,269 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts === +class Foo { +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) + + #field = 1; +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) + + static #staticField = 2; +>#staticField : Symbol(Foo.#staticField, Decl(privateNameInInExpression.ts, 1, 15)) + + #method() {} +>#method : Symbol(Foo.#method, Decl(privateNameInInExpression.ts, 2, 28)) + + static #staticMethod() {} +>#staticMethod : Symbol(Foo.#staticMethod, Decl(privateNameInInExpression.ts, 3, 16)) + + goodRhs(v: any) { +>goodRhs : Symbol(Foo.goodRhs, Decl(privateNameInInExpression.ts, 4, 29)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + + const a = #field in v; +>a : Symbol(a, Decl(privateNameInInExpression.ts, 7, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + + const b = #field in v.p1.p2; +>b : Symbol(b, Decl(privateNameInInExpression.ts, 9, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + + const c = #field in (v as {}); +>c : Symbol(c, Decl(privateNameInInExpression.ts, 11, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + + const d = #field in (v as Foo); +>d : Symbol(d, Decl(privateNameInInExpression.ts, 13, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) + + const e = #field in (v as never); +>e : Symbol(e, Decl(privateNameInInExpression.ts, 15, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + + for (let f in #field in v as any) { /**/ } // unlikely but valid +>f : Symbol(f, Decl(privateNameInInExpression.ts, 17, 16)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + } + badRhs(v: any) { +>badRhs : Symbol(Foo.badRhs, Decl(privateNameInInExpression.ts, 18, 5)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + + const a = #field in (v as unknown); // Bad - RHS of in must be object type or any +>a : Symbol(a, Decl(privateNameInInExpression.ts, 20, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + + const b = #fiel in v; // Bad - typo in privateID +>b : Symbol(b, Decl(privateNameInInExpression.ts, 22, 13)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + + const c = (#field) in v; // Bad - privateID is not an expression on its own +>c : Symbol(c, Decl(privateNameInInExpression.ts, 24, 13)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + + for (#field in v) { /**/ } // Bad - 'in' not allowed +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + + for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any +>d : Symbol(d, Decl(privateNameInInExpression.ts, 28, 16)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + } + whitespace(v: any) { +>whitespace : Symbol(Foo.whitespace, Decl(privateNameInInExpression.ts, 29, 5)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 30, 15)) + + const a = v && /*0*/#field/*1*/ +>a : Symbol(a, Decl(privateNameInInExpression.ts, 31, 13)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 30, 15)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) + + /*2*/in/*3*/ + /*4*/v/*5*/ +>v : Symbol(v, Decl(privateNameInInExpression.ts, 30, 15)) + } + flow(u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) { +>flow : Symbol(Foo.flow, Decl(privateNameInInExpression.ts, 34, 5)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) +>n : Symbol(n, Decl(privateNameInInExpression.ts, 35, 20)) +>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30)) +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) +>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48)) +>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45)) +>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1)) +>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57)) +>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48)) +>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65)) +>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1)) +>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48)) +>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84)) +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) +>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1)) +>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48)) + + if (typeof u === 'object') { +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + if (#field in n) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>n : Symbol(n, Decl(privateNameInInExpression.ts, 35, 20)) + + n; // good n is never +>n : Symbol(n, Decl(privateNameInInExpression.ts, 35, 20)) + } + + if (#field in u) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + u; // good u is Foo +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + } else { + u; // good u is object | null +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + } + + if (u !== null) { +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + if (#field in u) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + u; // good u is Foo +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + } else { + u; // good u is object +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + } + + if (#method in u) { +>#method : Symbol(Foo.#method, Decl(privateNameInInExpression.ts, 2, 28)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + u; // good u is Foo +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + } + + if (#staticField in u) { +>#staticField : Symbol(Foo.#staticField, Decl(privateNameInInExpression.ts, 1, 15)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + u; // good u is typeof Foo +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + } + + if (#staticMethod in u) { +>#staticMethod : Symbol(Foo.#staticMethod, Decl(privateNameInInExpression.ts, 3, 16)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + u; // good u is typeof Foo +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + } + } + } + + if (#field in fb) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30)) + + fb; // good fb is Foo +>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30)) + + } else { + fb; // good fb is Bar +>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30)) + } + + if (#field in fs) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45)) + + fs; // good fs is FooSub +>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45)) + + } else { + fs; // good fs is never +>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45)) + } + + if (#field in b) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57)) + + b; // good b is 'Bar & Foo' +>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57)) + + } else { + b; // good b is Bar +>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57)) + } + + if (#field in fsb) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65)) + + fsb; // good fsb is FooSub +>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65)) + + } else { + fsb; // good fsb is Bar +>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65)) + } + + if (#field in fsfb) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84)) + + fsfb; // good fsfb is 'Foo | FooSub' +>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84)) + + } else { + fsfb; // good fsfb is Bar +>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84)) + } + + class Nested { +>Nested : Symbol(Nested, Decl(privateNameInInExpression.ts, 97, 9)) + + m(v: any) { +>m : Symbol(Nested.m, Decl(privateNameInInExpression.ts, 99, 22)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 100, 14)) + + if (#field in v) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 100, 14)) + + v; // good v is Foo +>v : Symbol(v, Decl(privateNameInInExpression.ts, 100, 14)) + } + } + } + } +} + +class FooSub extends Foo { subTypeOfFoo = true } +>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1)) +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) +>subTypeOfFoo : Symbol(FooSub.subTypeOfFoo, Decl(privateNameInInExpression.ts, 109, 26)) + +class Bar { notFoo = true } +>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48)) +>notFoo : Symbol(Bar.notFoo, Decl(privateNameInInExpression.ts, 110, 11)) + +function badSyntax(v: Foo) { +>badSyntax : Symbol(badSyntax, Decl(privateNameInInExpression.ts, 110, 27)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 112, 19)) +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) + + return #field in v; // Bad - outside of class +>v : Symbol(v, Decl(privateNameInInExpression.ts, 112, 19)) +} + diff --git a/tests/baselines/reference/privateNameInInExpression(target=es2022).types b/tests/baselines/reference/privateNameInInExpression(target=es2022).types new file mode 100644 index 0000000000000..af1ce8a754f1c --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpression(target=es2022).types @@ -0,0 +1,308 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts === +class Foo { +>Foo : Foo + + #field = 1; +>#field : number +>1 : 1 + + static #staticField = 2; +>#staticField : number +>2 : 2 + + #method() {} +>#method : () => void + + static #staticMethod() {} +>#staticMethod : () => void + + goodRhs(v: any) { +>goodRhs : (v: any) => void +>v : any + + const a = #field in v; +>a : boolean +>#field in v : boolean +>#field : any +>v : any + + const b = #field in v.p1.p2; +>b : boolean +>#field in v.p1.p2 : boolean +>#field : any +>v.p1.p2 : any +>v.p1 : any +>v : any +>p1 : any +>p2 : any + + const c = #field in (v as {}); +>c : boolean +>#field in (v as {}) : boolean +>#field : any +>(v as {}) : {} +>v as {} : {} +>v : any + + const d = #field in (v as Foo); +>d : boolean +>#field in (v as Foo) : boolean +>#field : any +>(v as Foo) : Foo +>v as Foo : Foo +>v : any + + const e = #field in (v as never); +>e : boolean +>#field in (v as never) : boolean +>#field : any +>(v as never) : never +>v as never : never +>v : any + + for (let f in #field in v as any) { /**/ } // unlikely but valid +>f : string +>#field in v as any : any +>#field in v : boolean +>#field : any +>v : any + } + badRhs(v: any) { +>badRhs : (v: any) => void +>v : any + + const a = #field in (v as unknown); // Bad - RHS of in must be object type or any +>a : boolean +>#field in (v as unknown) : boolean +>#field : any +>(v as unknown) : unknown +>v as unknown : unknown +>v : any + + const b = #fiel in v; // Bad - typo in privateID +>b : boolean +>#fiel in v : boolean +>#fiel : any +>v : any + + const c = (#field) in v; // Bad - privateID is not an expression on its own +>c : boolean +>(#field) in v : boolean +>(#field) : any +>v : any + + for (#field in v) { /**/ } // Bad - 'in' not allowed +>v : any + + for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any +>d : string +>#field in v : boolean +>#field : any +>v : any + } + whitespace(v: any) { +>whitespace : (v: any) => void +>v : any + + const a = v && /*0*/#field/*1*/ +>a : any +>v && /*0*/#field/*1*/ /*2*/in/*3*/ /*4*/v : any +>v : any +>#field/*1*/ /*2*/in/*3*/ /*4*/v : boolean +>#field : any + + /*2*/in/*3*/ + /*4*/v/*5*/ +>v : any + } + flow(u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) { +>flow : (u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) => void +>u : unknown +>n : never +>fb : Foo | Bar +>fs : FooSub +>b : Bar +>fsb : Bar | FooSub +>fsfb : Foo | Bar | FooSub + + if (typeof u === 'object') { +>typeof u === 'object' : boolean +>typeof u : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>u : unknown +>'object' : "object" + + if (#field in n) { +>#field in n : boolean +>#field : any +>n : never + + n; // good n is never +>n : never + } + + if (#field in u) { +>#field in u : boolean +>#field : any +>u : object | null + + u; // good u is Foo +>u : Foo + + } else { + u; // good u is object | null +>u : object | null + } + + if (u !== null) { +>u !== null : boolean +>u : object | null +>null : null + + if (#field in u) { +>#field in u : boolean +>#field : any +>u : object + + u; // good u is Foo +>u : Foo + + } else { + u; // good u is object +>u : object + } + + if (#method in u) { +>#method in u : boolean +>#method : any +>u : object + + u; // good u is Foo +>u : Foo + } + + if (#staticField in u) { +>#staticField in u : boolean +>#staticField : any +>u : object + + u; // good u is typeof Foo +>u : typeof Foo + } + + if (#staticMethod in u) { +>#staticMethod in u : boolean +>#staticMethod : any +>u : object + + u; // good u is typeof Foo +>u : typeof Foo + } + } + } + + if (#field in fb) { +>#field in fb : boolean +>#field : any +>fb : Foo | Bar + + fb; // good fb is Foo +>fb : Foo + + } else { + fb; // good fb is Bar +>fb : Bar + } + + if (#field in fs) { +>#field in fs : boolean +>#field : any +>fs : FooSub + + fs; // good fs is FooSub +>fs : FooSub + + } else { + fs; // good fs is never +>fs : never + } + + if (#field in b) { +>#field in b : boolean +>#field : any +>b : Bar + + b; // good b is 'Bar & Foo' +>b : Bar & Foo + + } else { + b; // good b is Bar +>b : Bar + } + + if (#field in fsb) { +>#field in fsb : boolean +>#field : any +>fsb : Bar | FooSub + + fsb; // good fsb is FooSub +>fsb : FooSub + + } else { + fsb; // good fsb is Bar +>fsb : Bar + } + + if (#field in fsfb) { +>#field in fsfb : boolean +>#field : any +>fsfb : Foo | Bar | FooSub + + fsfb; // good fsfb is 'Foo | FooSub' +>fsfb : Foo | FooSub + + } else { + fsfb; // good fsfb is Bar +>fsfb : Bar + } + + class Nested { +>Nested : Nested + + m(v: any) { +>m : (v: any) => void +>v : any + + if (#field in v) { +>#field in v : boolean +>#field : any +>v : any + + v; // good v is Foo +>v : Foo + } + } + } + } +} + +class FooSub extends Foo { subTypeOfFoo = true } +>FooSub : FooSub +>Foo : Foo +>subTypeOfFoo : boolean +>true : true + +class Bar { notFoo = true } +>Bar : Bar +>notFoo : boolean +>true : true + +function badSyntax(v: Foo) { +>badSyntax : (v: Foo) => boolean +>v : Foo + + return #field in v; // Bad - outside of class +>#field in v : boolean +>#field : any +>v : Foo +} + diff --git a/tests/baselines/reference/privateNameInInExpression(target=esnext).errors.txt b/tests/baselines/reference/privateNameInInExpression(target=esnext).errors.txt new file mode 100644 index 0000000000000..d4ba5f81e9fdc --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpression(target=esnext).errors.txt @@ -0,0 +1,146 @@ +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(21,29): error TS2571: Object is of type 'unknown'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(23,19): error TS2304: Cannot find name '#fiel'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(23,19): error TS2339: Property '#fiel' does not exist on type 'any'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(25,20): error TS1451: Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(27,14): error TS1451: Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(27,14): error TS2406: The left-hand side of a 'for...in' statement must be a variable or a property access. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(29,23): error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type 'boolean'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(43,27): error TS2531: Object is possibly 'null'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(114,12): error TS18016: Private identifiers are not allowed outside class bodies. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts (9 errors) ==== + class Foo { + #field = 1; + static #staticField = 2; + #method() {} + static #staticMethod() {} + + goodRhs(v: any) { + const a = #field in v; + + const b = #field in v.p1.p2; + + const c = #field in (v as {}); + + const d = #field in (v as Foo); + + const e = #field in (v as never); + + for (let f in #field in v as any) { /**/ } // unlikely but valid + } + badRhs(v: any) { + const a = #field in (v as unknown); // Bad - RHS of in must be object type or any + ~~~~~~~~~~~~~~ +!!! error TS2571: Object is of type 'unknown'. + + const b = #fiel in v; // Bad - typo in privateID + ~~~~~ +!!! error TS2304: Cannot find name '#fiel'. + ~~~~~ +!!! error TS2339: Property '#fiel' does not exist on type 'any'. + + const c = (#field) in v; // Bad - privateID is not an expression on its own + ~~~~~~ +!!! error TS1451: Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression + + for (#field in v) { /**/ } // Bad - 'in' not allowed + ~~~~~~ +!!! error TS1451: Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression + ~~~~~~ +!!! error TS2406: The left-hand side of a 'for...in' statement must be a variable or a property access. + + for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any + ~~~~~~~~~~~ +!!! error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type 'boolean'. + } + whitespace(v: any) { + const a = v && /*0*/#field/*1*/ + /*2*/in/*3*/ + /*4*/v/*5*/ + } + flow(u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) { + + if (typeof u === 'object') { + if (#field in n) { + n; // good n is never + } + + if (#field in u) { + ~ +!!! error TS2531: Object is possibly 'null'. + u; // good u is Foo + } else { + u; // good u is object | null + } + + if (u !== null) { + if (#field in u) { + u; // good u is Foo + } else { + u; // good u is object + } + + if (#method in u) { + u; // good u is Foo + } + + if (#staticField in u) { + u; // good u is typeof Foo + } + + if (#staticMethod in u) { + u; // good u is typeof Foo + } + } + } + + if (#field in fb) { + fb; // good fb is Foo + } else { + fb; // good fb is Bar + } + + if (#field in fs) { + fs; // good fs is FooSub + } else { + fs; // good fs is never + } + + if (#field in b) { + b; // good b is 'Bar & Foo' + } else { + b; // good b is Bar + } + + if (#field in fsb) { + fsb; // good fsb is FooSub + } else { + fsb; // good fsb is Bar + } + + if (#field in fsfb) { + fsfb; // good fsfb is 'Foo | FooSub' + } else { + fsfb; // good fsfb is Bar + } + + class Nested { + m(v: any) { + if (#field in v) { + v; // good v is Foo + } + } + } + } + } + + class FooSub extends Foo { subTypeOfFoo = true } + class Bar { notFoo = true } + + function badSyntax(v: Foo) { + return #field in v; // Bad - outside of class + ~~~~~~ +!!! error TS18016: Private identifiers are not allowed outside class bodies. + } + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameInInExpression(target=esnext).js b/tests/baselines/reference/privateNameInInExpression(target=esnext).js new file mode 100644 index 0000000000000..a57d640c8d664 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpression(target=esnext).js @@ -0,0 +1,222 @@ +//// [privateNameInInExpression.ts] +class Foo { + #field = 1; + static #staticField = 2; + #method() {} + static #staticMethod() {} + + goodRhs(v: any) { + const a = #field in v; + + const b = #field in v.p1.p2; + + const c = #field in (v as {}); + + const d = #field in (v as Foo); + + const e = #field in (v as never); + + for (let f in #field in v as any) { /**/ } // unlikely but valid + } + badRhs(v: any) { + const a = #field in (v as unknown); // Bad - RHS of in must be object type or any + + const b = #fiel in v; // Bad - typo in privateID + + const c = (#field) in v; // Bad - privateID is not an expression on its own + + for (#field in v) { /**/ } // Bad - 'in' not allowed + + for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any + } + whitespace(v: any) { + const a = v && /*0*/#field/*1*/ + /*2*/in/*3*/ + /*4*/v/*5*/ + } + flow(u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) { + + if (typeof u === 'object') { + if (#field in n) { + n; // good n is never + } + + if (#field in u) { + u; // good u is Foo + } else { + u; // good u is object | null + } + + if (u !== null) { + if (#field in u) { + u; // good u is Foo + } else { + u; // good u is object + } + + if (#method in u) { + u; // good u is Foo + } + + if (#staticField in u) { + u; // good u is typeof Foo + } + + if (#staticMethod in u) { + u; // good u is typeof Foo + } + } + } + + if (#field in fb) { + fb; // good fb is Foo + } else { + fb; // good fb is Bar + } + + if (#field in fs) { + fs; // good fs is FooSub + } else { + fs; // good fs is never + } + + if (#field in b) { + b; // good b is 'Bar & Foo' + } else { + b; // good b is Bar + } + + if (#field in fsb) { + fsb; // good fsb is FooSub + } else { + fsb; // good fsb is Bar + } + + if (#field in fsfb) { + fsfb; // good fsfb is 'Foo | FooSub' + } else { + fsfb; // good fsfb is Bar + } + + class Nested { + m(v: any) { + if (#field in v) { + v; // good v is Foo + } + } + } + } +} + +class FooSub extends Foo { subTypeOfFoo = true } +class Bar { notFoo = true } + +function badSyntax(v: Foo) { + return #field in v; // Bad - outside of class +} + + +//// [privateNameInInExpression.js] +"use strict"; +class Foo { + #field = 1; + static #staticField = 2; + #method() { } + static #staticMethod() { } + goodRhs(v) { + const a = #field in v; + const b = #field in v.p1.p2; + const c = #field in v; + const d = #field in v; + const e = #field in v; + for (let f in #field in v) { /**/ } // unlikely but valid + } + badRhs(v) { + const a = #field in v; // Bad - RHS of in must be object type or any + const b = #fiel in v; // Bad - typo in privateID + const c = (#field) in v; // Bad - privateID is not an expression on its own + for (#field in v) { /**/ } // Bad - 'in' not allowed + for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any + } + whitespace(v) { + const a = v && /*0*/ #field /*1*/ + /*2*/ in /*3*/ + /*4*/ v; /*5*/ + } + flow(u, n, fb, fs, b, fsb, fsfb) { + if (typeof u === 'object') { + if (#field in n) { + n; // good n is never + } + if (#field in u) { + u; // good u is Foo + } + else { + u; // good u is object | null + } + if (u !== null) { + if (#field in u) { + u; // good u is Foo + } + else { + u; // good u is object + } + if (#method in u) { + u; // good u is Foo + } + if (#staticField in u) { + u; // good u is typeof Foo + } + if (#staticMethod in u) { + u; // good u is typeof Foo + } + } + } + if (#field in fb) { + fb; // good fb is Foo + } + else { + fb; // good fb is Bar + } + if (#field in fs) { + fs; // good fs is FooSub + } + else { + fs; // good fs is never + } + if (#field in b) { + b; // good b is 'Bar & Foo' + } + else { + b; // good b is Bar + } + if (#field in fsb) { + fsb; // good fsb is FooSub + } + else { + fsb; // good fsb is Bar + } + if (#field in fsfb) { + fsfb; // good fsfb is 'Foo | FooSub' + } + else { + fsfb; // good fsfb is Bar + } + class Nested { + m(v) { + if (#field in v) { + v; // good v is Foo + } + } + } + } +} +class FooSub extends Foo { + subTypeOfFoo = true; +} +class Bar { + notFoo = true; +} +function badSyntax(v) { + return #field in v; // Bad - outside of class +} diff --git a/tests/baselines/reference/privateNameInInExpression(target=esnext).symbols b/tests/baselines/reference/privateNameInInExpression(target=esnext).symbols new file mode 100644 index 0000000000000..2827e42d11150 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpression(target=esnext).symbols @@ -0,0 +1,269 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts === +class Foo { +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) + + #field = 1; +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) + + static #staticField = 2; +>#staticField : Symbol(Foo.#staticField, Decl(privateNameInInExpression.ts, 1, 15)) + + #method() {} +>#method : Symbol(Foo.#method, Decl(privateNameInInExpression.ts, 2, 28)) + + static #staticMethod() {} +>#staticMethod : Symbol(Foo.#staticMethod, Decl(privateNameInInExpression.ts, 3, 16)) + + goodRhs(v: any) { +>goodRhs : Symbol(Foo.goodRhs, Decl(privateNameInInExpression.ts, 4, 29)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + + const a = #field in v; +>a : Symbol(a, Decl(privateNameInInExpression.ts, 7, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + + const b = #field in v.p1.p2; +>b : Symbol(b, Decl(privateNameInInExpression.ts, 9, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + + const c = #field in (v as {}); +>c : Symbol(c, Decl(privateNameInInExpression.ts, 11, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + + const d = #field in (v as Foo); +>d : Symbol(d, Decl(privateNameInInExpression.ts, 13, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) + + const e = #field in (v as never); +>e : Symbol(e, Decl(privateNameInInExpression.ts, 15, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + + for (let f in #field in v as any) { /**/ } // unlikely but valid +>f : Symbol(f, Decl(privateNameInInExpression.ts, 17, 16)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 6, 12)) + } + badRhs(v: any) { +>badRhs : Symbol(Foo.badRhs, Decl(privateNameInInExpression.ts, 18, 5)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + + const a = #field in (v as unknown); // Bad - RHS of in must be object type or any +>a : Symbol(a, Decl(privateNameInInExpression.ts, 20, 13)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + + const b = #fiel in v; // Bad - typo in privateID +>b : Symbol(b, Decl(privateNameInInExpression.ts, 22, 13)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + + const c = (#field) in v; // Bad - privateID is not an expression on its own +>c : Symbol(c, Decl(privateNameInInExpression.ts, 24, 13)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + + for (#field in v) { /**/ } // Bad - 'in' not allowed +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + + for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any +>d : Symbol(d, Decl(privateNameInInExpression.ts, 28, 16)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 19, 11)) + } + whitespace(v: any) { +>whitespace : Symbol(Foo.whitespace, Decl(privateNameInInExpression.ts, 29, 5)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 30, 15)) + + const a = v && /*0*/#field/*1*/ +>a : Symbol(a, Decl(privateNameInInExpression.ts, 31, 13)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 30, 15)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) + + /*2*/in/*3*/ + /*4*/v/*5*/ +>v : Symbol(v, Decl(privateNameInInExpression.ts, 30, 15)) + } + flow(u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) { +>flow : Symbol(Foo.flow, Decl(privateNameInInExpression.ts, 34, 5)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) +>n : Symbol(n, Decl(privateNameInInExpression.ts, 35, 20)) +>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30)) +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) +>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48)) +>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45)) +>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1)) +>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57)) +>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48)) +>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65)) +>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1)) +>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48)) +>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84)) +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) +>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1)) +>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48)) + + if (typeof u === 'object') { +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + if (#field in n) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>n : Symbol(n, Decl(privateNameInInExpression.ts, 35, 20)) + + n; // good n is never +>n : Symbol(n, Decl(privateNameInInExpression.ts, 35, 20)) + } + + if (#field in u) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + u; // good u is Foo +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + } else { + u; // good u is object | null +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + } + + if (u !== null) { +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + if (#field in u) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + u; // good u is Foo +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + } else { + u; // good u is object +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + } + + if (#method in u) { +>#method : Symbol(Foo.#method, Decl(privateNameInInExpression.ts, 2, 28)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + u; // good u is Foo +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + } + + if (#staticField in u) { +>#staticField : Symbol(Foo.#staticField, Decl(privateNameInInExpression.ts, 1, 15)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + u; // good u is typeof Foo +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + } + + if (#staticMethod in u) { +>#staticMethod : Symbol(Foo.#staticMethod, Decl(privateNameInInExpression.ts, 3, 16)) +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + + u; // good u is typeof Foo +>u : Symbol(u, Decl(privateNameInInExpression.ts, 35, 9)) + } + } + } + + if (#field in fb) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30)) + + fb; // good fb is Foo +>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30)) + + } else { + fb; // good fb is Bar +>fb : Symbol(fb, Decl(privateNameInInExpression.ts, 35, 30)) + } + + if (#field in fs) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45)) + + fs; // good fs is FooSub +>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45)) + + } else { + fs; // good fs is never +>fs : Symbol(fs, Decl(privateNameInInExpression.ts, 35, 45)) + } + + if (#field in b) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57)) + + b; // good b is 'Bar & Foo' +>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57)) + + } else { + b; // good b is Bar +>b : Symbol(b, Decl(privateNameInInExpression.ts, 35, 57)) + } + + if (#field in fsb) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65)) + + fsb; // good fsb is FooSub +>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65)) + + } else { + fsb; // good fsb is Bar +>fsb : Symbol(fsb, Decl(privateNameInInExpression.ts, 35, 65)) + } + + if (#field in fsfb) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84)) + + fsfb; // good fsfb is 'Foo | FooSub' +>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84)) + + } else { + fsfb; // good fsfb is Bar +>fsfb : Symbol(fsfb, Decl(privateNameInInExpression.ts, 35, 84)) + } + + class Nested { +>Nested : Symbol(Nested, Decl(privateNameInInExpression.ts, 97, 9)) + + m(v: any) { +>m : Symbol(Nested.m, Decl(privateNameInInExpression.ts, 99, 22)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 100, 14)) + + if (#field in v) { +>#field : Symbol(Foo.#field, Decl(privateNameInInExpression.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 100, 14)) + + v; // good v is Foo +>v : Symbol(v, Decl(privateNameInInExpression.ts, 100, 14)) + } + } + } + } +} + +class FooSub extends Foo { subTypeOfFoo = true } +>FooSub : Symbol(FooSub, Decl(privateNameInInExpression.ts, 107, 1)) +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) +>subTypeOfFoo : Symbol(FooSub.subTypeOfFoo, Decl(privateNameInInExpression.ts, 109, 26)) + +class Bar { notFoo = true } +>Bar : Symbol(Bar, Decl(privateNameInInExpression.ts, 109, 48)) +>notFoo : Symbol(Bar.notFoo, Decl(privateNameInInExpression.ts, 110, 11)) + +function badSyntax(v: Foo) { +>badSyntax : Symbol(badSyntax, Decl(privateNameInInExpression.ts, 110, 27)) +>v : Symbol(v, Decl(privateNameInInExpression.ts, 112, 19)) +>Foo : Symbol(Foo, Decl(privateNameInInExpression.ts, 0, 0)) + + return #field in v; // Bad - outside of class +>v : Symbol(v, Decl(privateNameInInExpression.ts, 112, 19)) +} + diff --git a/tests/baselines/reference/privateNameInInExpression(target=esnext).types b/tests/baselines/reference/privateNameInInExpression(target=esnext).types new file mode 100644 index 0000000000000..af1ce8a754f1c --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpression(target=esnext).types @@ -0,0 +1,308 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts === +class Foo { +>Foo : Foo + + #field = 1; +>#field : number +>1 : 1 + + static #staticField = 2; +>#staticField : number +>2 : 2 + + #method() {} +>#method : () => void + + static #staticMethod() {} +>#staticMethod : () => void + + goodRhs(v: any) { +>goodRhs : (v: any) => void +>v : any + + const a = #field in v; +>a : boolean +>#field in v : boolean +>#field : any +>v : any + + const b = #field in v.p1.p2; +>b : boolean +>#field in v.p1.p2 : boolean +>#field : any +>v.p1.p2 : any +>v.p1 : any +>v : any +>p1 : any +>p2 : any + + const c = #field in (v as {}); +>c : boolean +>#field in (v as {}) : boolean +>#field : any +>(v as {}) : {} +>v as {} : {} +>v : any + + const d = #field in (v as Foo); +>d : boolean +>#field in (v as Foo) : boolean +>#field : any +>(v as Foo) : Foo +>v as Foo : Foo +>v : any + + const e = #field in (v as never); +>e : boolean +>#field in (v as never) : boolean +>#field : any +>(v as never) : never +>v as never : never +>v : any + + for (let f in #field in v as any) { /**/ } // unlikely but valid +>f : string +>#field in v as any : any +>#field in v : boolean +>#field : any +>v : any + } + badRhs(v: any) { +>badRhs : (v: any) => void +>v : any + + const a = #field in (v as unknown); // Bad - RHS of in must be object type or any +>a : boolean +>#field in (v as unknown) : boolean +>#field : any +>(v as unknown) : unknown +>v as unknown : unknown +>v : any + + const b = #fiel in v; // Bad - typo in privateID +>b : boolean +>#fiel in v : boolean +>#fiel : any +>v : any + + const c = (#field) in v; // Bad - privateID is not an expression on its own +>c : boolean +>(#field) in v : boolean +>(#field) : any +>v : any + + for (#field in v) { /**/ } // Bad - 'in' not allowed +>v : any + + for (let d in #field in v) { /**/ } // Bad - rhs of in should be a object/any +>d : string +>#field in v : boolean +>#field : any +>v : any + } + whitespace(v: any) { +>whitespace : (v: any) => void +>v : any + + const a = v && /*0*/#field/*1*/ +>a : any +>v && /*0*/#field/*1*/ /*2*/in/*3*/ /*4*/v : any +>v : any +>#field/*1*/ /*2*/in/*3*/ /*4*/v : boolean +>#field : any + + /*2*/in/*3*/ + /*4*/v/*5*/ +>v : any + } + flow(u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) { +>flow : (u: unknown, n: never, fb: Foo | Bar, fs: FooSub, b: Bar, fsb: FooSub | Bar, fsfb: Foo | FooSub | Bar) => void +>u : unknown +>n : never +>fb : Foo | Bar +>fs : FooSub +>b : Bar +>fsb : Bar | FooSub +>fsfb : Foo | Bar | FooSub + + if (typeof u === 'object') { +>typeof u === 'object' : boolean +>typeof u : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>u : unknown +>'object' : "object" + + if (#field in n) { +>#field in n : boolean +>#field : any +>n : never + + n; // good n is never +>n : never + } + + if (#field in u) { +>#field in u : boolean +>#field : any +>u : object | null + + u; // good u is Foo +>u : Foo + + } else { + u; // good u is object | null +>u : object | null + } + + if (u !== null) { +>u !== null : boolean +>u : object | null +>null : null + + if (#field in u) { +>#field in u : boolean +>#field : any +>u : object + + u; // good u is Foo +>u : Foo + + } else { + u; // good u is object +>u : object + } + + if (#method in u) { +>#method in u : boolean +>#method : any +>u : object + + u; // good u is Foo +>u : Foo + } + + if (#staticField in u) { +>#staticField in u : boolean +>#staticField : any +>u : object + + u; // good u is typeof Foo +>u : typeof Foo + } + + if (#staticMethod in u) { +>#staticMethod in u : boolean +>#staticMethod : any +>u : object + + u; // good u is typeof Foo +>u : typeof Foo + } + } + } + + if (#field in fb) { +>#field in fb : boolean +>#field : any +>fb : Foo | Bar + + fb; // good fb is Foo +>fb : Foo + + } else { + fb; // good fb is Bar +>fb : Bar + } + + if (#field in fs) { +>#field in fs : boolean +>#field : any +>fs : FooSub + + fs; // good fs is FooSub +>fs : FooSub + + } else { + fs; // good fs is never +>fs : never + } + + if (#field in b) { +>#field in b : boolean +>#field : any +>b : Bar + + b; // good b is 'Bar & Foo' +>b : Bar & Foo + + } else { + b; // good b is Bar +>b : Bar + } + + if (#field in fsb) { +>#field in fsb : boolean +>#field : any +>fsb : Bar | FooSub + + fsb; // good fsb is FooSub +>fsb : FooSub + + } else { + fsb; // good fsb is Bar +>fsb : Bar + } + + if (#field in fsfb) { +>#field in fsfb : boolean +>#field : any +>fsfb : Foo | Bar | FooSub + + fsfb; // good fsfb is 'Foo | FooSub' +>fsfb : Foo | FooSub + + } else { + fsfb; // good fsfb is Bar +>fsfb : Bar + } + + class Nested { +>Nested : Nested + + m(v: any) { +>m : (v: any) => void +>v : any + + if (#field in v) { +>#field in v : boolean +>#field : any +>v : any + + v; // good v is Foo +>v : Foo + } + } + } + } +} + +class FooSub extends Foo { subTypeOfFoo = true } +>FooSub : FooSub +>Foo : Foo +>subTypeOfFoo : boolean +>true : true + +class Bar { notFoo = true } +>Bar : Bar +>notFoo : boolean +>true : true + +function badSyntax(v: Foo) { +>badSyntax : (v: Foo) => boolean +>v : Foo + + return #field in v; // Bad - outside of class +>#field in v : boolean +>#field : any +>v : Foo +} + diff --git a/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).errors.txt b/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).errors.txt new file mode 100644 index 0000000000000..1d00c96fac064 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).errors.txt @@ -0,0 +1,61 @@ +tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(20,24): error TS2361: The right-hand side of an 'in' expression must not be a primitive. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(24,14): error TS2360: The left-hand side of an 'in' expression must be a private identifier or of type 'any', 'string', 'number', or 'symbol'. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(29,21): error TS1005: ';' expected. +tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts(30,21): error TS1005: ';' expected. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts (4 errors) ==== + class Foo { + #field = 1; + #method() {} + static #staticField= 2; + static #staticMethod() {} + + check(v: any) { + #field in v; // expect Foo's 'field' WeakMap + #method in v; // expect Foo's 'instances' WeakSet + #staticField in v; // expect Foo's constructor + #staticMethod in v; // expect Foo's constructor + } + precedence(v: any) { + // '==' and '||' have lower precedence than 'in' + // 'in' naturally has same precedence as 'in' + // '<<' has higher precedence than 'in' + + v == #field in v || v; // Good precedence: (v == (#field in v)) || v + + v << #field in v << v; // Good precedence (SyntaxError): (v << #field) in (v << v) + ~~~~~~ +!!! error TS2361: The right-hand side of an 'in' expression must not be a primitive. + + v << #field in v == v; // Good precedence (SyntaxError): ((v << #field) in v) == v + + v == #field in v in v; // Good precedence: v == ((#field in v) in v) + ~~~~~~~~~~~ +!!! error TS2360: The left-hand side of an 'in' expression must be a private identifier or of type 'any', 'string', 'number', or 'symbol'. + + #field in v && #field in v; // Good precedence: (#field in v) && (#field in v) + } + invalidLHS(v: any) { + 'prop' in v = 10; + ~ +!!! error TS1005: ';' expected. + #field in v = 10; + ~ +!!! error TS1005: ';' expected. + } + } + + class Bar { + #field = 1; + check(v: any) { + #field in v; // expect Bar's 'field' WeakMap + } + } + + function syntaxError(v: Foo) { + return #field in v; // expect `return in v` so runtime will have a syntax error + } + + export { } + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).js b/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).js new file mode 100644 index 0000000000000..50a91a840e5b2 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).js @@ -0,0 +1,87 @@ +//// [privateNameInInExpressionTransform.ts] +class Foo { + #field = 1; + #method() {} + static #staticField= 2; + static #staticMethod() {} + + check(v: any) { + #field in v; // expect Foo's 'field' WeakMap + #method in v; // expect Foo's 'instances' WeakSet + #staticField in v; // expect Foo's constructor + #staticMethod in v; // expect Foo's constructor + } + precedence(v: any) { + // '==' and '||' have lower precedence than 'in' + // 'in' naturally has same precedence as 'in' + // '<<' has higher precedence than 'in' + + v == #field in v || v; // Good precedence: (v == (#field in v)) || v + + v << #field in v << v; // Good precedence (SyntaxError): (v << #field) in (v << v) + + v << #field in v == v; // Good precedence (SyntaxError): ((v << #field) in v) == v + + v == #field in v in v; // Good precedence: v == ((#field in v) in v) + + #field in v && #field in v; // Good precedence: (#field in v) && (#field in v) + } + invalidLHS(v: any) { + 'prop' in v = 10; + #field in v = 10; + } +} + +class Bar { + #field = 1; + check(v: any) { + #field in v; // expect Bar's 'field' WeakMap + } +} + +function syntaxError(v: Foo) { + return #field in v; // expect `return in v` so runtime will have a syntax error +} + +export { } + + +//// [privateNameInInExpressionTransform.js] +class Foo { + #field = 1; + #method() { } + static #staticField = 2; + static #staticMethod() { } + check(v) { + #field in v; // expect Foo's 'field' WeakMap + #method in v; // expect Foo's 'instances' WeakSet + #staticField in v; // expect Foo's constructor + #staticMethod in v; // expect Foo's constructor + } + precedence(v) { + // '==' and '||' have lower precedence than 'in' + // 'in' naturally has same precedence as 'in' + // '<<' has higher precedence than 'in' + v == #field in v || v; // Good precedence: (v == (#field in v)) || v + v << #field in v << v; // Good precedence (SyntaxError): (v << #field) in (v << v) + v << #field in v == v; // Good precedence (SyntaxError): ((v << #field) in v) == v + v == #field in v in v; // Good precedence: v == ((#field in v) in v) + #field in v && #field in v; // Good precedence: (#field in v) && (#field in v) + } + invalidLHS(v) { + 'prop' in v; + 10; + #field in v; + 10; + } +} +class Bar { + #field = 1; + check(v) { + #field in v; // expect Bar's 'field' WeakMap + } +} +function syntaxError(v) { + return #field in v; // expect `return in v` so runtime will have a syntax error +} +export {}; diff --git a/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).symbols b/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).symbols new file mode 100644 index 0000000000000..572beaf65eee3 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).symbols @@ -0,0 +1,112 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts === +class Foo { +>Foo : Symbol(Foo, Decl(privateNameInInExpressionTransform.ts, 0, 0)) + + #field = 1; +>#field : Symbol(Foo.#field, Decl(privateNameInInExpressionTransform.ts, 0, 11)) + + #method() {} +>#method : Symbol(Foo.#method, Decl(privateNameInInExpressionTransform.ts, 1, 15)) + + static #staticField= 2; +>#staticField : Symbol(Foo.#staticField, Decl(privateNameInInExpressionTransform.ts, 2, 16)) + + static #staticMethod() {} +>#staticMethod : Symbol(Foo.#staticMethod, Decl(privateNameInInExpressionTransform.ts, 3, 27)) + + check(v: any) { +>check : Symbol(Foo.check, Decl(privateNameInInExpressionTransform.ts, 4, 29)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 6, 10)) + + #field in v; // expect Foo's 'field' WeakMap +>#field : Symbol(Foo.#field, Decl(privateNameInInExpressionTransform.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 6, 10)) + + #method in v; // expect Foo's 'instances' WeakSet +>#method : Symbol(Foo.#method, Decl(privateNameInInExpressionTransform.ts, 1, 15)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 6, 10)) + + #staticField in v; // expect Foo's constructor +>#staticField : Symbol(Foo.#staticField, Decl(privateNameInInExpressionTransform.ts, 2, 16)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 6, 10)) + + #staticMethod in v; // expect Foo's constructor +>#staticMethod : Symbol(Foo.#staticMethod, Decl(privateNameInInExpressionTransform.ts, 3, 27)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 6, 10)) + } + precedence(v: any) { +>precedence : Symbol(Foo.precedence, Decl(privateNameInInExpressionTransform.ts, 11, 5)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) + + // '==' and '||' have lower precedence than 'in' + // 'in' naturally has same precedence as 'in' + // '<<' has higher precedence than 'in' + + v == #field in v || v; // Good precedence: (v == (#field in v)) || v +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpressionTransform.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) + + v << #field in v << v; // Good precedence (SyntaxError): (v << #field) in (v << v) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) + + v << #field in v == v; // Good precedence (SyntaxError): ((v << #field) in v) == v +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) + + v == #field in v in v; // Good precedence: v == ((#field in v) in v) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpressionTransform.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) + + #field in v && #field in v; // Good precedence: (#field in v) && (#field in v) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpressionTransform.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) +>#field : Symbol(Foo.#field, Decl(privateNameInInExpressionTransform.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 12, 15)) + } + invalidLHS(v: any) { +>invalidLHS : Symbol(Foo.invalidLHS, Decl(privateNameInInExpressionTransform.ts, 26, 5)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 27, 15)) + + 'prop' in v = 10; +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 27, 15)) + + #field in v = 10; +>#field : Symbol(Foo.#field, Decl(privateNameInInExpressionTransform.ts, 0, 11)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 27, 15)) + } +} + +class Bar { +>Bar : Symbol(Bar, Decl(privateNameInInExpressionTransform.ts, 31, 1)) + + #field = 1; +>#field : Symbol(Bar.#field, Decl(privateNameInInExpressionTransform.ts, 33, 11)) + + check(v: any) { +>check : Symbol(Bar.check, Decl(privateNameInInExpressionTransform.ts, 34, 15)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 35, 10)) + + #field in v; // expect Bar's 'field' WeakMap +>#field : Symbol(Bar.#field, Decl(privateNameInInExpressionTransform.ts, 33, 11)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 35, 10)) + } +} + +function syntaxError(v: Foo) { +>syntaxError : Symbol(syntaxError, Decl(privateNameInInExpressionTransform.ts, 38, 1)) +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 40, 21)) +>Foo : Symbol(Foo, Decl(privateNameInInExpressionTransform.ts, 0, 0)) + + return #field in v; // expect `return in v` so runtime will have a syntax error +>v : Symbol(v, Decl(privateNameInInExpressionTransform.ts, 40, 21)) +} + +export { } + diff --git a/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).types b/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).types new file mode 100644 index 0000000000000..135b6495e4eeb --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionTransform(target=es2022).types @@ -0,0 +1,141 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts === +class Foo { +>Foo : Foo + + #field = 1; +>#field : number +>1 : 1 + + #method() {} +>#method : () => void + + static #staticField= 2; +>#staticField : number +>2 : 2 + + static #staticMethod() {} +>#staticMethod : () => void + + check(v: any) { +>check : (v: any) => void +>v : any + + #field in v; // expect Foo's 'field' WeakMap +>#field in v : boolean +>#field : any +>v : any + + #method in v; // expect Foo's 'instances' WeakSet +>#method in v : boolean +>#method : any +>v : any + + #staticField in v; // expect Foo's constructor +>#staticField in v : boolean +>#staticField : any +>v : any + + #staticMethod in v; // expect Foo's constructor +>#staticMethod in v : boolean +>#staticMethod : any +>v : any + } + precedence(v: any) { +>precedence : (v: any) => void +>v : any + + // '==' and '||' have lower precedence than 'in' + // 'in' naturally has same precedence as 'in' + // '<<' has higher precedence than 'in' + + v == #field in v || v; // Good precedence: (v == (#field in v)) || v +>v == #field in v || v : any +>v == #field in v : boolean +>v : any +>#field in v : boolean +>#field : any +>v : any +>v : any + + v << #field in v << v; // Good precedence (SyntaxError): (v << #field) in (v << v) +>v << #field in v << v : boolean +>v << #field : number +>v : any +>v << v : number +>v : any +>v : any + + v << #field in v == v; // Good precedence (SyntaxError): ((v << #field) in v) == v +>v << #field in v == v : boolean +>v << #field in v : boolean +>v << #field : number +>v : any +>v : any +>v : any + + v == #field in v in v; // Good precedence: v == ((#field in v) in v) +>v == #field in v in v : boolean +>v : any +>#field in v in v : boolean +>#field in v : boolean +>#field : any +>v : any +>v : any + + #field in v && #field in v; // Good precedence: (#field in v) && (#field in v) +>#field in v && #field in v : boolean +>#field in v : boolean +>#field : any +>v : any +>#field in v : boolean +>#field : any +>v : Foo + } + invalidLHS(v: any) { +>invalidLHS : (v: any) => void +>v : any + + 'prop' in v = 10; +>'prop' in v : boolean +>'prop' : "prop" +>v : any +>10 : 10 + + #field in v = 10; +>#field in v : boolean +>#field : any +>v : any +>10 : 10 + } +} + +class Bar { +>Bar : Bar + + #field = 1; +>#field : number +>1 : 1 + + check(v: any) { +>check : (v: any) => void +>v : any + + #field in v; // expect Bar's 'field' WeakMap +>#field in v : boolean +>#field : any +>v : any + } +} + +function syntaxError(v: Foo) { +>syntaxError : (v: Foo) => boolean +>v : Foo + + return #field in v; // expect `return in v` so runtime will have a syntax error +>#field in v : boolean +>#field : any +>v : Foo +} + +export { } + diff --git a/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).errors.txt b/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).errors.txt new file mode 100644 index 0000000000000..94d56876d297b --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).errors.txt @@ -0,0 +1,16 @@ +tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts(2,5): error TS6133: '#unused' is declared but its value is never read. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts (1 errors) ==== + class Foo { + #unused: undefined; // expect unused error + ~~~~~~~ +!!! error TS6133: '#unused' is declared but its value is never read. + #brand: undefined; // expect no error + + isFoo(v: any): v is Foo { + // This should count as using/reading '#brand' + return #brand in v; + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).js b/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).js new file mode 100644 index 0000000000000..651f2932d1669 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).js @@ -0,0 +1,22 @@ +//// [privateNameInInExpressionUnused.ts] +class Foo { + #unused: undefined; // expect unused error + #brand: undefined; // expect no error + + isFoo(v: any): v is Foo { + // This should count as using/reading '#brand' + return #brand in v; + } +} + + +//// [privateNameInInExpressionUnused.js] +"use strict"; +class Foo { + #unused; // expect unused error + #brand; // expect no error + isFoo(v) { + // This should count as using/reading '#brand' + return #brand in v; + } +} diff --git a/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).symbols b/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).symbols new file mode 100644 index 0000000000000..027c62bc16385 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts === +class Foo { +>Foo : Symbol(Foo, Decl(privateNameInInExpressionUnused.ts, 0, 0)) + + #unused: undefined; // expect unused error +>#unused : Symbol(Foo.#unused, Decl(privateNameInInExpressionUnused.ts, 0, 11)) + + #brand: undefined; // expect no error +>#brand : Symbol(Foo.#brand, Decl(privateNameInInExpressionUnused.ts, 1, 23)) + + isFoo(v: any): v is Foo { +>isFoo : Symbol(Foo.isFoo, Decl(privateNameInInExpressionUnused.ts, 2, 22)) +>v : Symbol(v, Decl(privateNameInInExpressionUnused.ts, 4, 10)) +>v : Symbol(v, Decl(privateNameInInExpressionUnused.ts, 4, 10)) +>Foo : Symbol(Foo, Decl(privateNameInInExpressionUnused.ts, 0, 0)) + + // This should count as using/reading '#brand' + return #brand in v; +>#brand : Symbol(Foo.#brand, Decl(privateNameInInExpressionUnused.ts, 1, 23)) +>v : Symbol(v, Decl(privateNameInInExpressionUnused.ts, 4, 10)) + } +} + diff --git a/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).types b/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).types new file mode 100644 index 0000000000000..95d8c12e0530d --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionUnused(target=es2022).types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts === +class Foo { +>Foo : Foo + + #unused: undefined; // expect unused error +>#unused : undefined + + #brand: undefined; // expect no error +>#brand : undefined + + isFoo(v: any): v is Foo { +>isFoo : (v: any) => v is Foo +>v : any + + // This should count as using/reading '#brand' + return #brand in v; +>#brand in v : boolean +>#brand : any +>v : any + } +} + diff --git a/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).errors.txt b/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).errors.txt new file mode 100644 index 0000000000000..94d56876d297b --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).errors.txt @@ -0,0 +1,16 @@ +tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts(2,5): error TS6133: '#unused' is declared but its value is never read. + + +==== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts (1 errors) ==== + class Foo { + #unused: undefined; // expect unused error + ~~~~~~~ +!!! error TS6133: '#unused' is declared but its value is never read. + #brand: undefined; // expect no error + + isFoo(v: any): v is Foo { + // This should count as using/reading '#brand' + return #brand in v; + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).js b/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).js new file mode 100644 index 0000000000000..651f2932d1669 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).js @@ -0,0 +1,22 @@ +//// [privateNameInInExpressionUnused.ts] +class Foo { + #unused: undefined; // expect unused error + #brand: undefined; // expect no error + + isFoo(v: any): v is Foo { + // This should count as using/reading '#brand' + return #brand in v; + } +} + + +//// [privateNameInInExpressionUnused.js] +"use strict"; +class Foo { + #unused; // expect unused error + #brand; // expect no error + isFoo(v) { + // This should count as using/reading '#brand' + return #brand in v; + } +} diff --git a/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).symbols b/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).symbols new file mode 100644 index 0000000000000..027c62bc16385 --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).symbols @@ -0,0 +1,23 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts === +class Foo { +>Foo : Symbol(Foo, Decl(privateNameInInExpressionUnused.ts, 0, 0)) + + #unused: undefined; // expect unused error +>#unused : Symbol(Foo.#unused, Decl(privateNameInInExpressionUnused.ts, 0, 11)) + + #brand: undefined; // expect no error +>#brand : Symbol(Foo.#brand, Decl(privateNameInInExpressionUnused.ts, 1, 23)) + + isFoo(v: any): v is Foo { +>isFoo : Symbol(Foo.isFoo, Decl(privateNameInInExpressionUnused.ts, 2, 22)) +>v : Symbol(v, Decl(privateNameInInExpressionUnused.ts, 4, 10)) +>v : Symbol(v, Decl(privateNameInInExpressionUnused.ts, 4, 10)) +>Foo : Symbol(Foo, Decl(privateNameInInExpressionUnused.ts, 0, 0)) + + // This should count as using/reading '#brand' + return #brand in v; +>#brand : Symbol(Foo.#brand, Decl(privateNameInInExpressionUnused.ts, 1, 23)) +>v : Symbol(v, Decl(privateNameInInExpressionUnused.ts, 4, 10)) + } +} + diff --git a/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).types b/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).types new file mode 100644 index 0000000000000..95d8c12e0530d --- /dev/null +++ b/tests/baselines/reference/privateNameInInExpressionUnused(target=esnext).types @@ -0,0 +1,22 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts === +class Foo { +>Foo : Foo + + #unused: undefined; // expect unused error +>#unused : undefined + + #brand: undefined; // expect no error +>#brand : undefined + + isFoo(v: any): v is Foo { +>isFoo : (v: any) => v is Foo +>v : any + + // This should count as using/reading '#brand' + return #brand in v; +>#brand in v : boolean +>#brand : any +>v : any + } +} + diff --git a/tests/baselines/reference/privateNameStaticAndStaticInitializer(target=es2022).js b/tests/baselines/reference/privateNameStaticAndStaticInitializer(target=es2022).js new file mode 100644 index 0000000000000..2e3d168e42004 --- /dev/null +++ b/tests/baselines/reference/privateNameStaticAndStaticInitializer(target=es2022).js @@ -0,0 +1,15 @@ +//// [privateNameStaticAndStaticInitializer.ts] +class A { + static #foo = 1; + static #prop = 2; +} + + + +//// [privateNameStaticAndStaticInitializer.js] +class A { + static #foo; + static #prop; +} +A.#foo = 1; +A.#prop = 2; diff --git a/tests/baselines/reference/privateNameStaticAndStaticInitializer(target=es2022).symbols b/tests/baselines/reference/privateNameStaticAndStaticInitializer(target=es2022).symbols new file mode 100644 index 0000000000000..c0085bdc9b9c0 --- /dev/null +++ b/tests/baselines/reference/privateNameStaticAndStaticInitializer(target=es2022).symbols @@ -0,0 +1,12 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticAndStaticInitializer.ts === +class A { +>A : Symbol(A, Decl(privateNameStaticAndStaticInitializer.ts, 0, 0)) + + static #foo = 1; +>#foo : Symbol(A.#foo, Decl(privateNameStaticAndStaticInitializer.ts, 0, 9)) + + static #prop = 2; +>#prop : Symbol(A.#prop, Decl(privateNameStaticAndStaticInitializer.ts, 1, 18)) +} + + diff --git a/tests/baselines/reference/privateNameStaticAndStaticInitializer(target=es2022).types b/tests/baselines/reference/privateNameStaticAndStaticInitializer(target=es2022).types new file mode 100644 index 0000000000000..956a0474bfb07 --- /dev/null +++ b/tests/baselines/reference/privateNameStaticAndStaticInitializer(target=es2022).types @@ -0,0 +1,14 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticAndStaticInitializer.ts === +class A { +>A : A + + static #foo = 1; +>#foo : number +>1 : 1 + + static #prop = 2; +>#prop : number +>2 : 2 +} + + diff --git a/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2022).js b/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2022).js new file mode 100644 index 0000000000000..bbaf5cd7601ab --- /dev/null +++ b/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2022).js @@ -0,0 +1,51 @@ +//// [privateNameStaticFieldDestructuredBinding.ts] +class A { + static #field = 1; + otherClass = A; + testObject() { + return { x: 10, y: 6 }; + } + testArray() { + return [10, 11]; + } + constructor() { + let y: number; + ({ x: A.#field, y } = this.testObject()); + ([A.#field, y] = this.testArray()); + ({ a: A.#field, b: [A.#field] } = { a: 1, b: [2] }); + [A.#field, [A.#field]] = [1, [2]]; + ({ a: A.#field = 1, b: [A.#field = 1] } = { b: [] }); + [A.#field = 2] = []; + [this.otherClass.#field = 2] = []; + } + static test(_a: typeof A) { + [_a.#field] = [2]; + } +} + + +//// [privateNameStaticFieldDestructuredBinding.js] +class A { + constructor() { + this.otherClass = A; + let y; + ({ x: A.#field, y } = this.testObject()); + ([A.#field, y] = this.testArray()); + ({ a: A.#field, b: [A.#field] } = { a: 1, b: [2] }); + [A.#field, [A.#field]] = [1, [2]]; + ({ a: A.#field = 1, b: [A.#field = 1] } = { b: [] }); + [A.#field = 2] = []; + [this.otherClass.#field = 2] = []; + } + static #field; + testObject() { + return { x: 10, y: 6 }; + } + testArray() { + return [10, 11]; + } + static test(_a) { + [_a.#field] = [2]; + } +} +A.#field = 1; diff --git a/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2022).symbols b/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2022).symbols new file mode 100644 index 0000000000000..a539e6833531e --- /dev/null +++ b/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2022).symbols @@ -0,0 +1,90 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldDestructuredBinding.ts === +class A { +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) + + static #field = 1; +>#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) + + otherClass = A; +>otherClass : Symbol(A.otherClass, Decl(privateNameStaticFieldDestructuredBinding.ts, 1, 22)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) + + testObject() { +>testObject : Symbol(A.testObject, Decl(privateNameStaticFieldDestructuredBinding.ts, 2, 19)) + + return { x: 10, y: 6 }; +>x : Symbol(x, Decl(privateNameStaticFieldDestructuredBinding.ts, 4, 16)) +>y : Symbol(y, Decl(privateNameStaticFieldDestructuredBinding.ts, 4, 23)) + } + testArray() { +>testArray : Symbol(A.testArray, Decl(privateNameStaticFieldDestructuredBinding.ts, 5, 5)) + + return [10, 11]; + } + constructor() { + let y: number; +>y : Symbol(y, Decl(privateNameStaticFieldDestructuredBinding.ts, 10, 11)) + + ({ x: A.#field, y } = this.testObject()); +>x : Symbol(x, Decl(privateNameStaticFieldDestructuredBinding.ts, 11, 10)) +>A.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) +>y : Symbol(y, Decl(privateNameStaticFieldDestructuredBinding.ts, 11, 23)) +>this.testObject : Symbol(A.testObject, Decl(privateNameStaticFieldDestructuredBinding.ts, 2, 19)) +>this : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) +>testObject : Symbol(A.testObject, Decl(privateNameStaticFieldDestructuredBinding.ts, 2, 19)) + + ([A.#field, y] = this.testArray()); +>A.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) +>y : Symbol(y, Decl(privateNameStaticFieldDestructuredBinding.ts, 10, 11)) +>this.testArray : Symbol(A.testArray, Decl(privateNameStaticFieldDestructuredBinding.ts, 5, 5)) +>this : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) +>testArray : Symbol(A.testArray, Decl(privateNameStaticFieldDestructuredBinding.ts, 5, 5)) + + ({ a: A.#field, b: [A.#field] } = { a: 1, b: [2] }); +>a : Symbol(a, Decl(privateNameStaticFieldDestructuredBinding.ts, 13, 10)) +>A.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) +>b : Symbol(b, Decl(privateNameStaticFieldDestructuredBinding.ts, 13, 23)) +>A.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) +>a : Symbol(a, Decl(privateNameStaticFieldDestructuredBinding.ts, 13, 43)) +>b : Symbol(b, Decl(privateNameStaticFieldDestructuredBinding.ts, 13, 49)) + + [A.#field, [A.#field]] = [1, [2]]; +>A.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) +>A.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) + + ({ a: A.#field = 1, b: [A.#field = 1] } = { b: [] }); +>a : Symbol(a, Decl(privateNameStaticFieldDestructuredBinding.ts, 15, 10)) +>A.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) +>b : Symbol(b, Decl(privateNameStaticFieldDestructuredBinding.ts, 15, 27)) +>A.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) +>b : Symbol(b, Decl(privateNameStaticFieldDestructuredBinding.ts, 15, 51)) + + [A.#field = 2] = []; +>A.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) + + [this.otherClass.#field = 2] = []; +>this.otherClass.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>this.otherClass : Symbol(A.otherClass, Decl(privateNameStaticFieldDestructuredBinding.ts, 1, 22)) +>this : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) +>otherClass : Symbol(A.otherClass, Decl(privateNameStaticFieldDestructuredBinding.ts, 1, 22)) + } + static test(_a: typeof A) { +>test : Symbol(A.test, Decl(privateNameStaticFieldDestructuredBinding.ts, 18, 5)) +>_a : Symbol(_a, Decl(privateNameStaticFieldDestructuredBinding.ts, 19, 16)) +>A : Symbol(A, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 0)) + + [_a.#field] = [2]; +>_a.#field : Symbol(A.#field, Decl(privateNameStaticFieldDestructuredBinding.ts, 0, 9)) +>_a : Symbol(_a, Decl(privateNameStaticFieldDestructuredBinding.ts, 19, 16)) + } +} + diff --git a/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2022).types b/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2022).types new file mode 100644 index 0000000000000..ef8a216bdb295 --- /dev/null +++ b/tests/baselines/reference/privateNameStaticFieldDestructuredBinding(target=es2022).types @@ -0,0 +1,144 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldDestructuredBinding.ts === +class A { +>A : A + + static #field = 1; +>#field : number +>1 : 1 + + otherClass = A; +>otherClass : typeof A +>A : typeof A + + testObject() { +>testObject : () => { x: number; y: number; } + + return { x: 10, y: 6 }; +>{ x: 10, y: 6 } : { x: number; y: number; } +>x : number +>10 : 10 +>y : number +>6 : 6 + } + testArray() { +>testArray : () => number[] + + return [10, 11]; +>[10, 11] : number[] +>10 : 10 +>11 : 11 + } + constructor() { + let y: number; +>y : number + + ({ x: A.#field, y } = this.testObject()); +>({ x: A.#field, y } = this.testObject()) : { x: number; y: number; } +>{ x: A.#field, y } = this.testObject() : { x: number; y: number; } +>{ x: A.#field, y } : { x: number; y: number; } +>x : number +>A.#field : number +>A : typeof A +>y : number +>this.testObject() : { x: number; y: number; } +>this.testObject : () => { x: number; y: number; } +>this : this +>testObject : () => { x: number; y: number; } + + ([A.#field, y] = this.testArray()); +>([A.#field, y] = this.testArray()) : number[] +>[A.#field, y] = this.testArray() : number[] +>[A.#field, y] : [number, number] +>A.#field : number +>A : typeof A +>y : number +>this.testArray() : number[] +>this.testArray : () => number[] +>this : this +>testArray : () => number[] + + ({ a: A.#field, b: [A.#field] } = { a: 1, b: [2] }); +>({ a: A.#field, b: [A.#field] } = { a: 1, b: [2] }) : { a: number; b: [number]; } +>{ a: A.#field, b: [A.#field] } = { a: 1, b: [2] } : { a: number; b: [number]; } +>{ a: A.#field, b: [A.#field] } : { a: number; b: [number]; } +>a : number +>A.#field : number +>A : typeof A +>b : [number] +>[A.#field] : [number] +>A.#field : number +>A : typeof A +>{ a: 1, b: [2] } : { a: number; b: [number]; } +>a : number +>1 : 1 +>b : [number] +>[2] : [number] +>2 : 2 + + [A.#field, [A.#field]] = [1, [2]]; +>[A.#field, [A.#field]] = [1, [2]] : [number, [number]] +>[A.#field, [A.#field]] : [number, [number]] +>A.#field : number +>A : typeof A +>[A.#field] : [number] +>A.#field : number +>A : typeof A +>[1, [2]] : [number, [number]] +>1 : 1 +>[2] : [number] +>2 : 2 + + ({ a: A.#field = 1, b: [A.#field = 1] } = { b: [] }); +>({ a: A.#field = 1, b: [A.#field = 1] } = { b: [] }) : { b: []; a?: number; } +>{ a: A.#field = 1, b: [A.#field = 1] } = { b: [] } : { b: []; a?: number; } +>{ a: A.#field = 1, b: [A.#field = 1] } : { a?: number; b: [number]; } +>a : number +>A.#field = 1 : 1 +>A.#field : number +>A : typeof A +>1 : 1 +>b : [number] +>[A.#field = 1] : [number] +>A.#field = 1 : 1 +>A.#field : number +>A : typeof A +>1 : 1 +>{ b: [] } : { b: []; a?: number; } +>b : [] +>[] : [] + + [A.#field = 2] = []; +>[A.#field = 2] = [] : [] +>[A.#field = 2] : [number] +>A.#field = 2 : 2 +>A.#field : number +>A : typeof A +>2 : 2 +>[] : [] + + [this.otherClass.#field = 2] = []; +>[this.otherClass.#field = 2] = [] : [] +>[this.otherClass.#field = 2] : [number] +>this.otherClass.#field = 2 : 2 +>this.otherClass.#field : number +>this.otherClass : typeof A +>this : this +>otherClass : typeof A +>2 : 2 +>[] : [] + } + static test(_a: typeof A) { +>test : (_a: typeof A) => void +>_a : typeof A +>A : typeof A + + [_a.#field] = [2]; +>[_a.#field] = [2] : [number] +>[_a.#field] : [number] +>_a.#field : number +>_a : typeof A +>[2] : [number] +>2 : 2 + } +} + diff --git a/tests/baselines/reference/privateNameStaticFieldInitializer(target=es2022).js b/tests/baselines/reference/privateNameStaticFieldInitializer(target=es2022).js new file mode 100644 index 0000000000000..fddf56e1754c5 --- /dev/null +++ b/tests/baselines/reference/privateNameStaticFieldInitializer(target=es2022).js @@ -0,0 +1,13 @@ +//// [privateNameStaticFieldInitializer.ts] +class A { + static #field = 10; + static #uninitialized; +} + + +//// [privateNameStaticFieldInitializer.js] +class A { + static #field; + static #uninitialized; +} +A.#field = 10; diff --git a/tests/baselines/reference/privateNameStaticFieldInitializer(target=es2022).symbols b/tests/baselines/reference/privateNameStaticFieldInitializer(target=es2022).symbols new file mode 100644 index 0000000000000..d503ebe5086a4 --- /dev/null +++ b/tests/baselines/reference/privateNameStaticFieldInitializer(target=es2022).symbols @@ -0,0 +1,11 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldInitializer.ts === +class A { +>A : Symbol(A, Decl(privateNameStaticFieldInitializer.ts, 0, 0)) + + static #field = 10; +>#field : Symbol(A.#field, Decl(privateNameStaticFieldInitializer.ts, 0, 9)) + + static #uninitialized; +>#uninitialized : Symbol(A.#uninitialized, Decl(privateNameStaticFieldInitializer.ts, 1, 23)) +} + diff --git a/tests/baselines/reference/privateNameStaticFieldInitializer(target=es2022).types b/tests/baselines/reference/privateNameStaticFieldInitializer(target=es2022).types new file mode 100644 index 0000000000000..d50c9a2533f0c --- /dev/null +++ b/tests/baselines/reference/privateNameStaticFieldInitializer(target=es2022).types @@ -0,0 +1,12 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldInitializer.ts === +class A { +>A : A + + static #field = 10; +>#field : number +>10 : 10 + + static #uninitialized; +>#uninitialized : any +} + diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).js b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).js index a2caf1c9fd25f..a53922b5e74a4 100644 --- a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).js +++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).js @@ -5,7 +5,8 @@ const C = class { class C2 { static #x; -} +} + //// [privateNameStaticFieldNoInitializer.js] var _a, _C_x, _b, _C2_x; diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).symbols b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).symbols index 282fbce172a80..eaca354548f9c 100644 --- a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).symbols +++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).symbols @@ -12,3 +12,4 @@ class C2 { static #x; >#x : Symbol(C2.#x, Decl(privateNameStaticFieldNoInitializer.ts, 4, 10)) } + diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).types b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).types index a9ecdc42725e9..0d3ae06d7076a 100644 --- a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).types +++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2015).types @@ -13,3 +13,4 @@ class C2 { static #x; >#x : any } + diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).js b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).js new file mode 100644 index 0000000000000..f9318e8ae349e --- /dev/null +++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).js @@ -0,0 +1,17 @@ +//// [privateNameStaticFieldNoInitializer.ts] +const C = class { + static #x; +} + +class C2 { + static #x; +} + + +//// [privateNameStaticFieldNoInitializer.js] +const C = class { + static #x; +}; +class C2 { + static #x; +} diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).symbols b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).symbols new file mode 100644 index 0000000000000..eaca354548f9c --- /dev/null +++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).symbols @@ -0,0 +1,15 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldNoInitializer.ts === +const C = class { +>C : Symbol(C, Decl(privateNameStaticFieldNoInitializer.ts, 0, 5)) + + static #x; +>#x : Symbol(C.#x, Decl(privateNameStaticFieldNoInitializer.ts, 0, 17)) +} + +class C2 { +>C2 : Symbol(C2, Decl(privateNameStaticFieldNoInitializer.ts, 2, 1)) + + static #x; +>#x : Symbol(C2.#x, Decl(privateNameStaticFieldNoInitializer.ts, 4, 10)) +} + diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).types b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).types new file mode 100644 index 0000000000000..0d3ae06d7076a --- /dev/null +++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=es2022).types @@ -0,0 +1,16 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldNoInitializer.ts === +const C = class { +>C : typeof C +>class { static #x;} : typeof C + + static #x; +>#x : any +} + +class C2 { +>C2 : C2 + + static #x; +>#x : any +} + diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).js b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).js index df9759b3ea594..f9318e8ae349e 100644 --- a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).js +++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).js @@ -5,7 +5,8 @@ const C = class { class C2 { static #x; -} +} + //// [privateNameStaticFieldNoInitializer.js] const C = class { diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).symbols b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).symbols index 282fbce172a80..eaca354548f9c 100644 --- a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).symbols +++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).symbols @@ -12,3 +12,4 @@ class C2 { static #x; >#x : Symbol(C2.#x, Decl(privateNameStaticFieldNoInitializer.ts, 4, 10)) } + diff --git a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).types b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).types index a9ecdc42725e9..0d3ae06d7076a 100644 --- a/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).types +++ b/tests/baselines/reference/privateNameStaticFieldNoInitializer(target=esnext).types @@ -13,3 +13,4 @@ class C2 { static #x; >#x : any } + diff --git a/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=es2022).js b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=es2022).js new file mode 100644 index 0000000000000..971fb06aeb4e0 --- /dev/null +++ b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=es2022).js @@ -0,0 +1,62 @@ +//// [privateNameStaticsAndStaticMethods.ts] +class A { + static #foo(a: number) {} + static async #bar(a: number) {} + static async *#baz(a: number) { + return 3; + } + static #_quux: number; + static get #quux (): number { + return this.#_quux; + } + static set #quux (val: number) { + this.#_quux = val; + } + constructor () { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } +} + +class B extends A { + static #foo(a: string) {} + constructor () { + super(); + B.#foo("str"); + } +} + + +//// [privateNameStaticsAndStaticMethods.js] +"use strict"; +class A { + constructor() { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } + static #foo(a) { } + static async #bar(a) { } + static async *#baz(a) { + return 3; + } + static #_quux; + static get #quux() { + return this.#_quux; + } + static set #quux(val) { + this.#_quux = val; + } +} +class B extends A { + static #foo(a) { } + constructor() { + super(); + B.#foo("str"); + } +} diff --git a/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=es2022).symbols b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=es2022).symbols new file mode 100644 index 0000000000000..7ec73424ea701 --- /dev/null +++ b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=es2022).symbols @@ -0,0 +1,80 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticsAndStaticMethods.ts === +class A { +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + static #foo(a: number) {} +>#foo : Symbol(A.#foo, Decl(privateNameStaticsAndStaticMethods.ts, 0, 9)) +>a : Symbol(a, Decl(privateNameStaticsAndStaticMethods.ts, 1, 16)) + + static async #bar(a: number) {} +>#bar : Symbol(A.#bar, Decl(privateNameStaticsAndStaticMethods.ts, 1, 29)) +>a : Symbol(a, Decl(privateNameStaticsAndStaticMethods.ts, 2, 22)) + + static async *#baz(a: number) { +>#baz : Symbol(A.#baz, Decl(privateNameStaticsAndStaticMethods.ts, 2, 35)) +>a : Symbol(a, Decl(privateNameStaticsAndStaticMethods.ts, 3, 23)) + + return 3; + } + static #_quux: number; +>#_quux : Symbol(A.#_quux, Decl(privateNameStaticsAndStaticMethods.ts, 5, 5)) + + static get #quux (): number { +>#quux : Symbol(A.#quux, Decl(privateNameStaticsAndStaticMethods.ts, 6, 26), Decl(privateNameStaticsAndStaticMethods.ts, 9, 5)) + + return this.#_quux; +>this.#_quux : Symbol(A.#_quux, Decl(privateNameStaticsAndStaticMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + } + static set #quux (val: number) { +>#quux : Symbol(A.#quux, Decl(privateNameStaticsAndStaticMethods.ts, 6, 26), Decl(privateNameStaticsAndStaticMethods.ts, 9, 5)) +>val : Symbol(val, Decl(privateNameStaticsAndStaticMethods.ts, 10, 22)) + + this.#_quux = val; +>this.#_quux : Symbol(A.#_quux, Decl(privateNameStaticsAndStaticMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) +>val : Symbol(val, Decl(privateNameStaticsAndStaticMethods.ts, 10, 22)) + } + constructor () { + A.#foo(30); +>A.#foo : Symbol(A.#foo, Decl(privateNameStaticsAndStaticMethods.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + A.#bar(30); +>A.#bar : Symbol(A.#bar, Decl(privateNameStaticsAndStaticMethods.ts, 1, 29)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + A.#bar(30); +>A.#bar : Symbol(A.#bar, Decl(privateNameStaticsAndStaticMethods.ts, 1, 29)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + A.#quux = A.#quux + 1; +>A.#quux : Symbol(A.#quux, Decl(privateNameStaticsAndStaticMethods.ts, 6, 26), Decl(privateNameStaticsAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) +>A.#quux : Symbol(A.#quux, Decl(privateNameStaticsAndStaticMethods.ts, 6, 26), Decl(privateNameStaticsAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + A.#quux++; +>A.#quux : Symbol(A.#quux, Decl(privateNameStaticsAndStaticMethods.ts, 6, 26), Decl(privateNameStaticsAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + } +} + +class B extends A { +>B : Symbol(B, Decl(privateNameStaticsAndStaticMethods.ts, 20, 1)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + static #foo(a: string) {} +>#foo : Symbol(B.#foo, Decl(privateNameStaticsAndStaticMethods.ts, 22, 19)) +>a : Symbol(a, Decl(privateNameStaticsAndStaticMethods.ts, 23, 16)) + + constructor () { + super(); +>super : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + B.#foo("str"); +>B.#foo : Symbol(B.#foo, Decl(privateNameStaticsAndStaticMethods.ts, 22, 19)) +>B : Symbol(B, Decl(privateNameStaticsAndStaticMethods.ts, 20, 1)) + } +} + diff --git a/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=es2022).types b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=es2022).types new file mode 100644 index 0000000000000..3ed79a37e11fc --- /dev/null +++ b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=es2022).types @@ -0,0 +1,95 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticsAndStaticMethods.ts === +class A { +>A : A + + static #foo(a: number) {} +>#foo : (a: number) => void +>a : number + + static async #bar(a: number) {} +>#bar : (a: number) => Promise +>a : number + + static async *#baz(a: number) { +>#baz : (a: number) => AsyncGenerator +>a : number + + return 3; +>3 : 3 + } + static #_quux: number; +>#_quux : number + + static get #quux (): number { +>#quux : number + + return this.#_quux; +>this.#_quux : number +>this : typeof A + } + static set #quux (val: number) { +>#quux : number +>val : number + + this.#_quux = val; +>this.#_quux = val : number +>this.#_quux : number +>this : typeof A +>val : number + } + constructor () { + A.#foo(30); +>A.#foo(30) : void +>A.#foo : (a: number) => void +>A : typeof A +>30 : 30 + + A.#bar(30); +>A.#bar(30) : Promise +>A.#bar : (a: number) => Promise +>A : typeof A +>30 : 30 + + A.#bar(30); +>A.#bar(30) : Promise +>A.#bar : (a: number) => Promise +>A : typeof A +>30 : 30 + + A.#quux = A.#quux + 1; +>A.#quux = A.#quux + 1 : number +>A.#quux : number +>A : typeof A +>A.#quux + 1 : number +>A.#quux : number +>A : typeof A +>1 : 1 + + A.#quux++; +>A.#quux++ : number +>A.#quux : number +>A : typeof A + } +} + +class B extends A { +>B : B +>A : A + + static #foo(a: string) {} +>#foo : (a: string) => void +>a : string + + constructor () { + super(); +>super() : void +>super : typeof A + + B.#foo("str"); +>B.#foo("str") : void +>B.#foo : (a: string) => void +>B : typeof B +>"str" : "str" + } +} + diff --git a/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=esnext).js b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=esnext).js new file mode 100644 index 0000000000000..971fb06aeb4e0 --- /dev/null +++ b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=esnext).js @@ -0,0 +1,62 @@ +//// [privateNameStaticsAndStaticMethods.ts] +class A { + static #foo(a: number) {} + static async #bar(a: number) {} + static async *#baz(a: number) { + return 3; + } + static #_quux: number; + static get #quux (): number { + return this.#_quux; + } + static set #quux (val: number) { + this.#_quux = val; + } + constructor () { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } +} + +class B extends A { + static #foo(a: string) {} + constructor () { + super(); + B.#foo("str"); + } +} + + +//// [privateNameStaticsAndStaticMethods.js] +"use strict"; +class A { + constructor() { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } + static #foo(a) { } + static async #bar(a) { } + static async *#baz(a) { + return 3; + } + static #_quux; + static get #quux() { + return this.#_quux; + } + static set #quux(val) { + this.#_quux = val; + } +} +class B extends A { + static #foo(a) { } + constructor() { + super(); + B.#foo("str"); + } +} diff --git a/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=esnext).symbols b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=esnext).symbols new file mode 100644 index 0000000000000..7ec73424ea701 --- /dev/null +++ b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=esnext).symbols @@ -0,0 +1,80 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticsAndStaticMethods.ts === +class A { +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + static #foo(a: number) {} +>#foo : Symbol(A.#foo, Decl(privateNameStaticsAndStaticMethods.ts, 0, 9)) +>a : Symbol(a, Decl(privateNameStaticsAndStaticMethods.ts, 1, 16)) + + static async #bar(a: number) {} +>#bar : Symbol(A.#bar, Decl(privateNameStaticsAndStaticMethods.ts, 1, 29)) +>a : Symbol(a, Decl(privateNameStaticsAndStaticMethods.ts, 2, 22)) + + static async *#baz(a: number) { +>#baz : Symbol(A.#baz, Decl(privateNameStaticsAndStaticMethods.ts, 2, 35)) +>a : Symbol(a, Decl(privateNameStaticsAndStaticMethods.ts, 3, 23)) + + return 3; + } + static #_quux: number; +>#_quux : Symbol(A.#_quux, Decl(privateNameStaticsAndStaticMethods.ts, 5, 5)) + + static get #quux (): number { +>#quux : Symbol(A.#quux, Decl(privateNameStaticsAndStaticMethods.ts, 6, 26), Decl(privateNameStaticsAndStaticMethods.ts, 9, 5)) + + return this.#_quux; +>this.#_quux : Symbol(A.#_quux, Decl(privateNameStaticsAndStaticMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + } + static set #quux (val: number) { +>#quux : Symbol(A.#quux, Decl(privateNameStaticsAndStaticMethods.ts, 6, 26), Decl(privateNameStaticsAndStaticMethods.ts, 9, 5)) +>val : Symbol(val, Decl(privateNameStaticsAndStaticMethods.ts, 10, 22)) + + this.#_quux = val; +>this.#_quux : Symbol(A.#_quux, Decl(privateNameStaticsAndStaticMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) +>val : Symbol(val, Decl(privateNameStaticsAndStaticMethods.ts, 10, 22)) + } + constructor () { + A.#foo(30); +>A.#foo : Symbol(A.#foo, Decl(privateNameStaticsAndStaticMethods.ts, 0, 9)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + A.#bar(30); +>A.#bar : Symbol(A.#bar, Decl(privateNameStaticsAndStaticMethods.ts, 1, 29)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + A.#bar(30); +>A.#bar : Symbol(A.#bar, Decl(privateNameStaticsAndStaticMethods.ts, 1, 29)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + A.#quux = A.#quux + 1; +>A.#quux : Symbol(A.#quux, Decl(privateNameStaticsAndStaticMethods.ts, 6, 26), Decl(privateNameStaticsAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) +>A.#quux : Symbol(A.#quux, Decl(privateNameStaticsAndStaticMethods.ts, 6, 26), Decl(privateNameStaticsAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + A.#quux++; +>A.#quux : Symbol(A.#quux, Decl(privateNameStaticsAndStaticMethods.ts, 6, 26), Decl(privateNameStaticsAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + } +} + +class B extends A { +>B : Symbol(B, Decl(privateNameStaticsAndStaticMethods.ts, 20, 1)) +>A : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + static #foo(a: string) {} +>#foo : Symbol(B.#foo, Decl(privateNameStaticsAndStaticMethods.ts, 22, 19)) +>a : Symbol(a, Decl(privateNameStaticsAndStaticMethods.ts, 23, 16)) + + constructor () { + super(); +>super : Symbol(A, Decl(privateNameStaticsAndStaticMethods.ts, 0, 0)) + + B.#foo("str"); +>B.#foo : Symbol(B.#foo, Decl(privateNameStaticsAndStaticMethods.ts, 22, 19)) +>B : Symbol(B, Decl(privateNameStaticsAndStaticMethods.ts, 20, 1)) + } +} + diff --git a/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=esnext).types b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=esnext).types new file mode 100644 index 0000000000000..3ed79a37e11fc --- /dev/null +++ b/tests/baselines/reference/privateNameStaticsAndStaticMethods(target=esnext).types @@ -0,0 +1,95 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNameStaticsAndStaticMethods.ts === +class A { +>A : A + + static #foo(a: number) {} +>#foo : (a: number) => void +>a : number + + static async #bar(a: number) {} +>#bar : (a: number) => Promise +>a : number + + static async *#baz(a: number) { +>#baz : (a: number) => AsyncGenerator +>a : number + + return 3; +>3 : 3 + } + static #_quux: number; +>#_quux : number + + static get #quux (): number { +>#quux : number + + return this.#_quux; +>this.#_quux : number +>this : typeof A + } + static set #quux (val: number) { +>#quux : number +>val : number + + this.#_quux = val; +>this.#_quux = val : number +>this.#_quux : number +>this : typeof A +>val : number + } + constructor () { + A.#foo(30); +>A.#foo(30) : void +>A.#foo : (a: number) => void +>A : typeof A +>30 : 30 + + A.#bar(30); +>A.#bar(30) : Promise +>A.#bar : (a: number) => Promise +>A : typeof A +>30 : 30 + + A.#bar(30); +>A.#bar(30) : Promise +>A.#bar : (a: number) => Promise +>A : typeof A +>30 : 30 + + A.#quux = A.#quux + 1; +>A.#quux = A.#quux + 1 : number +>A.#quux : number +>A : typeof A +>A.#quux + 1 : number +>A.#quux : number +>A : typeof A +>1 : 1 + + A.#quux++; +>A.#quux++ : number +>A.#quux : number +>A : typeof A + } +} + +class B extends A { +>B : B +>A : A + + static #foo(a: string) {} +>#foo : (a: string) => void +>a : string + + constructor () { + super(); +>super() : void +>super : typeof A + + B.#foo("str"); +>B.#foo("str") : void +>B.#foo : (a: string) => void +>B : typeof B +>"str" : "str" + } +} + diff --git a/tests/baselines/reference/privateNamesAndMethods(target=es2022).js b/tests/baselines/reference/privateNamesAndMethods(target=es2022).js new file mode 100644 index 0000000000000..5041d2a69d232 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndMethods(target=es2022).js @@ -0,0 +1,61 @@ +//// [privateNamesAndMethods.ts] +class A { + #foo(a: number) {} + async #bar(a: number) {} + async *#baz(a: number) { + return 3; + } + #_quux: number; + get #quux (): number { + return this.#_quux; + } + set #quux (val: number) { + this.#_quux = val; + } + constructor () { + this.#foo(30); + this.#bar(30); + this.#baz(30); + this.#quux = this.#quux + 1; + this.#quux++; + } +} + +class B extends A { + #foo(a: string) {} + constructor () { + super(); + this.#foo("str"); + } +} + + +//// [privateNamesAndMethods.js] +class A { + constructor() { + this.#foo(30); + this.#bar(30); + this.#baz(30); + this.#quux = this.#quux + 1; + this.#quux++; + } + #foo(a) { } + async #bar(a) { } + async *#baz(a) { + return 3; + } + #_quux; + get #quux() { + return this.#_quux; + } + set #quux(val) { + this.#_quux = val; + } +} +class B extends A { + #foo(a) { } + constructor() { + super(); + this.#foo("str"); + } +} diff --git a/tests/baselines/reference/privateNamesAndMethods(target=es2022).symbols b/tests/baselines/reference/privateNamesAndMethods(target=es2022).symbols new file mode 100644 index 0000000000000..b4077b65413f4 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndMethods(target=es2022).symbols @@ -0,0 +1,80 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts === +class A { +>A : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + #foo(a: number) {} +>#foo : Symbol(A.#foo, Decl(privateNamesAndMethods.ts, 0, 9)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 1, 9)) + + async #bar(a: number) {} +>#bar : Symbol(A.#bar, Decl(privateNamesAndMethods.ts, 1, 22)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 2, 15)) + + async *#baz(a: number) { +>#baz : Symbol(A.#baz, Decl(privateNamesAndMethods.ts, 2, 28)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 3, 16)) + + return 3; + } + #_quux: number; +>#_quux : Symbol(A.#_quux, Decl(privateNamesAndMethods.ts, 5, 5)) + + get #quux (): number { +>#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) + + return this.#_quux; +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + } + set #quux (val: number) { +>#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>val : Symbol(val, Decl(privateNamesAndMethods.ts, 10, 15)) + + this.#_quux = val; +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) +>val : Symbol(val, Decl(privateNamesAndMethods.ts, 10, 15)) + } + constructor () { + this.#foo(30); +>this.#foo : Symbol(A.#foo, Decl(privateNamesAndMethods.ts, 0, 9)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#bar(30); +>this.#bar : Symbol(A.#bar, Decl(privateNamesAndMethods.ts, 1, 22)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#baz(30); +>this.#baz : Symbol(A.#baz, Decl(privateNamesAndMethods.ts, 2, 28)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#quux = this.#quux + 1; +>this.#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) +>this.#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#quux++; +>this.#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + } +} + +class B extends A { +>B : Symbol(B, Decl(privateNamesAndMethods.ts, 20, 1)) +>A : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + #foo(a: string) {} +>#foo : Symbol(B.#foo, Decl(privateNamesAndMethods.ts, 22, 19)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 23, 9)) + + constructor () { + super(); +>super : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#foo("str"); +>this.#foo : Symbol(B.#foo, Decl(privateNamesAndMethods.ts, 22, 19)) +>this : Symbol(B, Decl(privateNamesAndMethods.ts, 20, 1)) + } +} + diff --git a/tests/baselines/reference/privateNamesAndMethods(target=es2022).types b/tests/baselines/reference/privateNamesAndMethods(target=es2022).types new file mode 100644 index 0000000000000..8412fa0a79b30 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndMethods(target=es2022).types @@ -0,0 +1,95 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts === +class A { +>A : A + + #foo(a: number) {} +>#foo : (a: number) => void +>a : number + + async #bar(a: number) {} +>#bar : (a: number) => Promise +>a : number + + async *#baz(a: number) { +>#baz : (a: number) => AsyncGenerator +>a : number + + return 3; +>3 : 3 + } + #_quux: number; +>#_quux : number + + get #quux (): number { +>#quux : number + + return this.#_quux; +>this.#_quux : number +>this : this + } + set #quux (val: number) { +>#quux : number +>val : number + + this.#_quux = val; +>this.#_quux = val : number +>this.#_quux : number +>this : this +>val : number + } + constructor () { + this.#foo(30); +>this.#foo(30) : void +>this.#foo : (a: number) => void +>this : this +>30 : 30 + + this.#bar(30); +>this.#bar(30) : Promise +>this.#bar : (a: number) => Promise +>this : this +>30 : 30 + + this.#baz(30); +>this.#baz(30) : AsyncGenerator +>this.#baz : (a: number) => AsyncGenerator +>this : this +>30 : 30 + + this.#quux = this.#quux + 1; +>this.#quux = this.#quux + 1 : number +>this.#quux : number +>this : this +>this.#quux + 1 : number +>this.#quux : number +>this : this +>1 : 1 + + this.#quux++; +>this.#quux++ : number +>this.#quux : number +>this : this + } +} + +class B extends A { +>B : B +>A : A + + #foo(a: string) {} +>#foo : (a: string) => void +>a : string + + constructor () { + super(); +>super() : void +>super : typeof A + + this.#foo("str"); +>this.#foo("str") : void +>this.#foo : (a: string) => void +>this : this +>"str" : "str" + } +} + diff --git a/tests/baselines/reference/privateNamesAndMethods(target=esnext).js b/tests/baselines/reference/privateNamesAndMethods(target=esnext).js new file mode 100644 index 0000000000000..5041d2a69d232 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndMethods(target=esnext).js @@ -0,0 +1,61 @@ +//// [privateNamesAndMethods.ts] +class A { + #foo(a: number) {} + async #bar(a: number) {} + async *#baz(a: number) { + return 3; + } + #_quux: number; + get #quux (): number { + return this.#_quux; + } + set #quux (val: number) { + this.#_quux = val; + } + constructor () { + this.#foo(30); + this.#bar(30); + this.#baz(30); + this.#quux = this.#quux + 1; + this.#quux++; + } +} + +class B extends A { + #foo(a: string) {} + constructor () { + super(); + this.#foo("str"); + } +} + + +//// [privateNamesAndMethods.js] +class A { + constructor() { + this.#foo(30); + this.#bar(30); + this.#baz(30); + this.#quux = this.#quux + 1; + this.#quux++; + } + #foo(a) { } + async #bar(a) { } + async *#baz(a) { + return 3; + } + #_quux; + get #quux() { + return this.#_quux; + } + set #quux(val) { + this.#_quux = val; + } +} +class B extends A { + #foo(a) { } + constructor() { + super(); + this.#foo("str"); + } +} diff --git a/tests/baselines/reference/privateNamesAndMethods(target=esnext).symbols b/tests/baselines/reference/privateNamesAndMethods(target=esnext).symbols new file mode 100644 index 0000000000000..b4077b65413f4 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndMethods(target=esnext).symbols @@ -0,0 +1,80 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts === +class A { +>A : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + #foo(a: number) {} +>#foo : Symbol(A.#foo, Decl(privateNamesAndMethods.ts, 0, 9)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 1, 9)) + + async #bar(a: number) {} +>#bar : Symbol(A.#bar, Decl(privateNamesAndMethods.ts, 1, 22)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 2, 15)) + + async *#baz(a: number) { +>#baz : Symbol(A.#baz, Decl(privateNamesAndMethods.ts, 2, 28)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 3, 16)) + + return 3; + } + #_quux: number; +>#_quux : Symbol(A.#_quux, Decl(privateNamesAndMethods.ts, 5, 5)) + + get #quux (): number { +>#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) + + return this.#_quux; +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + } + set #quux (val: number) { +>#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>val : Symbol(val, Decl(privateNamesAndMethods.ts, 10, 15)) + + this.#_quux = val; +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) +>val : Symbol(val, Decl(privateNamesAndMethods.ts, 10, 15)) + } + constructor () { + this.#foo(30); +>this.#foo : Symbol(A.#foo, Decl(privateNamesAndMethods.ts, 0, 9)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#bar(30); +>this.#bar : Symbol(A.#bar, Decl(privateNamesAndMethods.ts, 1, 22)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#baz(30); +>this.#baz : Symbol(A.#baz, Decl(privateNamesAndMethods.ts, 2, 28)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#quux = this.#quux + 1; +>this.#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) +>this.#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#quux++; +>this.#quux : Symbol(A.#quux, Decl(privateNamesAndMethods.ts, 6, 19), Decl(privateNamesAndMethods.ts, 9, 5)) +>this : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + } +} + +class B extends A { +>B : Symbol(B, Decl(privateNamesAndMethods.ts, 20, 1)) +>A : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + #foo(a: string) {} +>#foo : Symbol(B.#foo, Decl(privateNamesAndMethods.ts, 22, 19)) +>a : Symbol(a, Decl(privateNamesAndMethods.ts, 23, 9)) + + constructor () { + super(); +>super : Symbol(A, Decl(privateNamesAndMethods.ts, 0, 0)) + + this.#foo("str"); +>this.#foo : Symbol(B.#foo, Decl(privateNamesAndMethods.ts, 22, 19)) +>this : Symbol(B, Decl(privateNamesAndMethods.ts, 20, 1)) + } +} + diff --git a/tests/baselines/reference/privateNamesAndMethods(target=esnext).types b/tests/baselines/reference/privateNamesAndMethods(target=esnext).types new file mode 100644 index 0000000000000..8412fa0a79b30 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndMethods(target=esnext).types @@ -0,0 +1,95 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts === +class A { +>A : A + + #foo(a: number) {} +>#foo : (a: number) => void +>a : number + + async #bar(a: number) {} +>#bar : (a: number) => Promise +>a : number + + async *#baz(a: number) { +>#baz : (a: number) => AsyncGenerator +>a : number + + return 3; +>3 : 3 + } + #_quux: number; +>#_quux : number + + get #quux (): number { +>#quux : number + + return this.#_quux; +>this.#_quux : number +>this : this + } + set #quux (val: number) { +>#quux : number +>val : number + + this.#_quux = val; +>this.#_quux = val : number +>this.#_quux : number +>this : this +>val : number + } + constructor () { + this.#foo(30); +>this.#foo(30) : void +>this.#foo : (a: number) => void +>this : this +>30 : 30 + + this.#bar(30); +>this.#bar(30) : Promise +>this.#bar : (a: number) => Promise +>this : this +>30 : 30 + + this.#baz(30); +>this.#baz(30) : AsyncGenerator +>this.#baz : (a: number) => AsyncGenerator +>this : this +>30 : 30 + + this.#quux = this.#quux + 1; +>this.#quux = this.#quux + 1 : number +>this.#quux : number +>this : this +>this.#quux + 1 : number +>this.#quux : number +>this : this +>1 : 1 + + this.#quux++; +>this.#quux++ : number +>this.#quux : number +>this : this + } +} + +class B extends A { +>B : B +>A : A + + #foo(a: string) {} +>#foo : (a: string) => void +>a : string + + constructor () { + super(); +>super() : void +>super : typeof A + + this.#foo("str"); +>this.#foo("str") : void +>this.#foo : (a: string) => void +>this : this +>"str" : "str" + } +} + diff --git a/tests/baselines/reference/privateNamesAndStaticMethods(target=es2022).js b/tests/baselines/reference/privateNamesAndStaticMethods(target=es2022).js new file mode 100644 index 0000000000000..7ec1ea5b8cc6f --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticMethods(target=es2022).js @@ -0,0 +1,62 @@ +//// [privateNamesAndStaticMethods.ts] +class A { + static #foo(a: number) {} + static async #bar(a: number) {} + static async *#baz(a: number) { + return 3; + } + static #_quux: number; + static get #quux (): number { + return this.#_quux; + } + static set #quux (val: number) { + this.#_quux = val; + } + constructor () { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } +} + +class B extends A { + static #foo(a: string) {} + constructor () { + super(); + B.#foo("str"); + } +} + + +//// [privateNamesAndStaticMethods.js] +"use strict"; +class A { + constructor() { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } + static #foo(a) { } + static async #bar(a) { } + static async *#baz(a) { + return 3; + } + static #_quux; + static get #quux() { + return this.#_quux; + } + static set #quux(val) { + this.#_quux = val; + } +} +class B extends A { + static #foo(a) { } + constructor() { + super(); + B.#foo("str"); + } +} diff --git a/tests/baselines/reference/privateNamesAndStaticMethods(target=es2022).symbols b/tests/baselines/reference/privateNamesAndStaticMethods(target=es2022).symbols new file mode 100644 index 0000000000000..6657f76abd602 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticMethods(target=es2022).symbols @@ -0,0 +1,80 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts === +class A { +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + static #foo(a: number) {} +>#foo : Symbol(A.#foo, Decl(privateNamesAndStaticMethods.ts, 0, 9)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 1, 16)) + + static async #bar(a: number) {} +>#bar : Symbol(A.#bar, Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 2, 22)) + + static async *#baz(a: number) { +>#baz : Symbol(A.#baz, Decl(privateNamesAndStaticMethods.ts, 2, 35)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 3, 23)) + + return 3; + } + static #_quux: number; +>#_quux : Symbol(A.#_quux, Decl(privateNamesAndStaticMethods.ts, 5, 5)) + + static get #quux (): number { +>#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) + + return this.#_quux; +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndStaticMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + } + static set #quux (val: number) { +>#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>val : Symbol(val, Decl(privateNamesAndStaticMethods.ts, 10, 22)) + + this.#_quux = val; +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndStaticMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) +>val : Symbol(val, Decl(privateNamesAndStaticMethods.ts, 10, 22)) + } + constructor () { + A.#foo(30); +>A.#foo : Symbol(A.#foo, Decl(privateNamesAndStaticMethods.ts, 0, 9)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#bar(30); +>A.#bar : Symbol(A.#bar, Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#bar(30); +>A.#bar : Symbol(A.#bar, Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#quux = A.#quux + 1; +>A.#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) +>A.#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#quux++; +>A.#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + } +} + +class B extends A { +>B : Symbol(B, Decl(privateNamesAndStaticMethods.ts, 20, 1)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + static #foo(a: string) {} +>#foo : Symbol(B.#foo, Decl(privateNamesAndStaticMethods.ts, 22, 19)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 23, 16)) + + constructor () { + super(); +>super : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + B.#foo("str"); +>B.#foo : Symbol(B.#foo, Decl(privateNamesAndStaticMethods.ts, 22, 19)) +>B : Symbol(B, Decl(privateNamesAndStaticMethods.ts, 20, 1)) + } +} + diff --git a/tests/baselines/reference/privateNamesAndStaticMethods(target=es2022).types b/tests/baselines/reference/privateNamesAndStaticMethods(target=es2022).types new file mode 100644 index 0000000000000..a7bb6418ae256 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticMethods(target=es2022).types @@ -0,0 +1,95 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts === +class A { +>A : A + + static #foo(a: number) {} +>#foo : (a: number) => void +>a : number + + static async #bar(a: number) {} +>#bar : (a: number) => Promise +>a : number + + static async *#baz(a: number) { +>#baz : (a: number) => AsyncGenerator +>a : number + + return 3; +>3 : 3 + } + static #_quux: number; +>#_quux : number + + static get #quux (): number { +>#quux : number + + return this.#_quux; +>this.#_quux : number +>this : typeof A + } + static set #quux (val: number) { +>#quux : number +>val : number + + this.#_quux = val; +>this.#_quux = val : number +>this.#_quux : number +>this : typeof A +>val : number + } + constructor () { + A.#foo(30); +>A.#foo(30) : void +>A.#foo : (a: number) => void +>A : typeof A +>30 : 30 + + A.#bar(30); +>A.#bar(30) : Promise +>A.#bar : (a: number) => Promise +>A : typeof A +>30 : 30 + + A.#bar(30); +>A.#bar(30) : Promise +>A.#bar : (a: number) => Promise +>A : typeof A +>30 : 30 + + A.#quux = A.#quux + 1; +>A.#quux = A.#quux + 1 : number +>A.#quux : number +>A : typeof A +>A.#quux + 1 : number +>A.#quux : number +>A : typeof A +>1 : 1 + + A.#quux++; +>A.#quux++ : number +>A.#quux : number +>A : typeof A + } +} + +class B extends A { +>B : B +>A : A + + static #foo(a: string) {} +>#foo : (a: string) => void +>a : string + + constructor () { + super(); +>super() : void +>super : typeof A + + B.#foo("str"); +>B.#foo("str") : void +>B.#foo : (a: string) => void +>B : typeof B +>"str" : "str" + } +} + diff --git a/tests/baselines/reference/privateNamesAndStaticMethods(target=esnext).js b/tests/baselines/reference/privateNamesAndStaticMethods(target=esnext).js new file mode 100644 index 0000000000000..7ec1ea5b8cc6f --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticMethods(target=esnext).js @@ -0,0 +1,62 @@ +//// [privateNamesAndStaticMethods.ts] +class A { + static #foo(a: number) {} + static async #bar(a: number) {} + static async *#baz(a: number) { + return 3; + } + static #_quux: number; + static get #quux (): number { + return this.#_quux; + } + static set #quux (val: number) { + this.#_quux = val; + } + constructor () { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } +} + +class B extends A { + static #foo(a: string) {} + constructor () { + super(); + B.#foo("str"); + } +} + + +//// [privateNamesAndStaticMethods.js] +"use strict"; +class A { + constructor() { + A.#foo(30); + A.#bar(30); + A.#bar(30); + A.#quux = A.#quux + 1; + A.#quux++; + } + static #foo(a) { } + static async #bar(a) { } + static async *#baz(a) { + return 3; + } + static #_quux; + static get #quux() { + return this.#_quux; + } + static set #quux(val) { + this.#_quux = val; + } +} +class B extends A { + static #foo(a) { } + constructor() { + super(); + B.#foo("str"); + } +} diff --git a/tests/baselines/reference/privateNamesAndStaticMethods(target=esnext).symbols b/tests/baselines/reference/privateNamesAndStaticMethods(target=esnext).symbols new file mode 100644 index 0000000000000..6657f76abd602 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticMethods(target=esnext).symbols @@ -0,0 +1,80 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts === +class A { +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + static #foo(a: number) {} +>#foo : Symbol(A.#foo, Decl(privateNamesAndStaticMethods.ts, 0, 9)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 1, 16)) + + static async #bar(a: number) {} +>#bar : Symbol(A.#bar, Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 2, 22)) + + static async *#baz(a: number) { +>#baz : Symbol(A.#baz, Decl(privateNamesAndStaticMethods.ts, 2, 35)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 3, 23)) + + return 3; + } + static #_quux: number; +>#_quux : Symbol(A.#_quux, Decl(privateNamesAndStaticMethods.ts, 5, 5)) + + static get #quux (): number { +>#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) + + return this.#_quux; +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndStaticMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + } + static set #quux (val: number) { +>#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>val : Symbol(val, Decl(privateNamesAndStaticMethods.ts, 10, 22)) + + this.#_quux = val; +>this.#_quux : Symbol(A.#_quux, Decl(privateNamesAndStaticMethods.ts, 5, 5)) +>this : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) +>val : Symbol(val, Decl(privateNamesAndStaticMethods.ts, 10, 22)) + } + constructor () { + A.#foo(30); +>A.#foo : Symbol(A.#foo, Decl(privateNamesAndStaticMethods.ts, 0, 9)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#bar(30); +>A.#bar : Symbol(A.#bar, Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#bar(30); +>A.#bar : Symbol(A.#bar, Decl(privateNamesAndStaticMethods.ts, 1, 29)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#quux = A.#quux + 1; +>A.#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) +>A.#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + A.#quux++; +>A.#quux : Symbol(A.#quux, Decl(privateNamesAndStaticMethods.ts, 6, 26), Decl(privateNamesAndStaticMethods.ts, 9, 5)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + } +} + +class B extends A { +>B : Symbol(B, Decl(privateNamesAndStaticMethods.ts, 20, 1)) +>A : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + static #foo(a: string) {} +>#foo : Symbol(B.#foo, Decl(privateNamesAndStaticMethods.ts, 22, 19)) +>a : Symbol(a, Decl(privateNamesAndStaticMethods.ts, 23, 16)) + + constructor () { + super(); +>super : Symbol(A, Decl(privateNamesAndStaticMethods.ts, 0, 0)) + + B.#foo("str"); +>B.#foo : Symbol(B.#foo, Decl(privateNamesAndStaticMethods.ts, 22, 19)) +>B : Symbol(B, Decl(privateNamesAndStaticMethods.ts, 20, 1)) + } +} + diff --git a/tests/baselines/reference/privateNamesAndStaticMethods(target=esnext).types b/tests/baselines/reference/privateNamesAndStaticMethods(target=esnext).types new file mode 100644 index 0000000000000..a7bb6418ae256 --- /dev/null +++ b/tests/baselines/reference/privateNamesAndStaticMethods(target=esnext).types @@ -0,0 +1,95 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts === +class A { +>A : A + + static #foo(a: number) {} +>#foo : (a: number) => void +>a : number + + static async #bar(a: number) {} +>#bar : (a: number) => Promise +>a : number + + static async *#baz(a: number) { +>#baz : (a: number) => AsyncGenerator +>a : number + + return 3; +>3 : 3 + } + static #_quux: number; +>#_quux : number + + static get #quux (): number { +>#quux : number + + return this.#_quux; +>this.#_quux : number +>this : typeof A + } + static set #quux (val: number) { +>#quux : number +>val : number + + this.#_quux = val; +>this.#_quux = val : number +>this.#_quux : number +>this : typeof A +>val : number + } + constructor () { + A.#foo(30); +>A.#foo(30) : void +>A.#foo : (a: number) => void +>A : typeof A +>30 : 30 + + A.#bar(30); +>A.#bar(30) : Promise +>A.#bar : (a: number) => Promise +>A : typeof A +>30 : 30 + + A.#bar(30); +>A.#bar(30) : Promise +>A.#bar : (a: number) => Promise +>A : typeof A +>30 : 30 + + A.#quux = A.#quux + 1; +>A.#quux = A.#quux + 1 : number +>A.#quux : number +>A : typeof A +>A.#quux + 1 : number +>A.#quux : number +>A : typeof A +>1 : 1 + + A.#quux++; +>A.#quux++ : number +>A.#quux : number +>A : typeof A + } +} + +class B extends A { +>B : B +>A : A + + static #foo(a: string) {} +>#foo : (a: string) => void +>a : string + + constructor () { + super(); +>super() : void +>super : typeof A + + B.#foo("str"); +>B.#foo("str") : void +>B.#foo : (a: string) => void +>B : typeof B +>"str" : "str" + } +} + diff --git a/tests/baselines/reference/privateNamesAssertion(target=es2022).js b/tests/baselines/reference/privateNamesAssertion(target=es2022).js new file mode 100644 index 0000000000000..b6be4d5d4adf2 --- /dev/null +++ b/tests/baselines/reference/privateNamesAssertion(target=es2022).js @@ -0,0 +1,53 @@ +//// [privateNamesAssertion.ts] +class Foo { + #p1: (v: any) => asserts v is string = (v) => { + if (typeof v !== "string") { + throw new Error(); + } + } + m1(v: unknown) { + this.#p1(v); + v; + } +} + +class Foo2 { + #p1(v: any): asserts v is string { + if (typeof v !== "string") { + throw new Error(); + } + } + m1(v: unknown) { + this.#p1(v); + v; + } +} + + +//// [privateNamesAssertion.js] +"use strict"; +class Foo { + constructor() { + this.#p1 = (v) => { + if (typeof v !== "string") { + throw new Error(); + } + }; + } + #p1; + m1(v) { + this.#p1(v); + v; + } +} +class Foo2 { + #p1(v) { + if (typeof v !== "string") { + throw new Error(); + } + } + m1(v) { + this.#p1(v); + v; + } +} diff --git a/tests/baselines/reference/privateNamesAssertion(target=es2022).symbols b/tests/baselines/reference/privateNamesAssertion(target=es2022).symbols new file mode 100644 index 0000000000000..2e0c423f2dd4d --- /dev/null +++ b/tests/baselines/reference/privateNamesAssertion(target=es2022).symbols @@ -0,0 +1,60 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAssertion.ts === +class Foo { +>Foo : Symbol(Foo, Decl(privateNamesAssertion.ts, 0, 0)) + + #p1: (v: any) => asserts v is string = (v) => { +>#p1 : Symbol(Foo.#p1, Decl(privateNamesAssertion.ts, 0, 11)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 1, 10)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 1, 10)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 1, 44)) + + if (typeof v !== "string") { +>v : Symbol(v, Decl(privateNamesAssertion.ts, 1, 44)) + + throw new Error(); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } + } + m1(v: unknown) { +>m1 : Symbol(Foo.m1, Decl(privateNamesAssertion.ts, 5, 5)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 6, 7)) + + this.#p1(v); +>this.#p1 : Symbol(Foo.#p1, Decl(privateNamesAssertion.ts, 0, 11)) +>this : Symbol(Foo, Decl(privateNamesAssertion.ts, 0, 0)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 6, 7)) + + v; +>v : Symbol(v, Decl(privateNamesAssertion.ts, 6, 7)) + } +} + +class Foo2 { +>Foo2 : Symbol(Foo2, Decl(privateNamesAssertion.ts, 10, 1)) + + #p1(v: any): asserts v is string { +>#p1 : Symbol(Foo2.#p1, Decl(privateNamesAssertion.ts, 12, 12)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 13, 8)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 13, 8)) + + if (typeof v !== "string") { +>v : Symbol(v, Decl(privateNamesAssertion.ts, 13, 8)) + + throw new Error(); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } + } + m1(v: unknown) { +>m1 : Symbol(Foo2.m1, Decl(privateNamesAssertion.ts, 17, 5)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 18, 7)) + + this.#p1(v); +>this.#p1 : Symbol(Foo2.#p1, Decl(privateNamesAssertion.ts, 12, 12)) +>this : Symbol(Foo2, Decl(privateNamesAssertion.ts, 10, 1)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 18, 7)) + + v; +>v : Symbol(v, Decl(privateNamesAssertion.ts, 18, 7)) + } +} + diff --git a/tests/baselines/reference/privateNamesAssertion(target=es2022).types b/tests/baselines/reference/privateNamesAssertion(target=es2022).types new file mode 100644 index 0000000000000..44a052728e9eb --- /dev/null +++ b/tests/baselines/reference/privateNamesAssertion(target=es2022).types @@ -0,0 +1,69 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAssertion.ts === +class Foo { +>Foo : Foo + + #p1: (v: any) => asserts v is string = (v) => { +>#p1 : (v: any) => asserts v is string +>v : any +>(v) => { if (typeof v !== "string") { throw new Error(); } } : (v: any) => void +>v : any + + if (typeof v !== "string") { +>typeof v !== "string" : boolean +>typeof v : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>v : any +>"string" : "string" + + throw new Error(); +>new Error() : Error +>Error : ErrorConstructor + } + } + m1(v: unknown) { +>m1 : (v: unknown) => void +>v : unknown + + this.#p1(v); +>this.#p1(v) : void +>this.#p1 : (v: any) => asserts v is string +>this : this +>v : unknown + + v; +>v : string + } +} + +class Foo2 { +>Foo2 : Foo2 + + #p1(v: any): asserts v is string { +>#p1 : (v: any) => asserts v is string +>v : any + + if (typeof v !== "string") { +>typeof v !== "string" : boolean +>typeof v : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>v : any +>"string" : "string" + + throw new Error(); +>new Error() : Error +>Error : ErrorConstructor + } + } + m1(v: unknown) { +>m1 : (v: unknown) => void +>v : unknown + + this.#p1(v); +>this.#p1(v) : void +>this.#p1 : (v: any) => asserts v is string +>this : this +>v : unknown + + v; +>v : string + } +} + diff --git a/tests/baselines/reference/privateNamesAssertion(target=esnext).js b/tests/baselines/reference/privateNamesAssertion(target=esnext).js new file mode 100644 index 0000000000000..b6be4d5d4adf2 --- /dev/null +++ b/tests/baselines/reference/privateNamesAssertion(target=esnext).js @@ -0,0 +1,53 @@ +//// [privateNamesAssertion.ts] +class Foo { + #p1: (v: any) => asserts v is string = (v) => { + if (typeof v !== "string") { + throw new Error(); + } + } + m1(v: unknown) { + this.#p1(v); + v; + } +} + +class Foo2 { + #p1(v: any): asserts v is string { + if (typeof v !== "string") { + throw new Error(); + } + } + m1(v: unknown) { + this.#p1(v); + v; + } +} + + +//// [privateNamesAssertion.js] +"use strict"; +class Foo { + constructor() { + this.#p1 = (v) => { + if (typeof v !== "string") { + throw new Error(); + } + }; + } + #p1; + m1(v) { + this.#p1(v); + v; + } +} +class Foo2 { + #p1(v) { + if (typeof v !== "string") { + throw new Error(); + } + } + m1(v) { + this.#p1(v); + v; + } +} diff --git a/tests/baselines/reference/privateNamesAssertion(target=esnext).symbols b/tests/baselines/reference/privateNamesAssertion(target=esnext).symbols new file mode 100644 index 0000000000000..2e0c423f2dd4d --- /dev/null +++ b/tests/baselines/reference/privateNamesAssertion(target=esnext).symbols @@ -0,0 +1,60 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAssertion.ts === +class Foo { +>Foo : Symbol(Foo, Decl(privateNamesAssertion.ts, 0, 0)) + + #p1: (v: any) => asserts v is string = (v) => { +>#p1 : Symbol(Foo.#p1, Decl(privateNamesAssertion.ts, 0, 11)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 1, 10)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 1, 10)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 1, 44)) + + if (typeof v !== "string") { +>v : Symbol(v, Decl(privateNamesAssertion.ts, 1, 44)) + + throw new Error(); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } + } + m1(v: unknown) { +>m1 : Symbol(Foo.m1, Decl(privateNamesAssertion.ts, 5, 5)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 6, 7)) + + this.#p1(v); +>this.#p1 : Symbol(Foo.#p1, Decl(privateNamesAssertion.ts, 0, 11)) +>this : Symbol(Foo, Decl(privateNamesAssertion.ts, 0, 0)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 6, 7)) + + v; +>v : Symbol(v, Decl(privateNamesAssertion.ts, 6, 7)) + } +} + +class Foo2 { +>Foo2 : Symbol(Foo2, Decl(privateNamesAssertion.ts, 10, 1)) + + #p1(v: any): asserts v is string { +>#p1 : Symbol(Foo2.#p1, Decl(privateNamesAssertion.ts, 12, 12)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 13, 8)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 13, 8)) + + if (typeof v !== "string") { +>v : Symbol(v, Decl(privateNamesAssertion.ts, 13, 8)) + + throw new Error(); +>Error : Symbol(Error, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --)) + } + } + m1(v: unknown) { +>m1 : Symbol(Foo2.m1, Decl(privateNamesAssertion.ts, 17, 5)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 18, 7)) + + this.#p1(v); +>this.#p1 : Symbol(Foo2.#p1, Decl(privateNamesAssertion.ts, 12, 12)) +>this : Symbol(Foo2, Decl(privateNamesAssertion.ts, 10, 1)) +>v : Symbol(v, Decl(privateNamesAssertion.ts, 18, 7)) + + v; +>v : Symbol(v, Decl(privateNamesAssertion.ts, 18, 7)) + } +} + diff --git a/tests/baselines/reference/privateNamesAssertion(target=esnext).types b/tests/baselines/reference/privateNamesAssertion(target=esnext).types new file mode 100644 index 0000000000000..44a052728e9eb --- /dev/null +++ b/tests/baselines/reference/privateNamesAssertion(target=esnext).types @@ -0,0 +1,69 @@ +=== tests/cases/conformance/classes/members/privateNames/privateNamesAssertion.ts === +class Foo { +>Foo : Foo + + #p1: (v: any) => asserts v is string = (v) => { +>#p1 : (v: any) => asserts v is string +>v : any +>(v) => { if (typeof v !== "string") { throw new Error(); } } : (v: any) => void +>v : any + + if (typeof v !== "string") { +>typeof v !== "string" : boolean +>typeof v : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>v : any +>"string" : "string" + + throw new Error(); +>new Error() : Error +>Error : ErrorConstructor + } + } + m1(v: unknown) { +>m1 : (v: unknown) => void +>v : unknown + + this.#p1(v); +>this.#p1(v) : void +>this.#p1 : (v: any) => asserts v is string +>this : this +>v : unknown + + v; +>v : string + } +} + +class Foo2 { +>Foo2 : Foo2 + + #p1(v: any): asserts v is string { +>#p1 : (v: any) => asserts v is string +>v : any + + if (typeof v !== "string") { +>typeof v !== "string" : boolean +>typeof v : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function" +>v : any +>"string" : "string" + + throw new Error(); +>new Error() : Error +>Error : ErrorConstructor + } + } + m1(v: unknown) { +>m1 : (v: unknown) => void +>v : unknown + + this.#p1(v); +>this.#p1(v) : void +>this.#p1 : (v: any) => asserts v is string +>this : this +>v : unknown + + v; +>v : string + } +} + diff --git a/tests/baselines/reference/superInStaticMembers1(target=es2022).js b/tests/baselines/reference/superInStaticMembers1(target=es2022).js new file mode 100644 index 0000000000000..d4217f65bb9da --- /dev/null +++ b/tests/baselines/reference/superInStaticMembers1(target=es2022).js @@ -0,0 +1,866 @@ +//// [tests/cases/conformance/classes/members/instanceAndStaticMembers/superInStaticMembers1.ts] //// + +//// [external.ts] +export class Reflect {} +export interface Foo {} +export declare namespace Bar { type _ = unknown; } +export const enum Baz {} +export default class {}; + +//// [locals.ts] +export {}; +declare class B { static w(): number; } +class C extends B { + static _ = [ + (() => { + var Reflect; // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + var [Reflect] = [null]; // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + class Reflect {} // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + function Reflect() {} // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + enum Reflect {} // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + const enum Reflect {} // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + type Reflect = unknown; // no collision + super.w(); + })(), + (() => { + interface Reflect {}; // no collision + super.w(); + })(), + (() => { + (class Reflect {}); // no collision + super.w(); + })(), + (() => { + (function Reflect() {}); // no collision + super.w(); + })(), + ]; + + static { + var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only) + super.w(); + } + + static { + var [Reflect] = [null]; // collision (es2015-es2021 only) + super.w(); + } + + static { + var Reflect; // collision (es2015-es2021 only) + super.w(); + } + + static { + class Reflect {} // collision (es2015-es2021 only) + super.w(); + } + + static { + function Reflect() {} // collision (es2015-es2021 only) + super.w(); + } + + static { + enum Reflect {} // collision (es2015-es2021 only) + super.w(); + } + + static { + const enum Reflect {} // collision (es2015-es2021 only) + super.w(); + } + + static { + type Reflect = unknown; // no collision + super.w(); + } + + static { + interface Reflect {} // no collision + super.w(); + } + + static { + (class Reflect {}) // no collision + super.w(); + } + + static { + (function Reflect() {}) // no collision + super.w(); + } +} + +//// [varInContainingScopeStaticField1.ts] +export {}; +declare class B { static w(): number; } +var Reflect = null; // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [varInContainingScopeStaticField2.ts] +export {}; +declare class B { static w(): number; } +var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [varInContainingScopeStaticField3.ts] +export {}; +declare class B { static w(): number; } +var [Reflect] = [null]; // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [varInContainingScopeStaticBlock1.ts] +export {}; +declare class B { static w(): number; } +var Reflect = null; // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [varInContainingScopeStaticBlock2.ts] +export {}; +declare class B { static w(): number; } +var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [varInContainingScopeStaticBlock3.ts] +export {}; +declare class B { static w(): number; } +var [Reflect] = [null]; // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [classDeclInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +class Reflect {} // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [classDeclInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +class Reflect {} // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [funcDeclInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +function Reflect() {} // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [funcDeclInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +function Reflect() {} // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [valueNamespaceInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +namespace Reflect {} // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [valueNamespaceInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +namespace Reflect {} // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [enumInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +enum Reflect {} // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [enumInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +enum Reflect {} // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [constEnumInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +const enum Reflect {} // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [constEnumInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +const enum Reflect {} // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [namespaceImportInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +import * as Reflect from "./external"; // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [namespaceImportInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +import * as Reflect from "./external"; // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [namedImportInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +import { Reflect } from "./external"; // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [namedImportInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +import { Reflect } from "./external"; // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [namedImportOfInterfaceInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +import { Foo as Reflect } from "./external"; // collision (es2015-es2021 only, not a type-only import) +class C extends B { + static _ = super.w(); +} + +//// [namedImportOfInterfaceInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +import { Foo as Reflect } from "./external"; // collision (es2015-es2021 only, not a type-only import) +class C extends B { + static { super.w(); } +} + +//// [namedImportOfUninstantiatedNamespaceInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +import { Bar as Reflect } from "./external"; // collision (es2015-es2021 only, not a type-only import) +class C extends B { + static _ = super.w(); +} + +//// [namedImportOfUninstantiatedNamespaceInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +import { Bar as Reflect } from "./external"; // collision (es2015-es2021 only, not a type-only import) +class C extends B { + static { super.w(); } +} + +//// [namedImportOfConstEnumInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +import { Baz as Reflect } from "./external"; // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [namedImportOfConstEnumInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +import { Baz as Reflect } from "./external"; // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [typeOnlyNamedImportInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +import type { Reflect } from "./external"; // no collision +class C extends B { + static _ = super.w(); +} + +//// [typeOnlyNamedImportInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +import type { Reflect } from "./external"; // no collision +class C extends B { + static { super.w(); } +} + +//// [defaultImportInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +import Reflect from "./external"; // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} + +//// [defaultImportInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +import Reflect from "./external"; // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} + +//// [typeOnlyDefaultImportInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +import type Reflect from "./external"; // no collision +class C extends B { + static _ = super.w(); +} + +//// [typeOnlyDefaultImportInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +import type Reflect from "./external"; // no collision +class C extends B { + static { super.w(); } +} + +//// [typeInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +type Reflect = unknown; // no collision +class C extends B { + static _ = super.w(); +} + +//// [typeInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +type Reflect = unknown; // no collision +class C extends B { + static { super.w(); } +} + +//// [interfaceInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +interface Reflect {}; // no collision +class C extends B { + static _ = super.w(); +} + +//// [interfaceInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +interface Reflect {}; // no collision +class C extends B { + static { super.w(); } +} + +//// [uninstantiatedNamespaceInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +declare namespace Reflect { type _ = unknown; }; // no collision +class C extends B { + static _ = super.w(); +} + +//// [uninstantiatedNamespaceInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +declare namespace Reflect { type _ = unknown; }; // no collision +class C extends B { + static { super.w(); } +} + +//// [classExprInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +(class Reflect {}); // no collision +class C extends B { + static _ = super.w(); +} + +//// [classExprInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +(class Reflect {}); // no collision +class C extends B { + static { super.w(); } +} + +//// [inContainingClassExprStaticField.ts] +export {}; +declare class B { static w(): number; } +(class Reflect { // collision (es2015-es2021 only) + static { + class C extends B { + static _ = super.w(); + } + } +}); + +//// [inContainingClassExprStaticBlock.ts] +export {}; +declare class B { static w(): number; } +(class Reflect { // collision (es2015-es2021 only) + static { + class C extends B { + static { super.w(); } + } + } +}); + +//// [funcExprInContainingScopeStaticField.ts] +export {}; +declare class B { static w(): number; } +(function Reflect() {}); // no collision +class C extends B { + static _ = super.w(); +} + +//// [funcExprInContainingScopeStaticBlock.ts] +export {}; +declare class B { static w(): number; } +(function Reflect() {}); // no collision +class C extends B { + static { super.w(); } +} + +//// [inContainingFuncExprStaticField.ts] +export {}; +declare class B { static w(): number; } +(function Reflect() { // collision (es2015-es2021 only) + class C extends B { + static _ = super.w(); + } +}); + +//// [inContainingFuncExprStaticBlock.ts] +export {}; +declare class B { static w(): number; } +(function Reflect() { // collision (es2015-es2021 only) + class C extends B { + static { super.w(); } + } +}); + + +//// [external.js] +export class Reflect { +} +export default class { +} +; +//// [locals.js] +class C extends B { + static _ = [ + (() => { + var Reflect; // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + var [Reflect] = [null]; // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + class Reflect { + } // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + function Reflect() { } // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + let Reflect; + (function (Reflect) { + })(Reflect || (Reflect = {})); // collision (es2015-es2021 only) + super.w(); + })(), + (() => { + super.w(); + })(), + (() => { + super.w(); + })(), + (() => { + ; // no collision + super.w(); + })(), + (() => { + (class Reflect { + }); // no collision + super.w(); + })(), + (() => { + (function Reflect() { }); // no collision + super.w(); + })(), + ]; + static { + var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only) + super.w(); + } + static { + var [Reflect] = [null]; // collision (es2015-es2021 only) + super.w(); + } + static { + var Reflect; // collision (es2015-es2021 only) + super.w(); + } + static { + class Reflect { + } // collision (es2015-es2021 only) + super.w(); + } + static { + function Reflect() { } // collision (es2015-es2021 only) + super.w(); + } + static { + let Reflect; + (function (Reflect) { + })(Reflect || (Reflect = {})); // collision (es2015-es2021 only) + super.w(); + } + static { + super.w(); + } + static { + super.w(); + } + static { + super.w(); + } + static { + (class Reflect { + }); // no collision + super.w(); + } + static { + (function Reflect() { }); // no collision + super.w(); + } +} +export {}; +//// [varInContainingScopeStaticField1.js] +var Reflect = null; // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} +export {}; +//// [varInContainingScopeStaticField2.js] +var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} +export {}; +//// [varInContainingScopeStaticField3.js] +var [Reflect] = [null]; // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} +export {}; +//// [varInContainingScopeStaticBlock1.js] +var Reflect = null; // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} +export {}; +//// [varInContainingScopeStaticBlock2.js] +var { Reflect } = { Reflect: null }; // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} +export {}; +//// [varInContainingScopeStaticBlock3.js] +var [Reflect] = [null]; // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} +export {}; +//// [classDeclInContainingScopeStaticField.js] +class Reflect { +} // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} +export {}; +//// [classDeclInContainingScopeStaticBlock.js] +class Reflect { +} // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} +export {}; +//// [funcDeclInContainingScopeStaticField.js] +function Reflect() { } // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} +export {}; +//// [funcDeclInContainingScopeStaticBlock.js] +function Reflect() { } // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} +export {}; +//// [valueNamespaceInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [valueNamespaceInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [enumInContainingScopeStaticField.js] +var Reflect; +(function (Reflect) { +})(Reflect || (Reflect = {})); // collision (es2015-es2021 only) +class C extends B { + static _ = super.w(); +} +export {}; +//// [enumInContainingScopeStaticBlock.js] +var Reflect; +(function (Reflect) { +})(Reflect || (Reflect = {})); // collision (es2015-es2021 only) +class C extends B { + static { super.w(); } +} +export {}; +//// [constEnumInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [constEnumInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [namespaceImportInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [namespaceImportInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [namedImportInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [namedImportInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [namedImportOfInterfaceInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [namedImportOfInterfaceInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [namedImportOfUninstantiatedNamespaceInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [namedImportOfUninstantiatedNamespaceInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [namedImportOfConstEnumInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [namedImportOfConstEnumInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [typeOnlyNamedImportInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [typeOnlyNamedImportInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [defaultImportInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [defaultImportInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [typeOnlyDefaultImportInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [typeOnlyDefaultImportInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [typeInContainingScopeStaticField.js] +class C extends B { + static _ = super.w(); +} +export {}; +//// [typeInContainingScopeStaticBlock.js] +class C extends B { + static { super.w(); } +} +export {}; +//// [interfaceInContainingScopeStaticField.js] +; // no collision +class C extends B { + static _ = super.w(); +} +export {}; +//// [interfaceInContainingScopeStaticBlock.js] +; // no collision +class C extends B { + static { super.w(); } +} +export {}; +//// [uninstantiatedNamespaceInContainingScopeStaticField.js] +; // no collision +class C extends B { + static _ = super.w(); +} +export {}; +//// [uninstantiatedNamespaceInContainingScopeStaticBlock.js] +; // no collision +class C extends B { + static { super.w(); } +} +export {}; +//// [classExprInContainingScopeStaticField.js] +(class Reflect { +}); // no collision +class C extends B { + static _ = super.w(); +} +export {}; +//// [classExprInContainingScopeStaticBlock.js] +(class Reflect { +}); // no collision +class C extends B { + static { super.w(); } +} +export {}; +//// [inContainingClassExprStaticField.js] +(class Reflect { + static { + class C extends B { + static _ = super.w(); + } + } +}); +export {}; +//// [inContainingClassExprStaticBlock.js] +(class Reflect { + static { + class C extends B { + static { super.w(); } + } + } +}); +export {}; +//// [funcExprInContainingScopeStaticField.js] +(function Reflect() { }); // no collision +class C extends B { + static _ = super.w(); +} +export {}; +//// [funcExprInContainingScopeStaticBlock.js] +(function Reflect() { }); // no collision +class C extends B { + static { super.w(); } +} +export {}; +//// [inContainingFuncExprStaticField.js] +(function Reflect() { + class C extends B { + static _ = super.w(); + } +}); +export {}; +//// [inContainingFuncExprStaticBlock.js] +(function Reflect() { + class C extends B { + static { super.w(); } + } +}); +export {}; diff --git a/tests/baselines/reference/thisAndSuperInStaticMembers1(target=es2015).js b/tests/baselines/reference/thisAndSuperInStaticMembers1(target=es2015).js index 6c766ee87a600..ac2117eac8042 100644 --- a/tests/baselines/reference/thisAndSuperInStaticMembers1(target=es2015).js +++ b/tests/baselines/reference/thisAndSuperInStaticMembers1(target=es2015).js @@ -36,7 +36,8 @@ class C extends B { x = 1; y = this.x; z = super.f(); -} +} + //// [thisAndSuperInStaticMembers1.js] var __rest = (this && this.__rest) || function (s, e) { diff --git a/tests/baselines/reference/thisAndSuperInStaticMembers1(target=es2022).js b/tests/baselines/reference/thisAndSuperInStaticMembers1(target=es2022).js new file mode 100644 index 0000000000000..f100627421134 --- /dev/null +++ b/tests/baselines/reference/thisAndSuperInStaticMembers1(target=es2022).js @@ -0,0 +1,72 @@ +//// [thisAndSuperInStaticMembers1.ts] +declare class B { + static a: any; + static f(): number; + a: number; + f(): number; +} + +class C extends B { + static x: any = undefined!; + static y1 = this.x; + static y2 = this.x(); + static y3 = this?.x(); + static y4 = this[("x")](); + static y5 = this?.[("x")](); + static z1 = super.a; + static z2 = super["a"]; + static z3 = super.f(); + static z4 = super["f"](); + static z5 = super.a = 0; + static z6 = super.a += 1; + static z7 = (() => { super.a = 0; })(); + static z8 = [super.a] = [0]; + static z9 = [super.a = 0] = [0]; + static z10 = [...super.a] = [0]; + static z11 = { x: super.a } = { x: 0 }; + static z12 = { x: super.a = 0 } = { x: 0 }; + static z13 = { ...super.a } = { x: 0 }; + static z14 = ++super.a; + static z15 = --super.a; + static z16 = ++super[("a")]; + static z17 = super.a++; + static z18 = super.a``; + + // these should be unaffected + x = 1; + y = this.x; + z = super.f(); +} + + +//// [thisAndSuperInStaticMembers1.js] +class C extends B { + static x = undefined; + static y1 = this.x; + static y2 = this.x(); + static y3 = this?.x(); + static y4 = this[("x")](); + static y5 = this?.[("x")](); + static z1 = super.a; + static z2 = super["a"]; + static z3 = super.f(); + static z4 = super["f"](); + static z5 = super.a = 0; + static z6 = super.a += 1; + static z7 = (() => { super.a = 0; })(); + static z8 = [super.a] = [0]; + static z9 = [super.a = 0] = [0]; + static z10 = [...super.a] = [0]; + static z11 = { x: super.a } = { x: 0 }; + static z12 = { x: super.a = 0 } = { x: 0 }; + static z13 = { ...super.a } = { x: 0 }; + static z14 = ++super.a; + static z15 = --super.a; + static z16 = ++super[("a")]; + static z17 = super.a++; + static z18 = super.a ``; + // these should be unaffected + x = 1; + y = this.x; + z = super.f(); +} diff --git a/tests/baselines/reference/thisAndSuperInStaticMembers1(target=esnext).js b/tests/baselines/reference/thisAndSuperInStaticMembers1(target=esnext).js index 8bf57ccac5ae9..f100627421134 100644 --- a/tests/baselines/reference/thisAndSuperInStaticMembers1(target=esnext).js +++ b/tests/baselines/reference/thisAndSuperInStaticMembers1(target=esnext).js @@ -36,7 +36,8 @@ class C extends B { x = 1; y = this.x; z = super.f(); -} +} + //// [thisAndSuperInStaticMembers1.js] class C extends B { diff --git a/tests/baselines/reference/thisAndSuperInStaticMembers2(target=es2015).js b/tests/baselines/reference/thisAndSuperInStaticMembers2(target=es2015).js index 62f9e180aecb6..93c7ec5d7e46c 100644 --- a/tests/baselines/reference/thisAndSuperInStaticMembers2(target=es2015).js +++ b/tests/baselines/reference/thisAndSuperInStaticMembers2(target=es2015).js @@ -36,7 +36,8 @@ class C extends B { x = 1; y = this.x; z = super.f(); -} +} + //// [thisAndSuperInStaticMembers2.js] var __rest = (this && this.__rest) || function (s, e) { diff --git a/tests/baselines/reference/thisAndSuperInStaticMembers2(target=es2022).js b/tests/baselines/reference/thisAndSuperInStaticMembers2(target=es2022).js new file mode 100644 index 0000000000000..742fa6b656a60 --- /dev/null +++ b/tests/baselines/reference/thisAndSuperInStaticMembers2(target=es2022).js @@ -0,0 +1,77 @@ +//// [thisAndSuperInStaticMembers2.ts] +declare class B { + static a: any; + static f(): number; + a: number; + f(): number; +} + +class C extends B { + static x: any = undefined!; + static y1 = this.x; + static y2 = this.x(); + static y3 = this?.x(); + static y4 = this[("x")](); + static y5 = this?.[("x")](); + static z1 = super.a; + static z2 = super["a"]; + static z3 = super.f(); + static z4 = super["f"](); + static z5 = super.a = 0; + static z6 = super.a += 1; + static z7 = (() => { super.a = 0; })(); + static z8 = [super.a] = [0]; + static z9 = [super.a = 0] = [0]; + static z10 = [...super.a] = [0]; + static z11 = { x: super.a } = { x: 0 }; + static z12 = { x: super.a = 0 } = { x: 0 }; + static z13 = { ...super.a } = { x: 0 }; + static z14 = ++super.a; + static z15 = --super.a; + static z16 = ++super[("a")]; + static z17 = super.a++; + static z18 = super.a``; + + // these should be unaffected + x = 1; + y = this.x; + z = super.f(); +} + + +//// [thisAndSuperInStaticMembers2.js] +var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o; +class C extends (_b = B) { + constructor() { + super(...arguments); + // these should be unaffected + this.x = 1; + this.y = this.x; + this.z = super.f(); + } +} +_a = C; +C.x = undefined; +C.y1 = _a.x; +C.y2 = _a.x(); +C.y3 = _a?.x(); +C.y4 = _a[("x")](); +C.y5 = _a?.[("x")](); +C.z1 = Reflect.get(_b, "a", _a); +C.z2 = Reflect.get(_b, "a", _a); +C.z3 = Reflect.get(_b, "f", _a).call(_a); +C.z4 = Reflect.get(_b, "f", _a).call(_a); +C.z5 = (Reflect.set(_b, "a", _c = 0, _a), _c); +C.z6 = (Reflect.set(_b, "a", _d = Reflect.get(_b, "a", _a) + 1, _a), _d); +C.z7 = (() => { Reflect.set(_b, "a", 0, _a); })(); +C.z8 = [({ set value(_c) { Reflect.set(_b, "a", _c, _a); } }).value] = [0]; +C.z9 = [({ set value(_c) { Reflect.set(_b, "a", _c, _a); } }).value = 0] = [0]; +C.z10 = [...({ set value(_c) { Reflect.set(_b, "a", _c, _a); } }).value] = [0]; +C.z11 = { x: ({ set value(_c) { Reflect.set(_b, "a", _c, _a); } }).value } = { x: 0 }; +C.z12 = { x: ({ set value(_c) { Reflect.set(_b, "a", _c, _a); } }).value = 0 } = { x: 0 }; +C.z13 = { ...({ set value(_c) { Reflect.set(_b, "a", _c, _a); } }).value } = { x: 0 }; +C.z14 = (Reflect.set(_b, "a", (_f = Reflect.get(_b, "a", _a), _e = ++_f), _a), _e); +C.z15 = (Reflect.set(_b, "a", (_h = Reflect.get(_b, "a", _a), _g = --_h), _a), _g); +C.z16 = (Reflect.set(_b, _j = ("a"), (_l = Reflect.get(_b, _j, _a), _k = ++_l), _a), _k); +C.z17 = (Reflect.set(_b, "a", (_o = Reflect.get(_b, "a", _a), _m = _o++, _o), _a), _m); +C.z18 = Reflect.get(_b, "a", _a).bind(_a) ``; diff --git a/tests/baselines/reference/thisAndSuperInStaticMembers2(target=esnext).js b/tests/baselines/reference/thisAndSuperInStaticMembers2(target=esnext).js index d29dc7a000638..742fa6b656a60 100644 --- a/tests/baselines/reference/thisAndSuperInStaticMembers2(target=esnext).js +++ b/tests/baselines/reference/thisAndSuperInStaticMembers2(target=esnext).js @@ -36,7 +36,8 @@ class C extends B { x = 1; y = this.x; z = super.f(); -} +} + //// [thisAndSuperInStaticMembers2.js] var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o; diff --git a/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).errors.txt b/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).errors.txt new file mode 100644 index 0000000000000..be9735d6cd4ee --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).errors.txt @@ -0,0 +1,63 @@ +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts(6,16): error TS2816: Cannot use 'this' in a static property initializer of a decorated class. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts(12,16): error TS2816: Cannot use 'this' in a static property initializer of a decorated class. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts(13,26): error TS2816: Cannot use 'this' in a static property initializer of a decorated class. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts(14,22): error TS2816: Cannot use 'this' in a static property initializer of a decorated class. + + +==== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts (4 errors) ==== + declare const foo: any; + + @foo + class C { + static a = 1; + static b = this.a + 1; + ~~~~ +!!! error TS2816: Cannot use 'this' in a static property initializer of a decorated class. + } + + @foo + class D extends C { + static c = 2; + static d = this.c + 1; + ~~~~ +!!! error TS2816: Cannot use 'this' in a static property initializer of a decorated class. + static e = super.a + this.c + 1; + ~~~~ +!!! error TS2816: Cannot use 'this' in a static property initializer of a decorated class. + static f = () => this.c + 1; + ~~~~ +!!! error TS2816: Cannot use 'this' in a static property initializer of a decorated class. + static ff = function () { this.c + 1 } + static foo () { + return this.c + 1; + } + static get fa () { + return this.c + 1; + } + static set fa (v: number) { + this.c = v + 1; + } + } + + class CC { + static a = 1; + static b = this.a + 1; + } + + class DD extends CC { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; + static f = () => this.c + 1; + static ff = function () { this.c + 1 } + static foo () { + return this.c + 1; + } + static get fa () { + return this.c + 1; + } + static set fa (v: number) { + this.c = v + 1; + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).js b/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).js new file mode 100644 index 0000000000000..a45a5c9915488 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).js @@ -0,0 +1,106 @@ +//// [typeOfThisInStaticMembers10.ts] +declare const foo: any; + +@foo +class C { + static a = 1; + static b = this.a + 1; +} + +@foo +class D extends C { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; + static f = () => this.c + 1; + static ff = function () { this.c + 1 } + static foo () { + return this.c + 1; + } + static get fa () { + return this.c + 1; + } + static set fa (v: number) { + this.c = v + 1; + } +} + +class CC { + static a = 1; + static b = this.a + 1; +} + +class DD extends CC { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; + static f = () => this.c + 1; + static ff = function () { this.c + 1 } + static foo () { + return this.c + 1; + } + static get fa () { + return this.c + 1; + } + static set fa (v: number) { + this.c = v + 1; + } +} + + +//// [typeOfThisInStaticMembers10.js] +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +var _a, _b, _c; +let C = class C { +}; +C.a = 1; +C.b = (void 0).a + 1; +C = __decorate([ + foo +], C); +let D = class D extends C { + static foo() { + return this.c + 1; + } + static get fa() { + return this.c + 1; + } + static set fa(v) { + this.c = v + 1; + } +}; +D.c = 2; +D.d = (void 0).c + 1; +D.e = (void 0).a + (void 0).c + 1; +D.f = () => (void 0).c + 1; +D.ff = function () { this.c + 1; }; +D = __decorate([ + foo +], D); +class CC { +} +_a = CC; +CC.a = 1; +CC.b = _a.a + 1; +class DD extends (_c = CC) { + static foo() { + return this.c + 1; + } + static get fa() { + return this.c + 1; + } + static set fa(v) { + this.c = v + 1; + } +} +_b = DD; +DD.c = 2; +DD.d = _b.c + 1; +DD.e = Reflect.get(_c, "a", _b) + _b.c + 1; +DD.f = () => _b.c + 1; +DD.ff = function () { this.c + 1; }; diff --git a/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).symbols new file mode 100644 index 0000000000000..32b2ea3fd4926 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).symbols @@ -0,0 +1,154 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts === +declare const foo: any; +>foo : Symbol(foo, Decl(typeOfThisInStaticMembers10.ts, 0, 13)) + +@foo +>foo : Symbol(foo, Decl(typeOfThisInStaticMembers10.ts, 0, 13)) + +class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers10.ts, 0, 23)) + + static a = 1; +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers10.ts, 3, 9)) + + static b = this.a + 1; +>b : Symbol(C.b, Decl(typeOfThisInStaticMembers10.ts, 4, 17)) +>this.a : Symbol(C.a, Decl(typeOfThisInStaticMembers10.ts, 3, 9)) +>this : Symbol(C, Decl(typeOfThisInStaticMembers10.ts, 0, 23)) +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers10.ts, 3, 9)) +} + +@foo +>foo : Symbol(foo, Decl(typeOfThisInStaticMembers10.ts, 0, 13)) + +class D extends C { +>D : Symbol(D, Decl(typeOfThisInStaticMembers10.ts, 6, 1)) +>C : Symbol(C, Decl(typeOfThisInStaticMembers10.ts, 0, 23)) + + static c = 2; +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) + + static d = this.c + 1; +>d : Symbol(D.d, Decl(typeOfThisInStaticMembers10.ts, 10, 17)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers10.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) + + static e = super.a + this.c + 1; +>e : Symbol(D.e, Decl(typeOfThisInStaticMembers10.ts, 11, 26)) +>super.a : Symbol(C.a, Decl(typeOfThisInStaticMembers10.ts, 3, 9)) +>super : Symbol(C, Decl(typeOfThisInStaticMembers10.ts, 0, 23)) +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers10.ts, 3, 9)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers10.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) + + static f = () => this.c + 1; +>f : Symbol(D.f, Decl(typeOfThisInStaticMembers10.ts, 12, 36)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers10.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) + + static ff = function () { this.c + 1 } +>ff : Symbol(D.ff, Decl(typeOfThisInStaticMembers10.ts, 13, 32)) + + static foo () { +>foo : Symbol(D.foo, Decl(typeOfThisInStaticMembers10.ts, 14, 42)) + + return this.c + 1; +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers10.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) + } + static get fa () { +>fa : Symbol(D.fa, Decl(typeOfThisInStaticMembers10.ts, 17, 5), Decl(typeOfThisInStaticMembers10.ts, 20, 5)) + + return this.c + 1; +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers10.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) + } + static set fa (v: number) { +>fa : Symbol(D.fa, Decl(typeOfThisInStaticMembers10.ts, 17, 5), Decl(typeOfThisInStaticMembers10.ts, 20, 5)) +>v : Symbol(v, Decl(typeOfThisInStaticMembers10.ts, 21, 19)) + + this.c = v + 1; +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers10.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers10.ts, 9, 19)) +>v : Symbol(v, Decl(typeOfThisInStaticMembers10.ts, 21, 19)) + } +} + +class CC { +>CC : Symbol(CC, Decl(typeOfThisInStaticMembers10.ts, 24, 1)) + + static a = 1; +>a : Symbol(CC.a, Decl(typeOfThisInStaticMembers10.ts, 26, 10)) + + static b = this.a + 1; +>b : Symbol(CC.b, Decl(typeOfThisInStaticMembers10.ts, 27, 17)) +>this.a : Symbol(CC.a, Decl(typeOfThisInStaticMembers10.ts, 26, 10)) +>this : Symbol(CC, Decl(typeOfThisInStaticMembers10.ts, 24, 1)) +>a : Symbol(CC.a, Decl(typeOfThisInStaticMembers10.ts, 26, 10)) +} + +class DD extends CC { +>DD : Symbol(DD, Decl(typeOfThisInStaticMembers10.ts, 29, 1)) +>CC : Symbol(CC, Decl(typeOfThisInStaticMembers10.ts, 24, 1)) + + static c = 2; +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) + + static d = this.c + 1; +>d : Symbol(DD.d, Decl(typeOfThisInStaticMembers10.ts, 32, 17)) +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers10.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) + + static e = super.a + this.c + 1; +>e : Symbol(DD.e, Decl(typeOfThisInStaticMembers10.ts, 33, 26)) +>super.a : Symbol(CC.a, Decl(typeOfThisInStaticMembers10.ts, 26, 10)) +>super : Symbol(CC, Decl(typeOfThisInStaticMembers10.ts, 24, 1)) +>a : Symbol(CC.a, Decl(typeOfThisInStaticMembers10.ts, 26, 10)) +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers10.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) + + static f = () => this.c + 1; +>f : Symbol(DD.f, Decl(typeOfThisInStaticMembers10.ts, 34, 36)) +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers10.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) + + static ff = function () { this.c + 1 } +>ff : Symbol(DD.ff, Decl(typeOfThisInStaticMembers10.ts, 35, 32)) + + static foo () { +>foo : Symbol(DD.foo, Decl(typeOfThisInStaticMembers10.ts, 36, 42)) + + return this.c + 1; +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers10.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) + } + static get fa () { +>fa : Symbol(DD.fa, Decl(typeOfThisInStaticMembers10.ts, 39, 5), Decl(typeOfThisInStaticMembers10.ts, 42, 5)) + + return this.c + 1; +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers10.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) + } + static set fa (v: number) { +>fa : Symbol(DD.fa, Decl(typeOfThisInStaticMembers10.ts, 39, 5), Decl(typeOfThisInStaticMembers10.ts, 42, 5)) +>v : Symbol(v, Decl(typeOfThisInStaticMembers10.ts, 43, 19)) + + this.c = v + 1; +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers10.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers10.ts, 31, 21)) +>v : Symbol(v, Decl(typeOfThisInStaticMembers10.ts, 43, 19)) + } +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).types b/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).types new file mode 100644 index 0000000000000..824241e883d28 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers10(target=es2022).types @@ -0,0 +1,204 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts === +declare const foo: any; +>foo : any + +@foo +>foo : any + +class C { +>C : C + + static a = 1; +>a : number +>1 : 1 + + static b = this.a + 1; +>b : number +>this.a + 1 : number +>this.a : number +>this : typeof C +>a : number +>1 : 1 +} + +@foo +>foo : any + +class D extends C { +>D : D +>C : C + + static c = 2; +>c : number +>2 : 2 + + static d = this.c + 1; +>d : number +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + + static e = super.a + this.c + 1; +>e : number +>super.a + this.c + 1 : number +>super.a + this.c : number +>super.a : number +>super : typeof C +>a : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + + static f = () => this.c + 1; +>f : () => number +>() => this.c + 1 : () => number +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + + static ff = function () { this.c + 1 } +>ff : () => void +>function () { this.c + 1 } : () => void +>this.c + 1 : any +>this.c : any +>this : any +>c : any +>1 : 1 + + static foo () { +>foo : () => number + + return this.c + 1; +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + } + static get fa () { +>fa : number + + return this.c + 1; +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + } + static set fa (v: number) { +>fa : number +>v : number + + this.c = v + 1; +>this.c = v + 1 : number +>this.c : number +>this : typeof D +>c : number +>v + 1 : number +>v : number +>1 : 1 + } +} + +class CC { +>CC : CC + + static a = 1; +>a : number +>1 : 1 + + static b = this.a + 1; +>b : number +>this.a + 1 : number +>this.a : number +>this : typeof CC +>a : number +>1 : 1 +} + +class DD extends CC { +>DD : DD +>CC : CC + + static c = 2; +>c : number +>2 : 2 + + static d = this.c + 1; +>d : number +>this.c + 1 : number +>this.c : number +>this : typeof DD +>c : number +>1 : 1 + + static e = super.a + this.c + 1; +>e : number +>super.a + this.c + 1 : number +>super.a + this.c : number +>super.a : number +>super : typeof CC +>a : number +>this.c : number +>this : typeof DD +>c : number +>1 : 1 + + static f = () => this.c + 1; +>f : () => number +>() => this.c + 1 : () => number +>this.c + 1 : number +>this.c : number +>this : typeof DD +>c : number +>1 : 1 + + static ff = function () { this.c + 1 } +>ff : () => void +>function () { this.c + 1 } : () => void +>this.c + 1 : any +>this.c : any +>this : any +>c : any +>1 : 1 + + static foo () { +>foo : () => number + + return this.c + 1; +>this.c + 1 : number +>this.c : number +>this : typeof DD +>c : number +>1 : 1 + } + static get fa () { +>fa : number + + return this.c + 1; +>this.c + 1 : number +>this.c : number +>this : typeof DD +>c : number +>1 : 1 + } + static set fa (v: number) { +>fa : number +>v : number + + this.c = v + 1; +>this.c = v + 1 : number +>this.c : number +>this : typeof DD +>c : number +>v + 1 : number +>v : number +>1 : 1 + } +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).errors.txt b/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).errors.txt new file mode 100644 index 0000000000000..2e699c701e689 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).errors.txt @@ -0,0 +1,63 @@ +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts(6,16): error TS2816: Cannot use 'this' in a static property initializer of a decorated class. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts(12,16): error TS2816: Cannot use 'this' in a static property initializer of a decorated class. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts(13,26): error TS2816: Cannot use 'this' in a static property initializer of a decorated class. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts(14,22): error TS2816: Cannot use 'this' in a static property initializer of a decorated class. + + +==== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts (4 errors) ==== + declare const foo: any; + + @foo + class C { + static a = 1; + static b = this.a + 1; + ~~~~ +!!! error TS2816: Cannot use 'this' in a static property initializer of a decorated class. + } + + @foo + class D extends C { + static c = 2; + static d = this.c + 1; + ~~~~ +!!! error TS2816: Cannot use 'this' in a static property initializer of a decorated class. + static e = super.a + this.c + 1; + ~~~~ +!!! error TS2816: Cannot use 'this' in a static property initializer of a decorated class. + static f = () => this.c + 1; + ~~~~ +!!! error TS2816: Cannot use 'this' in a static property initializer of a decorated class. + static ff = function () { this.c + 1 } + static foo () { + return this.c + 1; + } + static get fa () { + return this.c + 1; + } + static set fa (v: number) { + this.c = v + 1; + } + } + + class CC { + static a = 1; + static b = this.a + 1; + } + + class DD extends CC { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; + static f = () => this.c + 1; + static ff = function () { this.c + 1 } + static foo () { + return this.c + 1; + } + static get fa () { + return this.c + 1; + } + static set fa (v: number) { + this.c = v + 1; + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).js b/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).js new file mode 100644 index 0000000000000..3e3c578c3dde8 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).js @@ -0,0 +1,103 @@ +//// [typeOfThisInStaticMembers11.ts] +declare const foo: any; + +@foo +class C { + static a = 1; + static b = this.a + 1; +} + +@foo +class D extends C { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; + static f = () => this.c + 1; + static ff = function () { this.c + 1 } + static foo () { + return this.c + 1; + } + static get fa () { + return this.c + 1; + } + static set fa (v: number) { + this.c = v + 1; + } +} + +class CC { + static a = 1; + static b = this.a + 1; +} + +class DD extends CC { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; + static f = () => this.c + 1; + static ff = function () { this.c + 1 } + static foo () { + return this.c + 1; + } + static get fa () { + return this.c + 1; + } + static set fa (v: number) { + this.c = v + 1; + } +} + + +//// [typeOfThisInStaticMembers11.js] +var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) { + var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc); + else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; + return c > 3 && r && Object.defineProperty(target, key, r), r; +}; +let C = class C { + static a = 1; + static b = this.a + 1; +}; +C = __decorate([ + foo +], C); +let D = class D extends C { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; + static f = () => this.c + 1; + static ff = function () { this.c + 1; }; + static foo() { + return this.c + 1; + } + static get fa() { + return this.c + 1; + } + static set fa(v) { + this.c = v + 1; + } +}; +D = __decorate([ + foo +], D); +class CC { + static a = 1; + static b = this.a + 1; +} +class DD extends CC { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; + static f = () => this.c + 1; + static ff = function () { this.c + 1; }; + static foo() { + return this.c + 1; + } + static get fa() { + return this.c + 1; + } + static set fa(v) { + this.c = v + 1; + } +} diff --git a/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).symbols new file mode 100644 index 0000000000000..d1df5efc4080b --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).symbols @@ -0,0 +1,154 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts === +declare const foo: any; +>foo : Symbol(foo, Decl(typeOfThisInStaticMembers11.ts, 0, 13)) + +@foo +>foo : Symbol(foo, Decl(typeOfThisInStaticMembers11.ts, 0, 13)) + +class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers11.ts, 0, 23)) + + static a = 1; +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers11.ts, 3, 9)) + + static b = this.a + 1; +>b : Symbol(C.b, Decl(typeOfThisInStaticMembers11.ts, 4, 17)) +>this.a : Symbol(C.a, Decl(typeOfThisInStaticMembers11.ts, 3, 9)) +>this : Symbol(C, Decl(typeOfThisInStaticMembers11.ts, 0, 23)) +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers11.ts, 3, 9)) +} + +@foo +>foo : Symbol(foo, Decl(typeOfThisInStaticMembers11.ts, 0, 13)) + +class D extends C { +>D : Symbol(D, Decl(typeOfThisInStaticMembers11.ts, 6, 1)) +>C : Symbol(C, Decl(typeOfThisInStaticMembers11.ts, 0, 23)) + + static c = 2; +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) + + static d = this.c + 1; +>d : Symbol(D.d, Decl(typeOfThisInStaticMembers11.ts, 10, 17)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers11.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) + + static e = super.a + this.c + 1; +>e : Symbol(D.e, Decl(typeOfThisInStaticMembers11.ts, 11, 26)) +>super.a : Symbol(C.a, Decl(typeOfThisInStaticMembers11.ts, 3, 9)) +>super : Symbol(C, Decl(typeOfThisInStaticMembers11.ts, 0, 23)) +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers11.ts, 3, 9)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers11.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) + + static f = () => this.c + 1; +>f : Symbol(D.f, Decl(typeOfThisInStaticMembers11.ts, 12, 36)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers11.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) + + static ff = function () { this.c + 1 } +>ff : Symbol(D.ff, Decl(typeOfThisInStaticMembers11.ts, 13, 32)) + + static foo () { +>foo : Symbol(D.foo, Decl(typeOfThisInStaticMembers11.ts, 14, 42)) + + return this.c + 1; +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers11.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) + } + static get fa () { +>fa : Symbol(D.fa, Decl(typeOfThisInStaticMembers11.ts, 17, 5), Decl(typeOfThisInStaticMembers11.ts, 20, 5)) + + return this.c + 1; +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers11.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) + } + static set fa (v: number) { +>fa : Symbol(D.fa, Decl(typeOfThisInStaticMembers11.ts, 17, 5), Decl(typeOfThisInStaticMembers11.ts, 20, 5)) +>v : Symbol(v, Decl(typeOfThisInStaticMembers11.ts, 21, 19)) + + this.c = v + 1; +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers11.ts, 6, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers11.ts, 9, 19)) +>v : Symbol(v, Decl(typeOfThisInStaticMembers11.ts, 21, 19)) + } +} + +class CC { +>CC : Symbol(CC, Decl(typeOfThisInStaticMembers11.ts, 24, 1)) + + static a = 1; +>a : Symbol(CC.a, Decl(typeOfThisInStaticMembers11.ts, 26, 10)) + + static b = this.a + 1; +>b : Symbol(CC.b, Decl(typeOfThisInStaticMembers11.ts, 27, 17)) +>this.a : Symbol(CC.a, Decl(typeOfThisInStaticMembers11.ts, 26, 10)) +>this : Symbol(CC, Decl(typeOfThisInStaticMembers11.ts, 24, 1)) +>a : Symbol(CC.a, Decl(typeOfThisInStaticMembers11.ts, 26, 10)) +} + +class DD extends CC { +>DD : Symbol(DD, Decl(typeOfThisInStaticMembers11.ts, 29, 1)) +>CC : Symbol(CC, Decl(typeOfThisInStaticMembers11.ts, 24, 1)) + + static c = 2; +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) + + static d = this.c + 1; +>d : Symbol(DD.d, Decl(typeOfThisInStaticMembers11.ts, 32, 17)) +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers11.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) + + static e = super.a + this.c + 1; +>e : Symbol(DD.e, Decl(typeOfThisInStaticMembers11.ts, 33, 26)) +>super.a : Symbol(CC.a, Decl(typeOfThisInStaticMembers11.ts, 26, 10)) +>super : Symbol(CC, Decl(typeOfThisInStaticMembers11.ts, 24, 1)) +>a : Symbol(CC.a, Decl(typeOfThisInStaticMembers11.ts, 26, 10)) +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers11.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) + + static f = () => this.c + 1; +>f : Symbol(DD.f, Decl(typeOfThisInStaticMembers11.ts, 34, 36)) +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers11.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) + + static ff = function () { this.c + 1 } +>ff : Symbol(DD.ff, Decl(typeOfThisInStaticMembers11.ts, 35, 32)) + + static foo () { +>foo : Symbol(DD.foo, Decl(typeOfThisInStaticMembers11.ts, 36, 42)) + + return this.c + 1; +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers11.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) + } + static get fa () { +>fa : Symbol(DD.fa, Decl(typeOfThisInStaticMembers11.ts, 39, 5), Decl(typeOfThisInStaticMembers11.ts, 42, 5)) + + return this.c + 1; +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers11.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) + } + static set fa (v: number) { +>fa : Symbol(DD.fa, Decl(typeOfThisInStaticMembers11.ts, 39, 5), Decl(typeOfThisInStaticMembers11.ts, 42, 5)) +>v : Symbol(v, Decl(typeOfThisInStaticMembers11.ts, 43, 19)) + + this.c = v + 1; +>this.c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) +>this : Symbol(DD, Decl(typeOfThisInStaticMembers11.ts, 29, 1)) +>c : Symbol(DD.c, Decl(typeOfThisInStaticMembers11.ts, 31, 21)) +>v : Symbol(v, Decl(typeOfThisInStaticMembers11.ts, 43, 19)) + } +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).types b/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).types new file mode 100644 index 0000000000000..44ad35960ec92 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers11(target=es2022).types @@ -0,0 +1,204 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts === +declare const foo: any; +>foo : any + +@foo +>foo : any + +class C { +>C : C + + static a = 1; +>a : number +>1 : 1 + + static b = this.a + 1; +>b : number +>this.a + 1 : number +>this.a : number +>this : typeof C +>a : number +>1 : 1 +} + +@foo +>foo : any + +class D extends C { +>D : D +>C : C + + static c = 2; +>c : number +>2 : 2 + + static d = this.c + 1; +>d : number +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + + static e = super.a + this.c + 1; +>e : number +>super.a + this.c + 1 : number +>super.a + this.c : number +>super.a : number +>super : typeof C +>a : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + + static f = () => this.c + 1; +>f : () => number +>() => this.c + 1 : () => number +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + + static ff = function () { this.c + 1 } +>ff : () => void +>function () { this.c + 1 } : () => void +>this.c + 1 : any +>this.c : any +>this : any +>c : any +>1 : 1 + + static foo () { +>foo : () => number + + return this.c + 1; +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + } + static get fa () { +>fa : number + + return this.c + 1; +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + } + static set fa (v: number) { +>fa : number +>v : number + + this.c = v + 1; +>this.c = v + 1 : number +>this.c : number +>this : typeof D +>c : number +>v + 1 : number +>v : number +>1 : 1 + } +} + +class CC { +>CC : CC + + static a = 1; +>a : number +>1 : 1 + + static b = this.a + 1; +>b : number +>this.a + 1 : number +>this.a : number +>this : typeof CC +>a : number +>1 : 1 +} + +class DD extends CC { +>DD : DD +>CC : CC + + static c = 2; +>c : number +>2 : 2 + + static d = this.c + 1; +>d : number +>this.c + 1 : number +>this.c : number +>this : typeof DD +>c : number +>1 : 1 + + static e = super.a + this.c + 1; +>e : number +>super.a + this.c + 1 : number +>super.a + this.c : number +>super.a : number +>super : typeof CC +>a : number +>this.c : number +>this : typeof DD +>c : number +>1 : 1 + + static f = () => this.c + 1; +>f : () => number +>() => this.c + 1 : () => number +>this.c + 1 : number +>this.c : number +>this : typeof DD +>c : number +>1 : 1 + + static ff = function () { this.c + 1 } +>ff : () => void +>function () { this.c + 1 } : () => void +>this.c + 1 : any +>this.c : any +>this : any +>c : any +>1 : 1 + + static foo () { +>foo : () => number + + return this.c + 1; +>this.c + 1 : number +>this.c : number +>this : typeof DD +>c : number +>1 : 1 + } + static get fa () { +>fa : number + + return this.c + 1; +>this.c + 1 : number +>this.c : number +>this : typeof DD +>c : number +>1 : 1 + } + static set fa (v: number) { +>fa : number +>v : number + + this.c = v + 1; +>this.c = v + 1 : number +>this.c : number +>this : typeof DD +>c : number +>v + 1 : number +>v : number +>1 : 1 + } +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).errors.txt b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).errors.txt new file mode 100644 index 0000000000000..3855b2ee7b651 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).errors.txt @@ -0,0 +1,23 @@ +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts(4,16): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts(4,17): error TS2465: 'this' cannot be referenced in a computed property name. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts(5,9): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts(5,10): error TS2465: 'this' cannot be referenced in a computed property name. + + +==== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts (4 errors) ==== + class C { + static readonly c: "foo" = "foo" + static bar = class Inner { + static [this.c] = 123; + ~~~~~~~~ +!!! error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. + ~~~~ +!!! error TS2465: 'this' cannot be referenced in a computed property name. + [this.c] = 123; + ~~~~~~~~ +!!! error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. + ~~~~ +!!! error TS2465: 'this' cannot be referenced in a computed property name. + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).js b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).js new file mode 100644 index 0000000000000..59ce5132646d1 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).js @@ -0,0 +1,25 @@ +//// [typeOfThisInStaticMembers12.ts] +class C { + static readonly c: "foo" = "foo" + static bar = class Inner { + static [this.c] = 123; + [this.c] = 123; + } +} + + +//// [typeOfThisInStaticMembers12.js] +var _a, _b, _c, _d; +class C { +} +_a = C; +C.c = "foo"; +C.bar = (_b = class Inner { + constructor() { + this[_d] = 123; + } + }, + _c = _a.c, + _d = _a.c, + _b[_c] = 123, + _b); diff --git a/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).symbols new file mode 100644 index 0000000000000..16ad5c64fd0df --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts === +class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers12.ts, 0, 0)) + + static readonly c: "foo" = "foo" +>c : Symbol(C.c, Decl(typeOfThisInStaticMembers12.ts, 0, 9)) + + static bar = class Inner { +>bar : Symbol(C.bar, Decl(typeOfThisInStaticMembers12.ts, 1, 36)) +>Inner : Symbol(Inner, Decl(typeOfThisInStaticMembers12.ts, 2, 16)) + + static [this.c] = 123; +>[this.c] : Symbol(Inner[this.c], Decl(typeOfThisInStaticMembers12.ts, 2, 31)) + + [this.c] = 123; +>[this.c] : Symbol(Inner[this.c], Decl(typeOfThisInStaticMembers12.ts, 3, 30)) + } +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).types b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).types new file mode 100644 index 0000000000000..ca37b9e4e200e --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers12(target=es2022).types @@ -0,0 +1,29 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts === +class C { +>C : C + + static readonly c: "foo" = "foo" +>c : "foo" +>"foo" : "foo" + + static bar = class Inner { +>bar : typeof Inner +>class Inner { static [this.c] = 123; [this.c] = 123; } : typeof Inner +>Inner : typeof Inner + + static [this.c] = 123; +>[this.c] : number +>this.c : any +>this : any +>c : any +>123 : 123 + + [this.c] = 123; +>[this.c] : number +>this.c : any +>this : any +>c : any +>123 : 123 + } +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).errors.txt b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).errors.txt new file mode 100644 index 0000000000000..804765ba1290d --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).errors.txt @@ -0,0 +1,23 @@ +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts(4,16): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts(4,17): error TS2465: 'this' cannot be referenced in a computed property name. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts(5,9): error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts(5,10): error TS2465: 'this' cannot be referenced in a computed property name. + + +==== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts (4 errors) ==== + class C { + static readonly c: "foo" = "foo" + static bar = class Inner { + static [this.c] = 123; + ~~~~~~~~ +!!! error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. + ~~~~ +!!! error TS2465: 'this' cannot be referenced in a computed property name. + [this.c] = 123; + ~~~~~~~~ +!!! error TS1166: A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type. + ~~~~ +!!! error TS2465: 'this' cannot be referenced in a computed property name. + } + } + \ No newline at end of file diff --git a/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).js b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).js new file mode 100644 index 0000000000000..400f037855480 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).js @@ -0,0 +1,18 @@ +//// [typeOfThisInStaticMembers13.ts] +class C { + static readonly c: "foo" = "foo" + static bar = class Inner { + static [this.c] = 123; + [this.c] = 123; + } +} + + +//// [typeOfThisInStaticMembers13.js] +class C { + static c = "foo"; + static bar = class Inner { + static [this.c] = 123; + [this.c] = 123; + }; +} diff --git a/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).symbols new file mode 100644 index 0000000000000..806a34350b5b9 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).symbols @@ -0,0 +1,19 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts === +class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers13.ts, 0, 0)) + + static readonly c: "foo" = "foo" +>c : Symbol(C.c, Decl(typeOfThisInStaticMembers13.ts, 0, 9)) + + static bar = class Inner { +>bar : Symbol(C.bar, Decl(typeOfThisInStaticMembers13.ts, 1, 36)) +>Inner : Symbol(Inner, Decl(typeOfThisInStaticMembers13.ts, 2, 16)) + + static [this.c] = 123; +>[this.c] : Symbol(Inner[this.c], Decl(typeOfThisInStaticMembers13.ts, 2, 31)) + + [this.c] = 123; +>[this.c] : Symbol(Inner[this.c], Decl(typeOfThisInStaticMembers13.ts, 3, 30)) + } +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).types b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).types new file mode 100644 index 0000000000000..bb274c6f556e7 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers13(target=es2022).types @@ -0,0 +1,29 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts === +class C { +>C : C + + static readonly c: "foo" = "foo" +>c : "foo" +>"foo" : "foo" + + static bar = class Inner { +>bar : typeof Inner +>class Inner { static [this.c] = 123; [this.c] = 123; } : typeof Inner +>Inner : typeof Inner + + static [this.c] = 123; +>[this.c] : number +>this.c : any +>this : any +>c : any +>123 : 123 + + [this.c] = 123; +>[this.c] : number +>this.c : any +>this : any +>c : any +>123 : 123 + } +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers3(target=es2022).js b/tests/baselines/reference/typeOfThisInStaticMembers3(target=es2022).js new file mode 100644 index 0000000000000..ac5018106c0f7 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers3(target=es2022).js @@ -0,0 +1,26 @@ +//// [typeOfThisInStaticMembers3.ts] +class C { + static a = 1; + static b = this.a + 1; +} + +class D extends C { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; +} + + +//// [typeOfThisInStaticMembers3.js] +var _a, _b, _c; +class C { +} +_a = C; +C.a = 1; +C.b = _a.a + 1; +class D extends (_c = C) { +} +_b = D; +D.c = 2; +D.d = _b.c + 1; +D.e = Reflect.get(_c, "a", _b) + _b.c + 1; diff --git a/tests/baselines/reference/typeOfThisInStaticMembers3(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers3(target=es2022).symbols new file mode 100644 index 0000000000000..bfd5a942122f0 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers3(target=es2022).symbols @@ -0,0 +1,37 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers3.ts === +class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers3.ts, 0, 0)) + + static a = 1; +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers3.ts, 0, 9)) + + static b = this.a + 1; +>b : Symbol(C.b, Decl(typeOfThisInStaticMembers3.ts, 1, 17)) +>this.a : Symbol(C.a, Decl(typeOfThisInStaticMembers3.ts, 0, 9)) +>this : Symbol(C, Decl(typeOfThisInStaticMembers3.ts, 0, 0)) +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers3.ts, 0, 9)) +} + +class D extends C { +>D : Symbol(D, Decl(typeOfThisInStaticMembers3.ts, 3, 1)) +>C : Symbol(C, Decl(typeOfThisInStaticMembers3.ts, 0, 0)) + + static c = 2; +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers3.ts, 5, 19)) + + static d = this.c + 1; +>d : Symbol(D.d, Decl(typeOfThisInStaticMembers3.ts, 6, 17)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers3.ts, 5, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers3.ts, 3, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers3.ts, 5, 19)) + + static e = super.a + this.c + 1; +>e : Symbol(D.e, Decl(typeOfThisInStaticMembers3.ts, 7, 26)) +>super.a : Symbol(C.a, Decl(typeOfThisInStaticMembers3.ts, 0, 9)) +>super : Symbol(C, Decl(typeOfThisInStaticMembers3.ts, 0, 0)) +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers3.ts, 0, 9)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers3.ts, 5, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers3.ts, 3, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers3.ts, 5, 19)) +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers3(target=es2022).types b/tests/baselines/reference/typeOfThisInStaticMembers3(target=es2022).types new file mode 100644 index 0000000000000..9af87449fff5c --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers3(target=es2022).types @@ -0,0 +1,46 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers3.ts === +class C { +>C : C + + static a = 1; +>a : number +>1 : 1 + + static b = this.a + 1; +>b : number +>this.a + 1 : number +>this.a : number +>this : typeof C +>a : number +>1 : 1 +} + +class D extends C { +>D : D +>C : C + + static c = 2; +>c : number +>2 : 2 + + static d = this.c + 1; +>d : number +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + + static e = super.a + this.c + 1; +>e : number +>super.a + this.c + 1 : number +>super.a + this.c : number +>super.a : number +>super : typeof C +>a : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers4(target=es2022).js b/tests/baselines/reference/typeOfThisInStaticMembers4(target=es2022).js new file mode 100644 index 0000000000000..1d64a21910e21 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers4(target=es2022).js @@ -0,0 +1,23 @@ +//// [typeOfThisInStaticMembers4.ts] +class C { + static a = 1; + static b = this.a + 1; +} + +class D extends C { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; +} + + +//// [typeOfThisInStaticMembers4.js] +class C { + static a = 1; + static b = this.a + 1; +} +class D extends C { + static c = 2; + static d = this.c + 1; + static e = super.a + this.c + 1; +} diff --git a/tests/baselines/reference/typeOfThisInStaticMembers4(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers4(target=es2022).symbols new file mode 100644 index 0000000000000..90e4f31f37107 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers4(target=es2022).symbols @@ -0,0 +1,37 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers4.ts === +class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers4.ts, 0, 0)) + + static a = 1; +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers4.ts, 0, 9)) + + static b = this.a + 1; +>b : Symbol(C.b, Decl(typeOfThisInStaticMembers4.ts, 1, 17)) +>this.a : Symbol(C.a, Decl(typeOfThisInStaticMembers4.ts, 0, 9)) +>this : Symbol(C, Decl(typeOfThisInStaticMembers4.ts, 0, 0)) +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers4.ts, 0, 9)) +} + +class D extends C { +>D : Symbol(D, Decl(typeOfThisInStaticMembers4.ts, 3, 1)) +>C : Symbol(C, Decl(typeOfThisInStaticMembers4.ts, 0, 0)) + + static c = 2; +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers4.ts, 5, 19)) + + static d = this.c + 1; +>d : Symbol(D.d, Decl(typeOfThisInStaticMembers4.ts, 6, 17)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers4.ts, 5, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers4.ts, 3, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers4.ts, 5, 19)) + + static e = super.a + this.c + 1; +>e : Symbol(D.e, Decl(typeOfThisInStaticMembers4.ts, 7, 26)) +>super.a : Symbol(C.a, Decl(typeOfThisInStaticMembers4.ts, 0, 9)) +>super : Symbol(C, Decl(typeOfThisInStaticMembers4.ts, 0, 0)) +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers4.ts, 0, 9)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers4.ts, 5, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers4.ts, 3, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers4.ts, 5, 19)) +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers4(target=es2022).types b/tests/baselines/reference/typeOfThisInStaticMembers4(target=es2022).types new file mode 100644 index 0000000000000..547768640b1e9 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers4(target=es2022).types @@ -0,0 +1,46 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers4.ts === +class C { +>C : C + + static a = 1; +>a : number +>1 : 1 + + static b = this.a + 1; +>b : number +>this.a + 1 : number +>this.a : number +>this : typeof C +>a : number +>1 : 1 +} + +class D extends C { +>D : D +>C : C + + static c = 2; +>c : number +>2 : 2 + + static d = this.c + 1; +>d : number +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + + static e = super.a + this.c + 1; +>e : number +>super.a + this.c + 1 : number +>super.a + this.c : number +>super.a : number +>super : typeof C +>a : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers5(target=es2022).js b/tests/baselines/reference/typeOfThisInStaticMembers5(target=es2022).js new file mode 100644 index 0000000000000..3c08a270550a6 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers5(target=es2022).js @@ -0,0 +1,18 @@ +//// [typeOfThisInStaticMembers5.ts] +class C { + static create = () => new this("yep") + + constructor (private foo: string) { + + } +} + + +//// [typeOfThisInStaticMembers5.js] +class C { + foo; + static create = () => new this("yep"); + constructor(foo) { + this.foo = foo; + } +} diff --git a/tests/baselines/reference/typeOfThisInStaticMembers5(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers5(target=es2022).symbols new file mode 100644 index 0000000000000..cb65daa136c32 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers5(target=es2022).symbols @@ -0,0 +1,14 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers5.ts === +class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers5.ts, 0, 0)) + + static create = () => new this("yep") +>create : Symbol(C.create, Decl(typeOfThisInStaticMembers5.ts, 0, 9)) +>this : Symbol(C, Decl(typeOfThisInStaticMembers5.ts, 0, 0)) + + constructor (private foo: string) { +>foo : Symbol(C.foo, Decl(typeOfThisInStaticMembers5.ts, 3, 17)) + + } +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers5(target=es2022).types b/tests/baselines/reference/typeOfThisInStaticMembers5(target=es2022).types new file mode 100644 index 0000000000000..63650b490ca90 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers5(target=es2022).types @@ -0,0 +1,17 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers5.ts === +class C { +>C : C + + static create = () => new this("yep") +>create : () => C +>() => new this("yep") : () => C +>new this("yep") : C +>this : typeof C +>"yep" : "yep" + + constructor (private foo: string) { +>foo : string + + } +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).js b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).js new file mode 100644 index 0000000000000..7e5d0bc0f819c --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).js @@ -0,0 +1,23 @@ +//// [typeOfThisInStaticMembers7.ts] +class C { + static a = 1; + static b = this.a + 1; +} + +class D extends C { + static c = 2; + static d = this.c + 1; + static e = 1 + (super.a) + (this.c + 1) + 1; +} + + +//// [typeOfThisInStaticMembers7.js] +class C { + static a = 1; + static b = this.a + 1; +} +class D extends C { + static c = 2; + static d = this.c + 1; + static e = 1 + (super.a) + (this.c + 1) + 1; +} diff --git a/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).symbols new file mode 100644 index 0000000000000..dfc319293d7ac --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).symbols @@ -0,0 +1,37 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers7.ts === +class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers7.ts, 0, 0)) + + static a = 1; +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9)) + + static b = this.a + 1; +>b : Symbol(C.b, Decl(typeOfThisInStaticMembers7.ts, 1, 17)) +>this.a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9)) +>this : Symbol(C, Decl(typeOfThisInStaticMembers7.ts, 0, 0)) +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9)) +} + +class D extends C { +>D : Symbol(D, Decl(typeOfThisInStaticMembers7.ts, 3, 1)) +>C : Symbol(C, Decl(typeOfThisInStaticMembers7.ts, 0, 0)) + + static c = 2; +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers7.ts, 5, 19)) + + static d = this.c + 1; +>d : Symbol(D.d, Decl(typeOfThisInStaticMembers7.ts, 6, 17)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers7.ts, 5, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers7.ts, 3, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers7.ts, 5, 19)) + + static e = 1 + (super.a) + (this.c + 1) + 1; +>e : Symbol(D.e, Decl(typeOfThisInStaticMembers7.ts, 7, 26)) +>super.a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9)) +>super : Symbol(C, Decl(typeOfThisInStaticMembers7.ts, 0, 0)) +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers7.ts, 0, 9)) +>this.c : Symbol(D.c, Decl(typeOfThisInStaticMembers7.ts, 5, 19)) +>this : Symbol(D, Decl(typeOfThisInStaticMembers7.ts, 3, 1)) +>c : Symbol(D.c, Decl(typeOfThisInStaticMembers7.ts, 5, 19)) +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).types b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).types new file mode 100644 index 0000000000000..23f7b690e1d51 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers7(target=es2022).types @@ -0,0 +1,52 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers7.ts === +class C { +>C : C + + static a = 1; +>a : number +>1 : 1 + + static b = this.a + 1; +>b : number +>this.a + 1 : number +>this.a : number +>this : typeof C +>a : number +>1 : 1 +} + +class D extends C { +>D : D +>C : C + + static c = 2; +>c : number +>2 : 2 + + static d = this.c + 1; +>d : number +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 + + static e = 1 + (super.a) + (this.c + 1) + 1; +>e : number +>1 + (super.a) + (this.c + 1) + 1 : number +>1 + (super.a) + (this.c + 1) : number +>1 + (super.a) : number +>1 : 1 +>(super.a) : number +>super.a : number +>super : typeof C +>a : number +>(this.c + 1) : number +>this.c + 1 : number +>this.c : number +>this : typeof D +>c : number +>1 : 1 +>1 : 1 +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).errors.txt b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).errors.txt new file mode 100644 index 0000000000000..072f38100cfc6 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).errors.txt @@ -0,0 +1,30 @@ +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers8.ts(5,49): error TS2339: Property 'f' does not exist on type '(Anonymous class)'. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers8.ts(11,22): error TS2339: Property 'f' does not exist on type 'CC'. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers8.ts(13,29): error TS2339: Property 'f' does not exist on type 'CC'. + + +==== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers8.ts (3 errors) ==== + class C { + static f = 1; + static arrowFunctionBoundary = () => this.f + 1; + static functionExprBoundary = function () { return this.f + 2 }; + static classExprBoundary = class { a = this.f + 3 }; + ~ +!!! error TS2339: Property 'f' does not exist on type '(Anonymous class)'. + static functionAndClassDeclBoundary = (() => { + function foo () { + return this.f + 4 + } + class CC { + a = this.f + 5 + ~ +!!! error TS2339: Property 'f' does not exist on type 'CC'. + method () { + return this.f + 6 + ~ +!!! error TS2339: Property 'f' does not exist on type 'CC'. + } + } + })(); + } + \ No newline at end of file diff --git a/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).js b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).js new file mode 100644 index 0000000000000..6d0e04fe18c71 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).js @@ -0,0 +1,40 @@ +//// [typeOfThisInStaticMembers8.ts] +class C { + static f = 1; + static arrowFunctionBoundary = () => this.f + 1; + static functionExprBoundary = function () { return this.f + 2 }; + static classExprBoundary = class { a = this.f + 3 }; + static functionAndClassDeclBoundary = (() => { + function foo () { + return this.f + 4 + } + class CC { + a = this.f + 5 + method () { + return this.f + 6 + } + } + })(); +} + + +//// [typeOfThisInStaticMembers8.js] +class C { + static f = 1; + static arrowFunctionBoundary = () => this.f + 1; + static functionExprBoundary = function () { return this.f + 2; }; + static classExprBoundary = class { + a = this.f + 3; + }; + static functionAndClassDeclBoundary = (() => { + function foo() { + return this.f + 4; + } + class CC { + a = this.f + 5; + method() { + return this.f + 6; + } + } + })(); +} diff --git a/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).symbols new file mode 100644 index 0000000000000..6579e0eac2ab4 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).symbols @@ -0,0 +1,46 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers8.ts === +class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers8.ts, 0, 0)) + + static f = 1; +>f : Symbol(C.f, Decl(typeOfThisInStaticMembers8.ts, 0, 9)) + + static arrowFunctionBoundary = () => this.f + 1; +>arrowFunctionBoundary : Symbol(C.arrowFunctionBoundary, Decl(typeOfThisInStaticMembers8.ts, 1, 17)) +>this.f : Symbol(C.f, Decl(typeOfThisInStaticMembers8.ts, 0, 9)) +>this : Symbol(C, Decl(typeOfThisInStaticMembers8.ts, 0, 0)) +>f : Symbol(C.f, Decl(typeOfThisInStaticMembers8.ts, 0, 9)) + + static functionExprBoundary = function () { return this.f + 2 }; +>functionExprBoundary : Symbol(C.functionExprBoundary, Decl(typeOfThisInStaticMembers8.ts, 2, 52)) + + static classExprBoundary = class { a = this.f + 3 }; +>classExprBoundary : Symbol(C.classExprBoundary, Decl(typeOfThisInStaticMembers8.ts, 3, 68)) +>a : Symbol((Anonymous class).a, Decl(typeOfThisInStaticMembers8.ts, 4, 38)) +>this : Symbol((Anonymous class), Decl(typeOfThisInStaticMembers8.ts, 4, 30)) + + static functionAndClassDeclBoundary = (() => { +>functionAndClassDeclBoundary : Symbol(C.functionAndClassDeclBoundary, Decl(typeOfThisInStaticMembers8.ts, 4, 56)) + + function foo () { +>foo : Symbol(foo, Decl(typeOfThisInStaticMembers8.ts, 5, 50)) + + return this.f + 4 + } + class CC { +>CC : Symbol(CC, Decl(typeOfThisInStaticMembers8.ts, 8, 9)) + + a = this.f + 5 +>a : Symbol(CC.a, Decl(typeOfThisInStaticMembers8.ts, 9, 18)) +>this : Symbol(CC, Decl(typeOfThisInStaticMembers8.ts, 8, 9)) + + method () { +>method : Symbol(CC.method, Decl(typeOfThisInStaticMembers8.ts, 10, 26)) + + return this.f + 6 +>this : Symbol(CC, Decl(typeOfThisInStaticMembers8.ts, 8, 9)) + } + } + })(); +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).types b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).types new file mode 100644 index 0000000000000..08873785a925c --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers8(target=es2022).types @@ -0,0 +1,77 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers8.ts === +class C { +>C : C + + static f = 1; +>f : number +>1 : 1 + + static arrowFunctionBoundary = () => this.f + 1; +>arrowFunctionBoundary : () => number +>() => this.f + 1 : () => number +>this.f + 1 : number +>this.f : number +>this : typeof C +>f : number +>1 : 1 + + static functionExprBoundary = function () { return this.f + 2 }; +>functionExprBoundary : () => any +>function () { return this.f + 2 } : () => any +>this.f + 2 : any +>this.f : any +>this : any +>f : any +>2 : 2 + + static classExprBoundary = class { a = this.f + 3 }; +>classExprBoundary : typeof (Anonymous class) +>class { a = this.f + 3 } : typeof (Anonymous class) +>a : any +>this.f + 3 : any +>this.f : any +>this : this +>f : any +>3 : 3 + + static functionAndClassDeclBoundary = (() => { +>functionAndClassDeclBoundary : void +>(() => { function foo () { return this.f + 4 } class CC { a = this.f + 5 method () { return this.f + 6 } } })() : void +>(() => { function foo () { return this.f + 4 } class CC { a = this.f + 5 method () { return this.f + 6 } } }) : () => void +>() => { function foo () { return this.f + 4 } class CC { a = this.f + 5 method () { return this.f + 6 } } } : () => void + + function foo () { +>foo : () => any + + return this.f + 4 +>this.f + 4 : any +>this.f : any +>this : any +>f : any +>4 : 4 + } + class CC { +>CC : CC + + a = this.f + 5 +>a : any +>this.f + 5 : any +>this.f : any +>this : this +>f : any +>5 : 5 + + method () { +>method : () => any + + return this.f + 6 +>this.f + 6 : any +>this.f : any +>this : this +>f : any +>6 : 6 + } + } + })(); +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).errors.txt b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).errors.txt new file mode 100644 index 0000000000000..7bf89ab8b3f97 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).errors.txt @@ -0,0 +1,39 @@ +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts(7,56): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts(8,44): error TS2335: 'super' can only be referenced in a derived class. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts(11,20): error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts(14,17): error TS2335: 'super' can only be referenced in a derived class. +tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts(16,24): error TS2335: 'super' can only be referenced in a derived class. + + +==== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts (5 errors) ==== + class C { + static f = 1 + } + + class D extends C { + static arrowFunctionBoundary = () => super.f + 1; + static functionExprBoundary = function () { return super.f + 2 }; + ~~~~~ +!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions. + static classExprBoundary = class { a = super.f + 3 }; + ~~~~~ +!!! error TS2335: 'super' can only be referenced in a derived class. + static functionAndClassDeclBoundary = (() => { + function foo () { + return super.f + 4 + ~~~~~ +!!! error TS2660: 'super' can only be referenced in members of derived classes or object literal expressions. + } + class C { + a = super.f + 5 + ~~~~~ +!!! error TS2335: 'super' can only be referenced in a derived class. + method () { + return super.f +6 + ~~~~~ +!!! error TS2335: 'super' can only be referenced in a derived class. + } + } + })(); + } + \ No newline at end of file diff --git a/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).js b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).js new file mode 100644 index 0000000000000..861937ac70d39 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).js @@ -0,0 +1,45 @@ +//// [typeOfThisInStaticMembers9.ts] +class C { + static f = 1 +} + +class D extends C { + static arrowFunctionBoundary = () => super.f + 1; + static functionExprBoundary = function () { return super.f + 2 }; + static classExprBoundary = class { a = super.f + 3 }; + static functionAndClassDeclBoundary = (() => { + function foo () { + return super.f + 4 + } + class C { + a = super.f + 5 + method () { + return super.f +6 + } + } + })(); +} + + +//// [typeOfThisInStaticMembers9.js] +class C { + static f = 1; +} +class D extends C { + static arrowFunctionBoundary = () => super.f + 1; + static functionExprBoundary = function () { return super.f + 2; }; + static classExprBoundary = class { + a = super.f + 3; + }; + static functionAndClassDeclBoundary = (() => { + function foo() { + return super.f + 4; + } + class C { + a = super.f + 5; + method() { + return super.f + 6; + } + } + })(); +} diff --git a/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).symbols b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).symbols new file mode 100644 index 0000000000000..15dd3c13164c8 --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).symbols @@ -0,0 +1,48 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts === +class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers9.ts, 0, 0)) + + static f = 1 +>f : Symbol(C.f, Decl(typeOfThisInStaticMembers9.ts, 0, 9)) +} + +class D extends C { +>D : Symbol(D, Decl(typeOfThisInStaticMembers9.ts, 2, 1)) +>C : Symbol(C, Decl(typeOfThisInStaticMembers9.ts, 0, 0)) + + static arrowFunctionBoundary = () => super.f + 1; +>arrowFunctionBoundary : Symbol(D.arrowFunctionBoundary, Decl(typeOfThisInStaticMembers9.ts, 4, 19)) +>super.f : Symbol(C.f, Decl(typeOfThisInStaticMembers9.ts, 0, 9)) +>super : Symbol(C, Decl(typeOfThisInStaticMembers9.ts, 0, 0)) +>f : Symbol(C.f, Decl(typeOfThisInStaticMembers9.ts, 0, 9)) + + static functionExprBoundary = function () { return super.f + 2 }; +>functionExprBoundary : Symbol(D.functionExprBoundary, Decl(typeOfThisInStaticMembers9.ts, 5, 53)) + + static classExprBoundary = class { a = super.f + 3 }; +>classExprBoundary : Symbol(D.classExprBoundary, Decl(typeOfThisInStaticMembers9.ts, 6, 69)) +>a : Symbol((Anonymous class).a, Decl(typeOfThisInStaticMembers9.ts, 7, 38)) + + static functionAndClassDeclBoundary = (() => { +>functionAndClassDeclBoundary : Symbol(D.functionAndClassDeclBoundary, Decl(typeOfThisInStaticMembers9.ts, 7, 57)) + + function foo () { +>foo : Symbol(foo, Decl(typeOfThisInStaticMembers9.ts, 8, 50)) + + return super.f + 4 + } + class C { +>C : Symbol(C, Decl(typeOfThisInStaticMembers9.ts, 11, 9)) + + a = super.f + 5 +>a : Symbol(C.a, Decl(typeOfThisInStaticMembers9.ts, 12, 17)) + + method () { +>method : Symbol(C.method, Decl(typeOfThisInStaticMembers9.ts, 13, 27)) + + return super.f +6 + } + } + })(); +} + diff --git a/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).types b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).types new file mode 100644 index 0000000000000..03f49b98d4c0a --- /dev/null +++ b/tests/baselines/reference/typeOfThisInStaticMembers9(target=es2022).types @@ -0,0 +1,82 @@ +=== tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts === +class C { +>C : C + + static f = 1 +>f : number +>1 : 1 +} + +class D extends C { +>D : D +>C : C + + static arrowFunctionBoundary = () => super.f + 1; +>arrowFunctionBoundary : () => number +>() => super.f + 1 : () => number +>super.f + 1 : number +>super.f : number +>super : typeof C +>f : number +>1 : 1 + + static functionExprBoundary = function () { return super.f + 2 }; +>functionExprBoundary : () => any +>function () { return super.f + 2 } : () => any +>super.f + 2 : any +>super.f : any +>super : any +>f : any +>2 : 2 + + static classExprBoundary = class { a = super.f + 3 }; +>classExprBoundary : typeof (Anonymous class) +>class { a = super.f + 3 } : typeof (Anonymous class) +>a : any +>super.f + 3 : any +>super.f : any +>super : any +>f : any +>3 : 3 + + static functionAndClassDeclBoundary = (() => { +>functionAndClassDeclBoundary : void +>(() => { function foo () { return super.f + 4 } class C { a = super.f + 5 method () { return super.f +6 } } })() : void +>(() => { function foo () { return super.f + 4 } class C { a = super.f + 5 method () { return super.f +6 } } }) : () => void +>() => { function foo () { return super.f + 4 } class C { a = super.f + 5 method () { return super.f +6 } } } : () => void + + function foo () { +>foo : () => any + + return super.f + 4 +>super.f + 4 : any +>super.f : any +>super : any +>f : any +>4 : 4 + } + class C { +>C : C + + a = super.f + 5 +>a : any +>super.f + 5 : any +>super.f : any +>super : any +>f : any +>5 : 5 + + method () { +>method : () => any + + return super.f +6 +>super.f +6 : any +>super.f : any +>super : any +>f : any +>6 : 6 + } + } + })(); +} + diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock1.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock1.ts index 8a0edbfedbe1a..9d1c3cdfc58fa 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock1.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock1.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015, es5 +// @target: esnext, es2022, es2015, es5 const a = 2; class C { diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock10.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock10.ts index c6e1fc2244d99..a0d351c8cb06b 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock10.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock10.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015, es5 +// @target: esnext, es2022, es2015, es5 var a1 = 1; var a2 = 1; const b1 = 2; @@ -25,4 +25,4 @@ class C2 { const b1 = 222; const b2 = 222; } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock11.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock11.ts index 685d870cceb09..d8d4b7aff292e 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock11.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock11.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 let getX; class C { diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock13.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock13.ts index 8120cc3575cb3..5078ab63dc016 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock13.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock13.ts @@ -1,9 +1,9 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 // @useDefineForClassFields: true class C { static #x = 123; - + static { console.log(C.#x) } diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock15.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock15.ts index ec2727660f123..ec40af5c290eb 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock15.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock15.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 // @useDefineForClassFields: true var _C__1; diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock18.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock18.ts index a36bd50917c20..0be8ee4cffec7 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock18.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock18.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015, es5 +// @target: esnext, es2022, es2015, es5 function foo () { return class { diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock2.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock2.ts index 292d7181bba5d..d27cc33913ed8 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock2.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock2.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015, es5 +// @target: esnext, es2022, es2015, es5 const a = 1; const b = 2; diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts index 8d3be9861aa71..2e63d2b0bf299 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock22.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: esnext, es2022 let await: "any"; class C { @@ -69,4 +69,4 @@ class C { static propFunc = function () { await; } } } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts index bb83b27dcab32..55dff224f0e17 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock23.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: esnext, es2022 const nums = [1, 2, 3].map(n => Promise.resolve(n)) @@ -18,4 +18,4 @@ async function foo () { } } } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock24.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock24.ts index 8132238772b65..a07d400633722 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock24.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock24.ts @@ -1,4 +1,4 @@ -// @module: commonjs, es2015, es2020, UMD, AMD, System, esnext +// @module: commonjs, es2015, es2020, es2022, UMD, AMD, System, esnext export class C { static x: number; diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.ts index 56f99a612298d..a490a1e1c5a0e 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock25.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: esnext, es2022 // @declaration: true // @declarationMap: true // @sourceMap: true diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts index 1081729acdb2d..75cdbd61d44ca 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock26.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: esnext, es2022 class C { static { diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts index 84125fdbed75a..c7052d5ce40c1 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock3.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: esnext, es2022 const a = 1; diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts index 7a944a496911f..432daf6494b8d 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock4.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: esnext, es2022 class C { static s1 = 1; diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock5.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock5.ts index cd0f7276c1b5f..aa834234d7269 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock5.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock5.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015, es5 +// @target: esnext, es2022, es2015, es5 class B { static a = 1; diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts index d99157b190983..218732ff9aa4a 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlock9.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015, es5 +// @target: esnext, es2022, es2015, es5 class A { static bar = A.foo + 1 static { diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef1.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef1.ts index 11f8b7f55472a..b9867afac336f 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef1.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef1.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: esnext, es2022 // @noEmit: true // @strict: true @@ -12,4 +12,4 @@ class C { static { this.z = this.y; } -} \ No newline at end of file +} diff --git a/tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts b/tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts index 89658a6ebe26c..769a126026c42 100644 --- a/tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts +++ b/tests/cases/conformance/classes/classStaticBlock/classStaticBlockUseBeforeDef2.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: esnext, es2022 // @noEmit: true // @strict: true @@ -7,4 +7,4 @@ class C { this.x = 1; } static x; -} \ No newline at end of file +} diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/superInStaticMembers1.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/superInStaticMembers1.ts index fd281b1606a52..e716307be1171 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/superInStaticMembers1.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/superInStaticMembers1.ts @@ -1,4 +1,4 @@ -// @target: es5, es2015, es2021, esnext +// @target: es5, es2015, es2021, es2022, esnext // @noTypesAndSymbols: true // @filename: external.ts diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/thisAndSuperInStaticMembers1.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/thisAndSuperInStaticMembers1.ts index e3bfff9aedfab..cc70f49d0f189 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/thisAndSuperInStaticMembers1.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/thisAndSuperInStaticMembers1.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 // @useDefineForClassFields: true // @noTypesAndSymbols: true @@ -39,4 +39,4 @@ class C extends B { x = 1; y = this.x; z = super.f(); -} \ No newline at end of file +} diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/thisAndSuperInStaticMembers2.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/thisAndSuperInStaticMembers2.ts index 7e751c3d672a4..513f1c5afa9eb 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/thisAndSuperInStaticMembers2.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/thisAndSuperInStaticMembers2.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 // @useDefineForClassFields: false // @noTypesAndSymbols: true @@ -39,4 +39,4 @@ class C extends B { x = 1; y = this.x; z = super.f(); -} \ No newline at end of file +} diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts index bb458c87d29a1..c56ac97ddbd82 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers10.ts @@ -1,4 +1,4 @@ -// @target: esnext, es6, es5 +// @target: esnext, es2022, es6, es5 // @experimentalDecorators: true // @useDefineForClassFields: false diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts index 6c4025bc4707e..0cac84a08b8fc 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers11.ts @@ -1,4 +1,4 @@ -// @target: esnext, es6, es5 +// @target: esnext, es2022, es6, es5 // @experimentalDecorators: true // @useDefineForClassFields: true diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts index 041089512bfa8..328612b48bd61 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers12.ts @@ -1,4 +1,4 @@ -// @target: esnext, es6, es5 +// @target: esnext, es2022, es6, es5 // @useDefineForClassFields: false class C { diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts index 6c965e0e2d55f..18780b0ff52d7 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers13.ts @@ -1,4 +1,4 @@ -// @target: esnext, es6, es5 +// @target: esnext, es2022, es6, es5 // @useDefineForClassFields: true class C { diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers3.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers3.ts index 27541ce361dbd..1f532ad9c6d38 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers3.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers3.ts @@ -1,4 +1,4 @@ -// @target: esnext, es6, es5 +// @target: esnext, es2022, es6, es5 // @useDefineForClassFields: false class C { static a = 1; diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers4.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers4.ts index 0d08423bb9ce1..facb155189a47 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers4.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers4.ts @@ -1,4 +1,4 @@ -// @target: esnext, es6, es5 +// @target: esnext, es2022, es6, es5 // @useDefineForClassFields: true class C { static a = 1; diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers5.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers5.ts index db6e8a76c6499..a6f035176492e 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers5.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers5.ts @@ -1,4 +1,4 @@ -// @target: esnext, es6, es5 +// @target: esnext, es2022, es6, es5 class C { static create = () => new this("yep") diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers7.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers7.ts index 1a2d9cd2e20eb..f6d01a83094ef 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers7.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers7.ts @@ -1,4 +1,4 @@ -// @target: esnext, es6, es5 +// @target: esnext, es2022, es6, es5 class C { static a = 1; diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers8.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers8.ts index 8b26476f143cf..c9836d3b6fe4d 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers8.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers8.ts @@ -1,4 +1,4 @@ -// @target: esnext, es6, es5 +// @target: esnext, es2022, es6, es5 class C { static f = 1; diff --git a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts index 0a648d2fa08a1..db65e5651d305 100644 --- a/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts +++ b/tests/cases/conformance/classes/members/instanceAndStaticMembers/typeOfThisInStaticMembers9.ts @@ -1,4 +1,4 @@ -// @target: esnext, es6, es5 +// @target: esnext, es2022, es6, es5 class C { static f = 1 diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameAndStaticInitializer.ts b/tests/cases/conformance/classes/members/privateNames/privateNameAndStaticInitializer.ts index 5dab0f08fed5c..d71b117af3459 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameAndStaticInitializer.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameAndStaticInitializer.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 class A { #foo = 1; diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameBadSuperUseDefineForClassFields.ts b/tests/cases/conformance/classes/members/privateNames/privateNameBadSuperUseDefineForClassFields.ts index 984b65a56957e..c9e67990f3d0b 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameBadSuperUseDefineForClassFields.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameBadSuperUseDefineForClassFields.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: esnext, es2022 // @useDefineForClassFields: true class B {}; class A extends B { diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName1.ts b/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName1.ts index 109985cb33c98..c17605b43cd1d 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName1.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName1.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 class A { #a = 'a'; diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName2.ts b/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName2.ts index a2e0a3e302541..c380f49f43213 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName2.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName2.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 let getX: (a: A) => number; diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName3.ts b/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName3.ts index 09573f98c91b3..e6639b6bc711e 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName3.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName3.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 class Foo { #name; diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName4.ts b/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName4.ts index e20efa4646f8f..a4b92a1341d50 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName4.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameComputedPropertyName4.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 // @useDefineForClassFields: true // @noTypesAndSymbols: true // https://github.com/microsoft/TypeScript/issues/44113 diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldDestructuredBinding.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldDestructuredBinding.ts index 7dc2b944c3735..a4a5a8afa979f 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameFieldDestructuredBinding.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldDestructuredBinding.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 class A { #field = 1; diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts index b57a1cd65923b..54035233239f1 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldsESNext.ts @@ -1,4 +1,4 @@ -// @target: esnext +// @target: esnext, es2022 // @useDefineForClassFields: false class C { diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts b/tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts index e274378150990..cc8c876e81f3a 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts @@ -1,5 +1,5 @@ // @strict: true -// @target: esnext +// @target: esnext, es2022 // @useDefineForClassFields: true class Foo { diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts b/tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts index f7be176373a5e..2ff682d039426 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionTransform.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2020 +// @target: esnext, es2022, es2020 class Foo { #field = 1; diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts b/tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts index 4b214a2b9e78f..35fdacb38795a 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameInInExpressionUnused.ts @@ -1,6 +1,6 @@ // @strict: true // @noUnusedLocals: true -// @target: esnext +// @target: esnext, es2022 class Foo { #unused: undefined; // expect unused error diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameStaticAndStaticInitializer.ts b/tests/cases/conformance/classes/members/privateNames/privateNameStaticAndStaticInitializer.ts index e4cd9be2c4428..c0035ef631947 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameStaticAndStaticInitializer.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameStaticAndStaticInitializer.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 // @useDefineForClassFields: false class A { diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldDestructuredBinding.ts b/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldDestructuredBinding.ts index 77482c675eb22..1c7b7f9b98187 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldDestructuredBinding.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldDestructuredBinding.ts @@ -1,4 +1,4 @@ -// @target: esnext, es2015 +// @target: esnext, es2022, es2015 // @useDefineForClassFields: false class A { diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldInitializer.ts b/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldInitializer.ts index b9aaaf872bf55..93763c9608e7d 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldInitializer.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldInitializer.ts @@ -1,4 +1,4 @@ -// @target: es2015, esnext +// @target: es2015, es2022, esnext // @useDefineForClassFields: false class A { diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldNoInitializer.ts b/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldNoInitializer.ts index 815a5d40f632e..f596214129e05 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldNoInitializer.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameStaticFieldNoInitializer.ts @@ -1,4 +1,4 @@ -// @target: es2015, esnext +// @target: es2015, es2022, esnext const C = class { static #x; @@ -6,4 +6,4 @@ const C = class { class C2 { static #x; -} \ No newline at end of file +} diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameStaticsAndStaticMethods.ts b/tests/cases/conformance/classes/members/privateNames/privateNameStaticsAndStaticMethods.ts index 94692964927e7..44f16f28dbf24 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNameStaticsAndStaticMethods.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNameStaticsAndStaticMethods.ts @@ -1,6 +1,6 @@ // @strict: true -// @target: esnext -// @lib: esnext +// @target: esnext, es2022 +// @lib: esnext, es2022 // @useDefineForClassFields: false class A { @@ -14,7 +14,7 @@ class A { return this.#_quux; } static set #quux (val: number) { - this.#_quux = val; + this.#_quux = val; } constructor () { A.#foo(30); diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts index d1c91d2736854..27c0cf68b92b2 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndMethods.ts @@ -1,5 +1,5 @@ -// @target: esnext -// @lib: esnext +// @target: esnext, es2022 +// @lib: esnext, es2022 // @useDefineForClassFields: false class A { @@ -13,7 +13,7 @@ class A { return this.#_quux; } set #quux (val: number) { - this.#_quux = val; + this.#_quux = val; } constructor () { this.#foo(30); diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts index 94692964927e7..44f16f28dbf24 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAndStaticMethods.ts @@ -1,6 +1,6 @@ // @strict: true -// @target: esnext -// @lib: esnext +// @target: esnext, es2022 +// @lib: esnext, es2022 // @useDefineForClassFields: false class A { @@ -14,7 +14,7 @@ class A { return this.#_quux; } static set #quux (val: number) { - this.#_quux = val; + this.#_quux = val; } constructor () { A.#foo(30); diff --git a/tests/cases/conformance/classes/members/privateNames/privateNamesAssertion.ts b/tests/cases/conformance/classes/members/privateNames/privateNamesAssertion.ts index 422c1bc9855a9..c2c34ad016acc 100644 --- a/tests/cases/conformance/classes/members/privateNames/privateNamesAssertion.ts +++ b/tests/cases/conformance/classes/members/privateNames/privateNamesAssertion.ts @@ -1,5 +1,5 @@ // @strict: true -// @target: esnext +// @target: esnext, es2022 // @useDefineForClassFields: false class Foo {