diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts index eace2e2c28057..2b6ca480e32fc 100644 --- a/src/compiler/transformers/esnext.ts +++ b/src/compiler/transformers/esnext.ts @@ -1,67 +1,67 @@ -import { - addEmitHelpers, - addRange, - append, - arrayFrom, - BindingElement, - Block, - Bundle, - CaseOrDefaultClause, - chainBundle, - ClassDeclaration, - Debug, - EmitFlags, - ExportAssignment, - ExportSpecifier, - Expression, - firstOrUndefined, - ForOfStatement, - ForStatement, - GeneratedIdentifierFlags, - getEmitFlags, - hasSyntacticModifier, - Identifier, - IdentifierNameMap, - isArray, - isBindingPattern, - isBlock, - isCaseClause, - isCustomPrologue, - isExpression, - isGeneratedIdentifier, - isIdentifier, - isLocalName, - isNamedEvaluation, - isOmittedExpression, - isPrologueDirective, - isSourceFile, - isStatement, - isVariableDeclarationList, - isVariableStatement, - ModifierFlags, - Node, - NodeFlags, - setCommentRange, - setEmitFlags, - setOriginalNode, - setSourceMapRange, - setTextRange, - skipOuterExpressions, - SourceFile, - Statement, - SwitchStatement, - SyntaxKind, - TransformationContext, - TransformFlags, - transformNamedEvaluation, - VariableDeclaration, - VariableDeclarationList, - VariableStatement, - visitArray, - visitEachChild, - visitNode, - visitNodes, - VisitResult, +import { + addEmitHelpers, + addRange, + append, + arrayFrom, + BindingElement, + Block, + Bundle, + CaseOrDefaultClause, + chainBundle, + ClassDeclaration, + Debug, + EmitFlags, + ExportAssignment, + ExportSpecifier, + Expression, + firstOrUndefined, + ForOfStatement, + ForStatement, + GeneratedIdentifierFlags, + getEmitFlags, + hasSyntacticModifier, + Identifier, + IdentifierNameMap, + isArray, + isBindingPattern, + isBlock, + isCaseClause, + isCustomPrologue, + isExpression, + isGeneratedIdentifier, + isIdentifier, + isLocalName, + isNamedEvaluation, + isOmittedExpression, + isPrologueDirective, + isSourceFile, + isStatement, + isVariableDeclarationList, + isVariableStatement, + ModifierFlags, + Node, + NodeFlags, + setCommentRange, + setEmitFlags, + setOriginalNode, + setSourceMapRange, + setTextRange, + skipOuterExpressions, + SourceFile, + Statement, + SwitchStatement, + SyntaxKind, + TransformationContext, + TransformFlags, + transformNamedEvaluation, + VariableDeclaration, + VariableDeclarationList, + VariableStatement, + visitArray, + visitEachChild, + visitNode, + visitNodes, + VisitResult, } from "../_namespaces/ts.js"; const enum UsingKind { @@ -289,54 +289,64 @@ export function transformESNext(context: TransformationContext): (x: SourceFile ); } - return visitEachChild(node, visitor, context); - } - - function visitForOfStatement(node: ForOfStatement) { - if (isUsingVariableDeclarationList(node.initializer)) { - // given: - // - // for (using x of y) { ... } - // - // produces a shallow transformation to: - // - // for (const x_1 of y) { - // using x = x; - // ... - // } - // - // before handing the shallow transformation back to the visitor for an in-depth transformation. - const forInitializer = node.initializer; - const forDecl = firstOrUndefined(forInitializer.declarations) || factory.createVariableDeclaration(factory.createTempVariable(/*recordTempVariable*/ undefined)); - - const isAwaitUsing = getUsingKindOfVariableDeclarationList(forInitializer) === UsingKind.Async; - const temp = factory.getGeneratedNameForNode(forDecl.name); - const usingVar = factory.updateVariableDeclaration(forDecl, forDecl.name, /*exclamationToken*/ undefined, /*type*/ undefined, temp); - const usingVarList = factory.createVariableDeclarationList([usingVar], isAwaitUsing ? NodeFlags.AwaitUsing : NodeFlags.Using); - const usingVarStatement = factory.createVariableStatement(/*modifiers*/ undefined, usingVarList); - return visitNode( - factory.updateForOfStatement( - node, - node.awaitModifier, - factory.createVariableDeclarationList([ - factory.createVariableDeclaration(temp), - ], NodeFlags.Const), - node.expression, - isBlock(node.statement) ? - factory.updateBlock(node.statement, [ - usingVarStatement, - ...node.statement.statements, - ]) : - factory.createBlock([ - usingVarStatement, - node.statement, - ], /*multiLine*/ true), - ), - visitor, - isStatement, - ); - } - return visitEachChild(node, visitor, context); + return visitEachChild(node, visitor, context); + } + + function visitForOfStatement(node: ForOfStatement) { + if (isUsingVariableDeclarationList(node.initializer)) { + // given: + // + // for (using x of y) { ... } + // + // produces a shallow transformation to: + // + // for (const x_1 of y) { + // using x = x_1; + // { ... } + // } + // + // where the original loop body is wrapped in an additional block scope + // to handle shadowing variables naturally through block scoping. + const forInitializer = node.initializer; + const forDecl = firstOrUndefined(forInitializer.declarations) || factory.createVariableDeclaration(factory.createTempVariable(/*recordTempVariable*/ undefined)); + + const isAwaitUsing = getUsingKindOfVariableDeclarationList(forInitializer) === UsingKind.Async; + const temp = factory.getGeneratedNameForNode(forDecl.name); + const usingVar = factory.updateVariableDeclaration(forDecl, forDecl.name, /*exclamationToken*/ undefined, /*type*/ undefined, temp); + const usingVarList = factory.createVariableDeclarationList([usingVar], isAwaitUsing ? NodeFlags.AwaitUsing : NodeFlags.Using); + const usingVarStatement = factory.createVariableStatement(/*modifiers*/ undefined, usingVarList); + + // Wrap the original loop body in an additional block scope to handle shadowing + // Don't create an extra block if the original statement is empty or contains only empty statements + const isEmptyBlock = isBlock(node.statement) && ( + node.statement.statements.length === 0 || + node.statement.statements.every(stmt => stmt.kind === SyntaxKind.EmptyStatement) + ); + const shouldWrapInBlock = !isEmptyBlock; + + const statements: Statement[] = [usingVarStatement]; + if (shouldWrapInBlock) { + const wrappedStatement = isBlock(node.statement) ? + node.statement : + factory.createBlock([node.statement], /*multiLine*/ true); + statements.push(wrappedStatement); + } + + return visitNode( + factory.updateForOfStatement( + node, + node.awaitModifier, + factory.createVariableDeclarationList([ + factory.createVariableDeclaration(temp), + ], NodeFlags.Const), + node.expression, + factory.createBlock(statements, /*multiLine*/ true), + ), + visitor, + isStatement, + ); + } + return visitEachChild(node, visitor, context); } function visitCaseOrDefaultClause(node: CaseOrDefaultClause, envBinding: Identifier) { diff --git a/tests/baselines/reference/awaitUsingDeclarationsInForAwaitOf.3(target=es5).js b/tests/baselines/reference/awaitUsingDeclarationsInForAwaitOf.3(target=es5).js index f929d3d0c6ced..db43dff80b288 100644 --- a/tests/baselines/reference/awaitUsingDeclarationsInForAwaitOf.3(target=es5).js +++ b/tests/baselines/reference/awaitUsingDeclarationsInForAwaitOf.3(target=es5).js @@ -118,7 +118,9 @@ try { var env_1 = { stack: [], error: void 0, hasError: false }; try { var _e = __addDisposableResource(env_1, _e_1, true); - ; + { + ; + } } catch (e_2) { env_1.error = e_2; @@ -159,7 +161,9 @@ export function test() { case 3: _f.trys.push([3, 4, 5, 8]); _b = __addDisposableResource(env_2, _b_1, true); - ; + { + ; + } return [3 /*break*/, 8]; case 4: e_3 = _f.sent(); diff --git a/tests/baselines/reference/awaitUsingDeclarationsInForOf.5(target=es5).js b/tests/baselines/reference/awaitUsingDeclarationsInForOf.5(target=es5).js index 6b9e8308d45a9..bc1a01dae2dbe 100644 --- a/tests/baselines/reference/awaitUsingDeclarationsInForOf.5(target=es5).js +++ b/tests/baselines/reference/awaitUsingDeclarationsInForOf.5(target=es5).js @@ -107,7 +107,9 @@ for (var _i = 0, x_1 = x; _i < x_1.length; _i++) { var env_1 = { stack: [], error: void 0, hasError: false }; try { var _a = __addDisposableResource(env_1, _a_1, true); - ; + { + ; + } } catch (e_1) { env_1.error = e_1; @@ -135,7 +137,9 @@ export function test() { case 2: _b.trys.push([2, 3, 4, 7]); _a = __addDisposableResource(env_2, _a_2, true); - ; + { + ; + } return [3 /*break*/, 7]; case 3: e_2 = _b.sent(); diff --git a/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2015).errors.txt b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2015).errors.txt new file mode 100644 index 0000000000000..9ff1e77bc34d6 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2015).errors.txt @@ -0,0 +1,24 @@ +main.ts(12,7): error TS2481: Cannot initialize outer scoped variable 'baz' in the same scope as block scoped declaration 'baz'. + + +==== main.ts (1 errors) ==== + class Foo {} + + for (using foo of []) { + const foo = new Foo(); + } + + for (using bar of []) { + let bar = "test"; + } + + for (using baz of []) { + var baz = 42; + ~~~ +!!! error TS2481: Cannot initialize outer scoped variable 'baz' in the same scope as block scoped declaration 'baz'. + } + +==== tslib.d.ts (0 errors) ==== + export declare function __addDisposableResource(env: any, value: T, async: boolean): T; + export declare function __disposeResources(env: any): void; + \ No newline at end of file diff --git a/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2015).js b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2015).js new file mode 100644 index 0000000000000..c7aa6cbd2433b --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2015).js @@ -0,0 +1,125 @@ +//// [tests/cases/conformance/statements/VariableStatements/usingDeclarations/usingDeclarationsInForOfShadowing.ts] //// + +//// [main.ts] +class Foo {} + +for (using foo of []) { + const foo = new Foo(); +} + +for (using bar of []) { + let bar = "test"; +} + +for (using baz of []) { + var baz = 42; +} + +//// [tslib.d.ts] +export declare function __addDisposableResource(env: any, value: T, async: boolean): T; +export declare function __disposeResources(env: any): void; + + +//// [main.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 { +} +for (const foo_1 of []) { + 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); + } +} +for (const bar_1 of []) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + const bar = __addDisposableResource(env_2, bar_1, false); + { + let bar = "test"; + } + } + catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } + finally { + __disposeResources(env_2); + } +} +for (const baz_1 of []) { + const env_3 = { stack: [], error: void 0, hasError: false }; + try { + const baz = __addDisposableResource(env_3, baz_1, false); + { + var baz = 42; + } + } + catch (e_3) { + env_3.error = e_3; + env_3.hasError = true; + } + finally { + __disposeResources(env_3); + } +} diff --git a/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2017).errors.txt b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2017).errors.txt new file mode 100644 index 0000000000000..9ff1e77bc34d6 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2017).errors.txt @@ -0,0 +1,24 @@ +main.ts(12,7): error TS2481: Cannot initialize outer scoped variable 'baz' in the same scope as block scoped declaration 'baz'. + + +==== main.ts (1 errors) ==== + class Foo {} + + for (using foo of []) { + const foo = new Foo(); + } + + for (using bar of []) { + let bar = "test"; + } + + for (using baz of []) { + var baz = 42; + ~~~ +!!! error TS2481: Cannot initialize outer scoped variable 'baz' in the same scope as block scoped declaration 'baz'. + } + +==== tslib.d.ts (0 errors) ==== + export declare function __addDisposableResource(env: any, value: T, async: boolean): T; + export declare function __disposeResources(env: any): void; + \ No newline at end of file diff --git a/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2017).js b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2017).js new file mode 100644 index 0000000000000..c7aa6cbd2433b --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2017).js @@ -0,0 +1,125 @@ +//// [tests/cases/conformance/statements/VariableStatements/usingDeclarations/usingDeclarationsInForOfShadowing.ts] //// + +//// [main.ts] +class Foo {} + +for (using foo of []) { + const foo = new Foo(); +} + +for (using bar of []) { + let bar = "test"; +} + +for (using baz of []) { + var baz = 42; +} + +//// [tslib.d.ts] +export declare function __addDisposableResource(env: any, value: T, async: boolean): T; +export declare function __disposeResources(env: any): void; + + +//// [main.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 { +} +for (const foo_1 of []) { + 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); + } +} +for (const bar_1 of []) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + const bar = __addDisposableResource(env_2, bar_1, false); + { + let bar = "test"; + } + } + catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } + finally { + __disposeResources(env_2); + } +} +for (const baz_1 of []) { + const env_3 = { stack: [], error: void 0, hasError: false }; + try { + const baz = __addDisposableResource(env_3, baz_1, false); + { + var baz = 42; + } + } + catch (e_3) { + env_3.error = e_3; + env_3.hasError = true; + } + finally { + __disposeResources(env_3); + } +} diff --git a/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2022).errors.txt b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2022).errors.txt new file mode 100644 index 0000000000000..9ff1e77bc34d6 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2022).errors.txt @@ -0,0 +1,24 @@ +main.ts(12,7): error TS2481: Cannot initialize outer scoped variable 'baz' in the same scope as block scoped declaration 'baz'. + + +==== main.ts (1 errors) ==== + class Foo {} + + for (using foo of []) { + const foo = new Foo(); + } + + for (using bar of []) { + let bar = "test"; + } + + for (using baz of []) { + var baz = 42; + ~~~ +!!! error TS2481: Cannot initialize outer scoped variable 'baz' in the same scope as block scoped declaration 'baz'. + } + +==== tslib.d.ts (0 errors) ==== + export declare function __addDisposableResource(env: any, value: T, async: boolean): T; + export declare function __disposeResources(env: any): void; + \ No newline at end of file diff --git a/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2022).js b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2022).js new file mode 100644 index 0000000000000..c7aa6cbd2433b --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es2022).js @@ -0,0 +1,125 @@ +//// [tests/cases/conformance/statements/VariableStatements/usingDeclarations/usingDeclarationsInForOfShadowing.ts] //// + +//// [main.ts] +class Foo {} + +for (using foo of []) { + const foo = new Foo(); +} + +for (using bar of []) { + let bar = "test"; +} + +for (using baz of []) { + var baz = 42; +} + +//// [tslib.d.ts] +export declare function __addDisposableResource(env: any, value: T, async: boolean): T; +export declare function __disposeResources(env: any): void; + + +//// [main.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 { +} +for (const foo_1 of []) { + 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); + } +} +for (const bar_1 of []) { + const env_2 = { stack: [], error: void 0, hasError: false }; + try { + const bar = __addDisposableResource(env_2, bar_1, false); + { + let bar = "test"; + } + } + catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } + finally { + __disposeResources(env_2); + } +} +for (const baz_1 of []) { + const env_3 = { stack: [], error: void 0, hasError: false }; + try { + const baz = __addDisposableResource(env_3, baz_1, false); + { + var baz = 42; + } + } + catch (e_3) { + env_3.error = e_3; + env_3.hasError = true; + } + finally { + __disposeResources(env_3); + } +} diff --git a/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es5).errors.txt b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es5).errors.txt new file mode 100644 index 0000000000000..9ff1e77bc34d6 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es5).errors.txt @@ -0,0 +1,24 @@ +main.ts(12,7): error TS2481: Cannot initialize outer scoped variable 'baz' in the same scope as block scoped declaration 'baz'. + + +==== main.ts (1 errors) ==== + class Foo {} + + for (using foo of []) { + const foo = new Foo(); + } + + for (using bar of []) { + let bar = "test"; + } + + for (using baz of []) { + var baz = 42; + ~~~ +!!! error TS2481: Cannot initialize outer scoped variable 'baz' in the same scope as block scoped declaration 'baz'. + } + +==== tslib.d.ts (0 errors) ==== + export declare function __addDisposableResource(env: any, value: T, async: boolean): T; + export declare function __disposeResources(env: any): void; + \ No newline at end of file diff --git a/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es5).js b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es5).js new file mode 100644 index 0000000000000..be5771ac0a662 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=es5).js @@ -0,0 +1,131 @@ +//// [tests/cases/conformance/statements/VariableStatements/usingDeclarations/usingDeclarationsInForOfShadowing.ts] //// + +//// [main.ts] +class Foo {} + +for (using foo of []) { + const foo = new Foo(); +} + +for (using bar of []) { + let bar = "test"; +} + +for (using baz of []) { + var baz = 42; +} + +//// [tslib.d.ts] +export declare function __addDisposableResource(env: any, value: T, async: boolean): T; +export declare function __disposeResources(env: any): void; + + +//// [main.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 Foo = /** @class */ (function () { + function Foo() { + } + return Foo; +}()); +for (var _i = 0, _a = []; _i < _a.length; _i++) { + var foo_1 = _a[_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); + } +} +for (var _b = 0, _c = []; _b < _c.length; _b++) { + var bar_1 = _c[_b]; + var env_2 = { stack: [], error: void 0, hasError: false }; + try { + var bar = __addDisposableResource(env_2, bar_1, false); + { + var bar_2 = "test"; + } + } + catch (e_2) { + env_2.error = e_2; + env_2.hasError = true; + } + finally { + __disposeResources(env_2); + } +} +for (var _d = 0, _e = []; _d < _e.length; _d++) { + var baz_1 = _e[_d]; + var env_3 = { stack: [], error: void 0, hasError: false }; + try { + var baz_1 = __addDisposableResource(env_3, baz_1, false); + { + var baz = 42; + } + } + catch (e_3) { + env_3.error = e_3; + env_3.hasError = true; + } + finally { + __disposeResources(env_3); + } +} diff --git a/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=esnext).errors.txt b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=esnext).errors.txt new file mode 100644 index 0000000000000..9ff1e77bc34d6 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=esnext).errors.txt @@ -0,0 +1,24 @@ +main.ts(12,7): error TS2481: Cannot initialize outer scoped variable 'baz' in the same scope as block scoped declaration 'baz'. + + +==== main.ts (1 errors) ==== + class Foo {} + + for (using foo of []) { + const foo = new Foo(); + } + + for (using bar of []) { + let bar = "test"; + } + + for (using baz of []) { + var baz = 42; + ~~~ +!!! error TS2481: Cannot initialize outer scoped variable 'baz' in the same scope as block scoped declaration 'baz'. + } + +==== tslib.d.ts (0 errors) ==== + export declare function __addDisposableResource(env: any, value: T, async: boolean): T; + export declare function __disposeResources(env: any): void; + \ No newline at end of file diff --git a/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=esnext).js b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=esnext).js new file mode 100644 index 0000000000000..ac64cb95ffa91 --- /dev/null +++ b/tests/baselines/reference/usingDeclarationsInForOfShadowing(target=esnext).js @@ -0,0 +1,34 @@ +//// [tests/cases/conformance/statements/VariableStatements/usingDeclarations/usingDeclarationsInForOfShadowing.ts] //// + +//// [main.ts] +class Foo {} + +for (using foo of []) { + const foo = new Foo(); +} + +for (using bar of []) { + let bar = "test"; +} + +for (using baz of []) { + var baz = 42; +} + +//// [tslib.d.ts] +export declare function __addDisposableResource(env: any, value: T, async: boolean): T; +export declare function __disposeResources(env: any): void; + + +//// [main.js] +class Foo { +} +for (using foo of []) { + const foo = new Foo(); +} +for (using bar of []) { + let bar = "test"; +} +for (using baz of []) { + var baz = 42; +} diff --git a/tests/cases/conformance/statements/VariableStatements/usingDeclarations/usingDeclarationsInForOfShadowing.ts b/tests/cases/conformance/statements/VariableStatements/usingDeclarations/usingDeclarationsInForOfShadowing.ts new file mode 100644 index 0000000000000..2a51a6231bd69 --- /dev/null +++ b/tests/cases/conformance/statements/VariableStatements/usingDeclarations/usingDeclarationsInForOfShadowing.ts @@ -0,0 +1,24 @@ +// @target: esnext,es2022,es2017,es2015,es5 +// @module: commonjs +// @lib: esnext +// @importHelpers: true +// @noTypesAndSymbols: true + +// @filename: main.ts +class Foo {} + +for (using foo of []) { + const foo = new Foo(); +} + +for (using bar of []) { + let bar = "test"; +} + +for (using baz of []) { + var baz = 42; +} + +// @filename: tslib.d.ts +export declare function __addDisposableResource(env: any, value: T, async: boolean): T; +export declare function __disposeResources(env: any): void;