diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 27ec079f614ab..941129064f006 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -72,12 +72,12 @@ import { FlowCondition, FlowFlags, FlowLabel, - FlowNode, - FlowReduceLabel, - FlowSwitchClause, - forEach, - forEachChild, - ForInOrOfStatement, + FlowNode, + FlowReduceLabel, + FlowSwitchClause, + forEach, + forEachChild, + ForInOrOfStatement, ForStatement, FunctionDeclaration, FunctionExpression, @@ -1551,23 +1551,69 @@ function createBinder(): (file: SourceFile, options: CompilerOptions) => void { currentFlow = finishFlowLabel(postLoopLabel); } - function bindForInOrForOfStatement(node: ForInOrOfStatement): void { - const preLoopLabel = setContinueTarget(node, createLoopLabel()); - const postLoopLabel = createBranchLabel(); - bind(node.expression); - addAntecedent(preLoopLabel, currentFlow); - currentFlow = preLoopLabel; - if (node.kind === SyntaxKind.ForOfStatement) { - bind(node.awaitModifier); - } - addAntecedent(postLoopLabel, currentFlow); - bind(node.initializer); - if (node.initializer.kind !== SyntaxKind.VariableDeclarationList) { - bindAssignmentTargetFlow(node.initializer); - } - bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel); - addAntecedent(preLoopLabel, currentFlow); - currentFlow = finishFlowLabel(postLoopLabel); + function checkForUsingShadowingInForOf(node: ForInOrOfStatement): void { + if (node.kind !== SyntaxKind.ForOfStatement || node.initializer.kind !== SyntaxKind.VariableDeclarationList) { + return; + } + + const varDeclList = node.initializer as any; // VariableDeclarationList + + // Only check if we have using declarations that will be downleveled + if (!(varDeclList.flags & NodeFlags.Using) || languageVersion >= ScriptTarget.ESNext) { + return; + } + + // Collect the names of using declarations + const usingNames = new Set(); + for (const declaration of varDeclList.declarations) { + if (isIdentifier(declaration.name)) { + usingNames.add(unescapeLeadingUnderscores(declaration.name.escapedText)); + } + } + + if (usingNames.size === 0) return; + + // Check for variable declarations with the same names in the loop body + function checkNode(node: Node): void { + if (isVariableStatement(node)) { + for (const declaration of node.declarationList.declarations) { + if (isIdentifier(declaration.name)) { + const name = unescapeLeadingUnderscores(declaration.name.escapedText); + if (usingNames.has(name)) { + file.bindDiagnostics.push(createDiagnosticForNode(declaration.name, Diagnostics.Duplicate_identifier_0, name)); + } + } + } + } + + // Recursively check child nodes + forEachChild(node, checkNode); + } + + checkNode(node.statement); + } + + function bindForInOrForOfStatement(node: ForInOrOfStatement): void { + const preLoopLabel = setContinueTarget(node, createLoopLabel()); + const postLoopLabel = createBranchLabel(); + bind(node.expression); + addAntecedent(preLoopLabel, currentFlow); + currentFlow = preLoopLabel; + if (node.kind === SyntaxKind.ForOfStatement) { + bind(node.awaitModifier); + } + addAntecedent(postLoopLabel, currentFlow); + bind(node.initializer); + if (node.initializer.kind !== SyntaxKind.VariableDeclarationList) { + bindAssignmentTargetFlow(node.initializer); + } + else { + // Check for using declarations that will be downleveled and shadow variables in the loop body + checkForUsingShadowingInForOf(node); + } + bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel); + addAntecedent(preLoopLabel, currentFlow); + currentFlow = finishFlowLabel(postLoopLabel); } function bindIfStatement(node: IfStatement): void { diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).errors.txt b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).errors.txt new file mode 100644 index 0000000000000..07d6069b6c197 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).errors.txt @@ -0,0 +1,36 @@ +usingDeclarationsForOfShadowing.ts(5,9): error TS2300: Duplicate identifier 'foo'. +usingDeclarationsForOfShadowing.ts(15,7): error TS2300: Duplicate identifier 'x'. +usingDeclarationsForOfShadowing.ts(20,7): error TS2300: Duplicate identifier 'y'. +usingDeclarationsForOfShadowing.ts(20,7): error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. + + +==== usingDeclarationsForOfShadowing.ts (4 errors) ==== + class Foo {} + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); + ~~~ +!!! error TS2300: Duplicate identifier 'foo'. + } + + // OK: different names + for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); + } + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; + ~ +!!! error TS2300: Duplicate identifier 'y'. + ~ +!!! error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. + } \ No newline at end of file diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).js b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).js new file mode 100644 index 0000000000000..fb8034f6d265f --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).js @@ -0,0 +1,140 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +//// [usingDeclarationsForOfShadowing.ts] +class Foo {} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; +} + +//// [usingDeclarationsForOfShadowing.js] +var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) inner = dispose; + } + if (typeof dispose !== "function") throw new TypeError("Object not disposable."); + if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } }; + env.stack.push({ value: value, dispose: dispose, async: async }); + } + else if (async) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) { + return function (env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); + } + else s |= 1; + } + catch (e) { + fail(e); + } + } + if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) throw env.error; + } + return next(); + }; +})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +class Foo { +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (const foo_1 of [{ [Symbol.dispose]() { } }]) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const foo = __addDisposableResource(env_1, foo_1, false); + const foo = new Foo(); + } + catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } + finally { + __disposeResources(env_1); + } +} +// OK: different names +for (const bar_1 of [{ [Symbol.dispose]() { } }]) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + const bar = __addDisposableResource(env_2, bar_1, false); + const baz = new Foo(); + } + catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } + finally { + __disposeResources(env_2); + } +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (const x_1 of [{ [Symbol.dispose]() { } }]) { + const env_3 = { stack: [], error: void 0, hasError: false }; + try { + const x = __addDisposableResource(env_3, x_1, false); + let x = 1; + } + catch (e_3) { + env_3.error = e_3; + env_3.hasError = true; + } + finally { + __disposeResources(env_3); + } +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (const y_1 of [{ [Symbol.dispose]() { } }]) { + const env_4 = { stack: [], error: void 0, hasError: false }; + try { + const y = __addDisposableResource(env_4, y_1, false); + var y = "test"; + } + catch (e_4) { + env_4.error = e_4; + env_4.hasError = true; + } + finally { + __disposeResources(env_4); + } +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).symbols b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).symbols new file mode 100644 index 0000000000000..2cc12e6e77bca --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).symbols @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +=== usingDeclarationsForOfShadowing.ts === +class Foo {} +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { +>foo : Symbol(foo, Decl(usingDeclarationsForOfShadowing.ts, 3, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 3, 20)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + const foo = new Foo(); +>foo : Symbol(foo, Decl(usingDeclarationsForOfShadowing.ts, 4, 7)) +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { +>bar : Symbol(bar, Decl(usingDeclarationsForOfShadowing.ts, 8, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 8, 20)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + const baz = new Foo(); +>baz : Symbol(baz, Decl(usingDeclarationsForOfShadowing.ts, 9, 7)) +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { +>x : Symbol(x, Decl(usingDeclarationsForOfShadowing.ts, 13, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 13, 18)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + let x = 1; +>x : Symbol(x, Decl(usingDeclarationsForOfShadowing.ts, 14, 5)) +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { +>y : Symbol(y, Decl(usingDeclarationsForOfShadowing.ts, 18, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 18, 18)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + var y = "test"; +>y : Symbol(y, Decl(usingDeclarationsForOfShadowing.ts, 19, 5)) +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).types b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).types new file mode 100644 index 0000000000000..a1ad2df64738f --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2015).types @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +=== usingDeclarationsForOfShadowing.ts === +class Foo {} +>Foo : Foo +> : ^^^ + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { +>foo : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + const foo = new Foo(); +>foo : Foo +> : ^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { +>bar : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + const baz = new Foo(); +>baz : Foo +> : ^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { +>x : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + let x = 1; +>x : number +> : ^^^^^^ +>1 : 1 +> : ^ +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { +>y : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + var y = "test"; +>y : string +> : ^^^^^^ +>"test" : "test" +> : ^^^^^^ +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).errors.txt b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).errors.txt new file mode 100644 index 0000000000000..07d6069b6c197 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).errors.txt @@ -0,0 +1,36 @@ +usingDeclarationsForOfShadowing.ts(5,9): error TS2300: Duplicate identifier 'foo'. +usingDeclarationsForOfShadowing.ts(15,7): error TS2300: Duplicate identifier 'x'. +usingDeclarationsForOfShadowing.ts(20,7): error TS2300: Duplicate identifier 'y'. +usingDeclarationsForOfShadowing.ts(20,7): error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. + + +==== usingDeclarationsForOfShadowing.ts (4 errors) ==== + class Foo {} + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); + ~~~ +!!! error TS2300: Duplicate identifier 'foo'. + } + + // OK: different names + for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); + } + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; + ~ +!!! error TS2300: Duplicate identifier 'y'. + ~ +!!! error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. + } \ No newline at end of file diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).js b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).js new file mode 100644 index 0000000000000..fb8034f6d265f --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).js @@ -0,0 +1,140 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +//// [usingDeclarationsForOfShadowing.ts] +class Foo {} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; +} + +//// [usingDeclarationsForOfShadowing.js] +var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) inner = dispose; + } + if (typeof dispose !== "function") throw new TypeError("Object not disposable."); + if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } }; + env.stack.push({ value: value, dispose: dispose, async: async }); + } + else if (async) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) { + return function (env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); + } + else s |= 1; + } + catch (e) { + fail(e); + } + } + if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) throw env.error; + } + return next(); + }; +})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +class Foo { +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (const foo_1 of [{ [Symbol.dispose]() { } }]) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const foo = __addDisposableResource(env_1, foo_1, false); + const foo = new Foo(); + } + catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } + finally { + __disposeResources(env_1); + } +} +// OK: different names +for (const bar_1 of [{ [Symbol.dispose]() { } }]) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + const bar = __addDisposableResource(env_2, bar_1, false); + const baz = new Foo(); + } + catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } + finally { + __disposeResources(env_2); + } +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (const x_1 of [{ [Symbol.dispose]() { } }]) { + const env_3 = { stack: [], error: void 0, hasError: false }; + try { + const x = __addDisposableResource(env_3, x_1, false); + let x = 1; + } + catch (e_3) { + env_3.error = e_3; + env_3.hasError = true; + } + finally { + __disposeResources(env_3); + } +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (const y_1 of [{ [Symbol.dispose]() { } }]) { + const env_4 = { stack: [], error: void 0, hasError: false }; + try { + const y = __addDisposableResource(env_4, y_1, false); + var y = "test"; + } + catch (e_4) { + env_4.error = e_4; + env_4.hasError = true; + } + finally { + __disposeResources(env_4); + } +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).symbols b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).symbols new file mode 100644 index 0000000000000..2cc12e6e77bca --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).symbols @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +=== usingDeclarationsForOfShadowing.ts === +class Foo {} +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { +>foo : Symbol(foo, Decl(usingDeclarationsForOfShadowing.ts, 3, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 3, 20)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + const foo = new Foo(); +>foo : Symbol(foo, Decl(usingDeclarationsForOfShadowing.ts, 4, 7)) +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { +>bar : Symbol(bar, Decl(usingDeclarationsForOfShadowing.ts, 8, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 8, 20)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + const baz = new Foo(); +>baz : Symbol(baz, Decl(usingDeclarationsForOfShadowing.ts, 9, 7)) +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { +>x : Symbol(x, Decl(usingDeclarationsForOfShadowing.ts, 13, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 13, 18)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + let x = 1; +>x : Symbol(x, Decl(usingDeclarationsForOfShadowing.ts, 14, 5)) +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { +>y : Symbol(y, Decl(usingDeclarationsForOfShadowing.ts, 18, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 18, 18)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + var y = "test"; +>y : Symbol(y, Decl(usingDeclarationsForOfShadowing.ts, 19, 5)) +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).types b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).types new file mode 100644 index 0000000000000..a1ad2df64738f --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2017).types @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +=== usingDeclarationsForOfShadowing.ts === +class Foo {} +>Foo : Foo +> : ^^^ + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { +>foo : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + const foo = new Foo(); +>foo : Foo +> : ^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { +>bar : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + const baz = new Foo(); +>baz : Foo +> : ^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { +>x : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + let x = 1; +>x : number +> : ^^^^^^ +>1 : 1 +> : ^ +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { +>y : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + var y = "test"; +>y : string +> : ^^^^^^ +>"test" : "test" +> : ^^^^^^ +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).errors.txt b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).errors.txt new file mode 100644 index 0000000000000..07d6069b6c197 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).errors.txt @@ -0,0 +1,36 @@ +usingDeclarationsForOfShadowing.ts(5,9): error TS2300: Duplicate identifier 'foo'. +usingDeclarationsForOfShadowing.ts(15,7): error TS2300: Duplicate identifier 'x'. +usingDeclarationsForOfShadowing.ts(20,7): error TS2300: Duplicate identifier 'y'. +usingDeclarationsForOfShadowing.ts(20,7): error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. + + +==== usingDeclarationsForOfShadowing.ts (4 errors) ==== + class Foo {} + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); + ~~~ +!!! error TS2300: Duplicate identifier 'foo'. + } + + // OK: different names + for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); + } + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; + ~ +!!! error TS2300: Duplicate identifier 'y'. + ~ +!!! error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. + } \ No newline at end of file diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).js b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).js new file mode 100644 index 0000000000000..fb8034f6d265f --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).js @@ -0,0 +1,140 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +//// [usingDeclarationsForOfShadowing.ts] +class Foo {} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; +} + +//// [usingDeclarationsForOfShadowing.js] +var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) inner = dispose; + } + if (typeof dispose !== "function") throw new TypeError("Object not disposable."); + if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } }; + env.stack.push({ value: value, dispose: dispose, async: async }); + } + else if (async) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) { + return function (env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); + } + else s |= 1; + } + catch (e) { + fail(e); + } + } + if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) throw env.error; + } + return next(); + }; +})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +class Foo { +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (const foo_1 of [{ [Symbol.dispose]() { } }]) { + const env_1 = { stack: [], error: void 0, hasError: false }; + try { + const foo = __addDisposableResource(env_1, foo_1, false); + const foo = new Foo(); + } + catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } + finally { + __disposeResources(env_1); + } +} +// OK: different names +for (const bar_1 of [{ [Symbol.dispose]() { } }]) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + const bar = __addDisposableResource(env_2, bar_1, false); + const baz = new Foo(); + } + catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } + finally { + __disposeResources(env_2); + } +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (const x_1 of [{ [Symbol.dispose]() { } }]) { + const env_3 = { stack: [], error: void 0, hasError: false }; + try { + const x = __addDisposableResource(env_3, x_1, false); + let x = 1; + } + catch (e_3) { + env_3.error = e_3; + env_3.hasError = true; + } + finally { + __disposeResources(env_3); + } +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (const y_1 of [{ [Symbol.dispose]() { } }]) { + const env_4 = { stack: [], error: void 0, hasError: false }; + try { + const y = __addDisposableResource(env_4, y_1, false); + var y = "test"; + } + catch (e_4) { + env_4.error = e_4; + env_4.hasError = true; + } + finally { + __disposeResources(env_4); + } +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).symbols b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).symbols new file mode 100644 index 0000000000000..2cc12e6e77bca --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).symbols @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +=== usingDeclarationsForOfShadowing.ts === +class Foo {} +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { +>foo : Symbol(foo, Decl(usingDeclarationsForOfShadowing.ts, 3, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 3, 20)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + const foo = new Foo(); +>foo : Symbol(foo, Decl(usingDeclarationsForOfShadowing.ts, 4, 7)) +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { +>bar : Symbol(bar, Decl(usingDeclarationsForOfShadowing.ts, 8, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 8, 20)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + const baz = new Foo(); +>baz : Symbol(baz, Decl(usingDeclarationsForOfShadowing.ts, 9, 7)) +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { +>x : Symbol(x, Decl(usingDeclarationsForOfShadowing.ts, 13, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 13, 18)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + let x = 1; +>x : Symbol(x, Decl(usingDeclarationsForOfShadowing.ts, 14, 5)) +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { +>y : Symbol(y, Decl(usingDeclarationsForOfShadowing.ts, 18, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 18, 18)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + var y = "test"; +>y : Symbol(y, Decl(usingDeclarationsForOfShadowing.ts, 19, 5)) +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).types b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).types new file mode 100644 index 0000000000000..a1ad2df64738f --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es2022).types @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +=== usingDeclarationsForOfShadowing.ts === +class Foo {} +>Foo : Foo +> : ^^^ + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { +>foo : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + const foo = new Foo(); +>foo : Foo +> : ^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { +>bar : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + const baz = new Foo(); +>baz : Foo +> : ^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { +>x : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + let x = 1; +>x : number +> : ^^^^^^ +>1 : 1 +> : ^ +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { +>y : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + var y = "test"; +>y : string +> : ^^^^^^ +>"test" : "test" +> : ^^^^^^ +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).errors.txt b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).errors.txt new file mode 100644 index 0000000000000..07d6069b6c197 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).errors.txt @@ -0,0 +1,36 @@ +usingDeclarationsForOfShadowing.ts(5,9): error TS2300: Duplicate identifier 'foo'. +usingDeclarationsForOfShadowing.ts(15,7): error TS2300: Duplicate identifier 'x'. +usingDeclarationsForOfShadowing.ts(20,7): error TS2300: Duplicate identifier 'y'. +usingDeclarationsForOfShadowing.ts(20,7): error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. + + +==== usingDeclarationsForOfShadowing.ts (4 errors) ==== + class Foo {} + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); + ~~~ +!!! error TS2300: Duplicate identifier 'foo'. + } + + // OK: different names + for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); + } + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; + ~ +!!! error TS2300: Duplicate identifier 'x'. + } + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; + ~ +!!! error TS2300: Duplicate identifier 'y'. + ~ +!!! error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. + } \ No newline at end of file diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).js b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).js new file mode 100644 index 0000000000000..0c02af22fc3d1 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).js @@ -0,0 +1,148 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +//// [usingDeclarationsForOfShadowing.ts] +class Foo {} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; +} + +//// [usingDeclarationsForOfShadowing.js] +var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) { + if (value !== null && value !== void 0) { + if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected."); + var dispose, inner; + if (async) { + if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined."); + dispose = value[Symbol.asyncDispose]; + } + if (dispose === void 0) { + if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined."); + dispose = value[Symbol.dispose]; + if (async) inner = dispose; + } + if (typeof dispose !== "function") throw new TypeError("Object not disposable."); + if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } }; + env.stack.push({ value: value, dispose: dispose, async: async }); + } + else if (async) { + env.stack.push({ async: true }); + } + return value; +}; +var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) { + return function (env) { + function fail(e) { + env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e; + env.hasError = true; + } + var r, s = 0; + function next() { + while (r = env.stack.pop()) { + try { + if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next); + if (r.dispose) { + var result = r.dispose.call(r.value); + if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); }); + } + else s |= 1; + } + catch (e) { + fail(e); + } + } + if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve(); + if (env.hasError) throw env.error; + } + return next(); + }; +})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) { + var e = new Error(message); + return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e; +}); +var _a, _b, _c, _d; +var Foo = /** @class */ (function () { + function Foo() { + } + return Foo; +}()); +// Error when downleveling: using declaration shadowed by loop body declaration +for (var _i = 0, _e = [(_a = {}, _a[Symbol.dispose] = function () { }, _a)]; _i < _e.length; _i++) { + var foo_1 = _e[_i]; + var env_1 = { stack: [], error: void 0, hasError: false }; + try { + var foo = __addDisposableResource(env_1, foo_1, false); + var foo_2 = new Foo(); + } + catch (e_1) { + env_1.error = e_1; + env_1.hasError = true; + } + finally { + __disposeResources(env_1); + } +} +// OK: different names +for (var _f = 0, _g = [(_b = {}, _b[Symbol.dispose] = function () { }, _b)]; _f < _g.length; _f++) { + var bar_1 = _g[_f]; + var env_2 = { stack: [], error: void 0, hasError: false }; + try { + var bar = __addDisposableResource(env_2, bar_1, false); + var baz = new Foo(); + } + catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } + finally { + __disposeResources(env_2); + } +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (var _h = 0, _j = [(_c = {}, _c[Symbol.dispose] = function () { }, _c)]; _h < _j.length; _h++) { + var x_1 = _j[_h]; + var env_3 = { stack: [], error: void 0, hasError: false }; + try { + var x = __addDisposableResource(env_3, x_1, false); + var x_2 = 1; + } + catch (e_3) { + env_3.error = e_3; + env_3.hasError = true; + } + finally { + __disposeResources(env_3); + } +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (var _k = 0, _l = [(_d = {}, _d[Symbol.dispose] = function () { }, _d)]; _k < _l.length; _k++) { + var y_1 = _l[_k]; + var env_4 = { stack: [], error: void 0, hasError: false }; + try { + var y_1 = __addDisposableResource(env_4, y_1, false); + var y = "test"; + } + catch (e_4) { + env_4.error = e_4; + env_4.hasError = true; + } + finally { + __disposeResources(env_4); + } +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).symbols b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).symbols new file mode 100644 index 0000000000000..2cc12e6e77bca --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).symbols @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +=== usingDeclarationsForOfShadowing.ts === +class Foo {} +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { +>foo : Symbol(foo, Decl(usingDeclarationsForOfShadowing.ts, 3, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 3, 20)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + const foo = new Foo(); +>foo : Symbol(foo, Decl(usingDeclarationsForOfShadowing.ts, 4, 7)) +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { +>bar : Symbol(bar, Decl(usingDeclarationsForOfShadowing.ts, 8, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 8, 20)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + const baz = new Foo(); +>baz : Symbol(baz, Decl(usingDeclarationsForOfShadowing.ts, 9, 7)) +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { +>x : Symbol(x, Decl(usingDeclarationsForOfShadowing.ts, 13, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 13, 18)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + let x = 1; +>x : Symbol(x, Decl(usingDeclarationsForOfShadowing.ts, 14, 5)) +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { +>y : Symbol(y, Decl(usingDeclarationsForOfShadowing.ts, 18, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 18, 18)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + var y = "test"; +>y : Symbol(y, Decl(usingDeclarationsForOfShadowing.ts, 19, 5)) +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).types b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).types new file mode 100644 index 0000000000000..a1ad2df64738f --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=es5).types @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +=== usingDeclarationsForOfShadowing.ts === +class Foo {} +>Foo : Foo +> : ^^^ + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { +>foo : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + const foo = new Foo(); +>foo : Foo +> : ^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { +>bar : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + const baz = new Foo(); +>baz : Foo +> : ^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { +>x : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + let x = 1; +>x : number +> : ^^^^^^ +>1 : 1 +> : ^ +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { +>y : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + var y = "test"; +>y : string +> : ^^^^^^ +>"test" : "test" +> : ^^^^^^ +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).errors.txt b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).errors.txt new file mode 100644 index 0000000000000..5a5d645b848aa --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).errors.txt @@ -0,0 +1,27 @@ +usingDeclarationsForOfShadowing.ts(20,7): error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. + + +==== usingDeclarationsForOfShadowing.ts (1 errors) ==== + class Foo {} + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); + } + + // OK: different names + for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); + } + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; + } + + // Error when downleveling: using declaration shadowed by loop body declaration + for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; + ~ +!!! error TS2481: Cannot initialize outer scoped variable 'y' in the same scope as block scoped declaration 'y'. + } \ No newline at end of file diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).js b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).js new file mode 100644 index 0000000000000..95d914d3beea9 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).js @@ -0,0 +1,44 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +//// [usingDeclarationsForOfShadowing.ts] +class Foo {} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; +} + +//// [usingDeclarationsForOfShadowing.js] +class Foo { +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() { } }]) { + const foo = new Foo(); +} +// OK: different names +for (using bar of [{ [Symbol.dispose]() { } }]) { + const baz = new Foo(); +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() { } }]) { + let x = 1; +} +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() { } }]) { + var y = "test"; +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).symbols b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).symbols new file mode 100644 index 0000000000000..2cc12e6e77bca --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).symbols @@ -0,0 +1,55 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +=== usingDeclarationsForOfShadowing.ts === +class Foo {} +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { +>foo : Symbol(foo, Decl(usingDeclarationsForOfShadowing.ts, 3, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 3, 20)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + const foo = new Foo(); +>foo : Symbol(foo, Decl(usingDeclarationsForOfShadowing.ts, 4, 7)) +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { +>bar : Symbol(bar, Decl(usingDeclarationsForOfShadowing.ts, 8, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 8, 20)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + const baz = new Foo(); +>baz : Symbol(baz, Decl(usingDeclarationsForOfShadowing.ts, 9, 7)) +>Foo : Symbol(Foo, Decl(usingDeclarationsForOfShadowing.ts, 0, 0)) +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { +>x : Symbol(x, Decl(usingDeclarationsForOfShadowing.ts, 13, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 13, 18)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + let x = 1; +>x : Symbol(x, Decl(usingDeclarationsForOfShadowing.ts, 14, 5)) +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { +>y : Symbol(y, Decl(usingDeclarationsForOfShadowing.ts, 18, 10)) +>[Symbol.dispose] : Symbol([Symbol.dispose], Decl(usingDeclarationsForOfShadowing.ts, 18, 18)) +>Symbol.dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) +>Symbol : Symbol(Symbol, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.symbol.d.ts, --, --), Decl(lib.es2015.symbol.wellknown.d.ts, --, --), Decl(lib.es2019.symbol.d.ts, --, --)) +>dispose : Symbol(SymbolConstructor.dispose, Decl(lib.esnext.disposable.d.ts, --, --)) + + var y = "test"; +>y : Symbol(y, Decl(usingDeclarationsForOfShadowing.ts, 19, 5)) +} diff --git a/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).types b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).types new file mode 100644 index 0000000000000..a1ad2df64738f --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsForOfShadowing(target=esnext).types @@ -0,0 +1,106 @@ +//// [tests/cases/compiler/usingDeclarationsForOfShadowing.ts] //// + +=== usingDeclarationsForOfShadowing.ts === +class Foo {} +>Foo : Foo +> : ^^^ + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { +>foo : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + const foo = new Foo(); +>foo : Foo +> : ^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { +>bar : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + const baz = new Foo(); +>baz : Foo +> : ^^^ +>new Foo() : Foo +> : ^^^ +>Foo : typeof Foo +> : ^^^^^^^^^^ +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { +>x : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + let x = 1; +>x : number +> : ^^^^^^ +>1 : 1 +> : ^ +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { +>y : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[{ [Symbol.dispose]() {} }] : { [Symbol.dispose](): void; }[] +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>{ [Symbol.dispose]() {} } : { [Symbol.dispose](): void; } +> : ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +>[Symbol.dispose] : () => void +> : ^^^^^^^^^^ +>Symbol.dispose : unique symbol +> : ^^^^^^^^^^^^^ +>Symbol : SymbolConstructor +> : ^^^^^^^^^^^^^^^^^ +>dispose : unique symbol +> : ^^^^^^^^^^^^^ + + var y = "test"; +>y : string +> : ^^^^^^ +>"test" : "test" +> : ^^^^^^ +} diff --git a/tests/cases/compiler/usingDeclarationsForOfShadowing.ts b/tests/cases/compiler/usingDeclarationsForOfShadowing.ts new file mode 100644 index 0000000000000..ba4ec5f964681 --- /dev/null +++ b/tests/cases/compiler/usingDeclarationsForOfShadowing.ts @@ -0,0 +1,25 @@ +// @target: es5,es2015,es2017,es2022,esnext +// @module: esnext +// @lib: esnext + +class Foo {} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using foo of [{ [Symbol.dispose]() {} }]) { + const foo = new Foo(); +} + +// OK: different names +for (using bar of [{ [Symbol.dispose]() {} }]) { + const baz = new Foo(); +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using x of [{ [Symbol.dispose]() {} }]) { + let x = 1; +} + +// Error when downleveling: using declaration shadowed by loop body declaration +for (using y of [{ [Symbol.dispose]() {} }]) { + var y = "test"; +} \ No newline at end of file