From 788239ff87106e847d8db6d702d104bd4f86f904 Mon Sep 17 00:00:00 2001 From: Zzzen Date: Tue, 29 Aug 2023 01:47:32 +0800 Subject: [PATCH] =?UTF-8?q?do=20not=20report=20use-before-declaration=20er?= =?UTF-8?q?ror=20in=20async=20like=20IIFE=20initial=E2=80=A6=20(#55279)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/compiler/checker.ts | 3 +- ...lockScopedVariablesUseBeforeDef.errors.txt | 15 +++++ .../blockScopedVariablesUseBeforeDef.js | 59 +++++++++++++++++++ .../blockScopedVariablesUseBeforeDef.symbols | 29 +++++++++ .../blockScopedVariablesUseBeforeDef.types | 41 +++++++++++++ .../blockScopedVariablesUseBeforeDef.ts | 15 +++++ 6 files changed, 160 insertions(+), 2 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index fd69b99c152..075b40d732c 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -452,7 +452,6 @@ import { isAssignmentOperator, isAssignmentPattern, isAssignmentTarget, - isAsyncFunction, isAutoAccessorPropertyDeclaration, isAwaitExpression, isBinaryExpression, @@ -3874,7 +3873,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker { function isSameScopeDescendentOf(initial: Node, parent: Node | undefined, stopAt: Node): boolean { return !!parent && !!findAncestor(initial, n => n === parent - || (n === stopAt || isFunctionLike(n) && (!getImmediatelyInvokedFunctionExpression(n) || isAsyncFunction(n)) ? "quit" : false)); + || (n === stopAt || isFunctionLike(n) && (!getImmediatelyInvokedFunctionExpression(n) || (getFunctionFlags(n) & FunctionFlags.AsyncGenerator)) ? "quit" : false)); } function getAnyImportSyntax(node: Node): AnyImportSyntax | undefined { diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.errors.txt b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.errors.txt index 771b237e28a..c9ff8364382 100644 --- a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.errors.txt +++ b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.errors.txt @@ -164,4 +164,19 @@ blockScopedVariablesUseBeforeDef.ts(122,22): error TS2448: Block-scoped variable const foo = 1; } + + // #30907 + function wrapI1() { + const iter = (function* foo() { + iter; + yield 1; + })(); + } + + function wrapI2() { + const iter = (async function* foo() { + iter; + yield 1; + })(); + } \ No newline at end of file diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js index 04274491f5a..0c1bca18f01 100644 --- a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js +++ b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.js @@ -136,6 +136,21 @@ function foo17() { const foo = 1; } + +// #30907 +function wrapI1() { + const iter = (function* foo() { + iter; + yield 1; + })(); +} + +function wrapI2() { + const iter = (async function* foo() { + iter; + yield 1; + })(); +} //// [blockScopedVariablesUseBeforeDef.js] @@ -179,6 +194,18 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : ""; return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name }); }; +var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); } +var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) { + if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined."); + var g = generator.apply(thisArg, _arguments || []), i, q = []; + return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i; + function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; } + function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } } + function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); } + function fulfill(value) { resume("next", value); } + function reject(value) { resume("throw", value); } + function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); } +}; function foo0() { var a = x; var x; @@ -329,3 +356,35 @@ function foo17() { }); })(); var foo = 1; } +// #30907 +function wrapI1() { + var iter = (function foo() { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + iter; + return [4 /*yield*/, 1]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); + })(); +} +function wrapI2() { + var iter = (function foo() { + return __asyncGenerator(this, arguments, function foo_1() { + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + iter; + return [4 /*yield*/, __await(1)]; + case 1: return [4 /*yield*/, _a.sent()]; + case 2: + _a.sent(); + return [2 /*return*/]; + } + }); + }); + })(); +} diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols index a64201efe26..5821664b5a7 100644 --- a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols +++ b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.symbols @@ -283,3 +283,32 @@ function foo17() { >foo : Symbol(foo, Decl(blockScopedVariablesUseBeforeDef.ts, 133, 9)) } +// #30907 +function wrapI1() { +>wrapI1 : Symbol(wrapI1, Decl(blockScopedVariablesUseBeforeDef.ts, 134, 1)) + + const iter = (function* foo() { +>iter : Symbol(iter, Decl(blockScopedVariablesUseBeforeDef.ts, 138, 9)) +>foo : Symbol(foo, Decl(blockScopedVariablesUseBeforeDef.ts, 138, 18)) + + iter; +>iter : Symbol(iter, Decl(blockScopedVariablesUseBeforeDef.ts, 138, 9)) + + yield 1; + })(); +} + +function wrapI2() { +>wrapI2 : Symbol(wrapI2, Decl(blockScopedVariablesUseBeforeDef.ts, 142, 1)) + + const iter = (async function* foo() { +>iter : Symbol(iter, Decl(blockScopedVariablesUseBeforeDef.ts, 145, 9)) +>foo : Symbol(foo, Decl(blockScopedVariablesUseBeforeDef.ts, 145, 18)) + + iter; +>iter : Symbol(iter, Decl(blockScopedVariablesUseBeforeDef.ts, 145, 9)) + + yield 1; + })(); +} + diff --git a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.types b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.types index 2bfda8a687b..9446d9999ef 100644 --- a/tests/baselines/reference/blockScopedVariablesUseBeforeDef.types +++ b/tests/baselines/reference/blockScopedVariablesUseBeforeDef.types @@ -320,3 +320,44 @@ function foo17() { >1 : 1 } +// #30907 +function wrapI1() { +>wrapI1 : () => void + + const iter = (function* foo() { +>iter : Generator +>(function* foo() { iter; yield 1; })() : Generator +>(function* foo() { iter; yield 1; }) : () => Generator +>function* foo() { iter; yield 1; } : () => Generator +>foo : () => Generator + + iter; +>iter : Generator + + yield 1; +>yield 1 : any +>1 : 1 + + })(); +} + +function wrapI2() { +>wrapI2 : () => void + + const iter = (async function* foo() { +>iter : AsyncGenerator +>(async function* foo() { iter; yield 1; })() : AsyncGenerator +>(async function* foo() { iter; yield 1; }) : () => AsyncGenerator +>async function* foo() { iter; yield 1; } : () => AsyncGenerator +>foo : () => AsyncGenerator + + iter; +>iter : AsyncGenerator + + yield 1; +>yield 1 : any +>1 : 1 + + })(); +} + diff --git a/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts b/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts index 435f1daf563..1fe0749eaab 100644 --- a/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts +++ b/tests/cases/compiler/blockScopedVariablesUseBeforeDef.ts @@ -135,3 +135,18 @@ function foo17() { const foo = 1; } + +// #30907 +function wrapI1() { + const iter = (function* foo() { + iter; + yield 1; + })(); +} + +function wrapI2() { + const iter = (async function* foo() { + iter; + yield 1; + })(); +}