do not report use-before-declaration error in async like IIFE initial… (#55279)

Zzzen · web-flow · commit 788239ff8710 · 2023-08-28T10:47:32.000-07:00
diff --git 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
@@ -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;
+        })();
+    }
     
diff --git 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
@@ -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
@@ -320,3 +320,44 @@ function foo17() {
 >1 : 1
 }
 
+// #30907
+function wrapI1() {
+>wrapI1 : () => void
+
+    const iter = (function* foo() {
+>iter : Generator<number, void, unknown>
+>(function* foo() {        iter;        yield 1;    })() : Generator<number, void, unknown>
+>(function* foo() {        iter;        yield 1;    }) : () => Generator<number, void, unknown>
+>function* foo() {        iter;        yield 1;    } : () => Generator<number, void, unknown>
+>foo : () => Generator<number, void, unknown>
+
+        iter;
+>iter : Generator<number, void, unknown>
+
+        yield 1;
+>yield 1 : any
+>1 : 1
+
+    })();
+}
+
+function wrapI2() {
+>wrapI2 : () => void
+
+    const iter = (async function* foo() {
+>iter : AsyncGenerator<number, void, unknown>
+>(async function* foo() {        iter;        yield 1;    })() : AsyncGenerator<number, void, unknown>
+>(async function* foo() {        iter;        yield 1;    }) : () => AsyncGenerator<number, void, unknown>
+>async function* foo() {        iter;        yield 1;    } : () => AsyncGenerator<number, void, unknown>
+>foo : () => AsyncGenerator<number, void, unknown>
+
+        iter;
+>iter : AsyncGenerator<number, void, unknown>
+
+        yield 1;
+>yield 1 : any
+>1 : 1
+
+    })();
+}
+
diff --git 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;
+    })();
+}
