Fix block-scope capturing with prop initializers

Author: joeywatts

Diff for: src/compiler/checker.ts

@@ -22254,8 +22254,10 @@ namespace ts {
             return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
         }
 
-        function isInsideFunction(node: Node, threshold: Node): boolean {
-            return !!findAncestor(node, n => n === threshold ? "quit" : isFunctionLike(n));
+        function isInsideFunctionOrInstancePropertyInitializer(node: Node, threshold: Node): boolean {
+            return !!findAncestor(node, n => n === threshold ? "quit" : isFunctionLike(n) || (
+                n.parent && isPropertyDeclaration(n.parent) && !hasStaticModifier(n.parent) && n.parent.initializer === n
+            ));
         }
 
         function getPartOfForStatementContainingNode(node: Node, container: ForStatement) {
@@ -22280,11 +22282,11 @@ namespace ts {
             // if there is an iteration statement in between declaration and boundary (is binding/class declared inside iteration statement)
 
             const container = getEnclosingBlockScopeContainer(symbol.valueDeclaration);
-            const usedInFunction = isInsideFunction(node.parent, container);
+            const isCaptured = isInsideFunctionOrInstancePropertyInitializer(node, container);
 
             const enclosingIterationStatement = getEnclosingIterationStatement(container);
             if (enclosingIterationStatement) {
-                if (usedInFunction) {
+                if (isCaptured) {
                     // mark iteration statement as containing block-scoped binding captured in some function
                     let capturesBlockScopeBindingInLoopBody = true;
                     if (isForStatement(container)) {
@@ -22322,7 +22324,7 @@ namespace ts {
                 getNodeLinks(symbol.valueDeclaration).flags |= NodeCheckFlags.BlockScopedBindingInLoop;
             }
 
-            if (usedInFunction) {
+            if (isCaptured) {
                 getNodeLinks(symbol.valueDeclaration).flags |= NodeCheckFlags.CapturedBlockScopedBinding;
             }
         }

Diff for: tests/baselines/reference/classDeclarationLoop.js

@@ -0,0 +1,24 @@
+//// [classDeclarationLoop.ts]
+const arr = [];
+for (let i = 0; i < 10; ++i) {
+    class C {
+        prop = i;
+    }
+    arr.push(C);
+}
+
+
+//// [classDeclarationLoop.js]
+var arr = [];
+var _loop_1 = function (i) {
+    var C = /** @class */ (function () {
+        function C() {
+            this.prop = i;
+        }
+        return C;
+    }());
+    arr.push(C);
+};
+for (var i = 0; i < 10; ++i) {
+    _loop_1(i);
+}

Diff for: tests/baselines/reference/classDeclarationLoop.symbols

@@ -0,0 +1,23 @@
+=== tests/cases/conformance/classes/classDeclarations/classDeclarationLoop.ts ===
+const arr = [];
+>arr : Symbol(arr, Decl(classDeclarationLoop.ts, 0, 5))
+
+for (let i = 0; i < 10; ++i) {
+>i : Symbol(i, Decl(classDeclarationLoop.ts, 1, 8))
+>i : Symbol(i, Decl(classDeclarationLoop.ts, 1, 8))
+>i : Symbol(i, Decl(classDeclarationLoop.ts, 1, 8))
+
+    class C {
+>C : Symbol(C, Decl(classDeclarationLoop.ts, 1, 30))
+
+        prop = i;
+>prop : Symbol(C.prop, Decl(classDeclarationLoop.ts, 2, 13))
+>i : Symbol(i, Decl(classDeclarationLoop.ts, 1, 8))
+    }
+    arr.push(C);
+>arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>arr : Symbol(arr, Decl(classDeclarationLoop.ts, 0, 5))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>C : Symbol(C, Decl(classDeclarationLoop.ts, 1, 30))
+}
+

Diff for: tests/baselines/reference/classDeclarationLoop.types

@@ -0,0 +1,29 @@
+=== tests/cases/conformance/classes/classDeclarations/classDeclarationLoop.ts ===
+const arr = [];
+>arr : any[]
+>[] : undefined[]
+
+for (let i = 0; i < 10; ++i) {
+>i : number
+>0 : 0
+>i < 10 : boolean
+>i : number
+>10 : 10
+>++i : number
+>i : number
+
+    class C {
+>C : C
+
+        prop = i;
+>prop : number
+>i : number
+    }
+    arr.push(C);
+>arr.push(C) : number
+>arr.push : (...items: any[]) => number
+>arr : any[]
+>push : (...items: any[]) => number
+>C : typeof C
+}
+

Diff for: tests/baselines/reference/classExpressionLoop.js

@@ -0,0 +1,22 @@
+//// [classExpressionLoop.ts]
+let arr = [];
+for (let i = 0; i < 10; ++i) {
+    arr.push(class C {
+        prop = i;
+    });
+}
+
+
+//// [classExpressionLoop.js]
+var arr = [];
+var _loop_1 = function (i) {
+    arr.push(/** @class */ (function () {
+        function C() {
+            this.prop = i;
+        }
+        return C;
+    }()));
+};
+for (var i = 0; i < 10; ++i) {
+    _loop_1(i);
+}

Diff for: tests/baselines/reference/classExpressionLoop.symbols

@@ -0,0 +1,22 @@
+=== tests/cases/conformance/classes/classExpressions/classExpressionLoop.ts ===
+let arr = [];
+>arr : Symbol(arr, Decl(classExpressionLoop.ts, 0, 3))
+
+for (let i = 0; i < 10; ++i) {
+>i : Symbol(i, Decl(classExpressionLoop.ts, 1, 8))
+>i : Symbol(i, Decl(classExpressionLoop.ts, 1, 8))
+>i : Symbol(i, Decl(classExpressionLoop.ts, 1, 8))
+
+    arr.push(class C {
+>arr.push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>arr : Symbol(arr, Decl(classExpressionLoop.ts, 0, 3))
+>push : Symbol(Array.push, Decl(lib.es5.d.ts, --, --))
+>C : Symbol(C, Decl(classExpressionLoop.ts, 2, 13))
+
+        prop = i;
+>prop : Symbol(C.prop, Decl(classExpressionLoop.ts, 2, 22))
+>i : Symbol(i, Decl(classExpressionLoop.ts, 1, 8))
+
+    });
+}
+

Diff for: tests/baselines/reference/classExpressionLoop.types

@@ -0,0 +1,29 @@
+=== tests/cases/conformance/classes/classExpressions/classExpressionLoop.ts ===
+let arr = [];
+>arr : any[]
+>[] : undefined[]
+
+for (let i = 0; i < 10; ++i) {
+>i : number
+>0 : 0
+>i < 10 : boolean
+>i : number
+>10 : 10
+>++i : number
+>i : number
+
+    arr.push(class C {
+>arr.push(class C {        prop = i;    }) : number
+>arr.push : (...items: any[]) => number
+>arr : any[]
+>push : (...items: any[]) => number
+>class C {        prop = i;    } : typeof C
+>C : typeof C
+
+        prop = i;
+>prop : number
+>i : number
+
+    });
+}
+

Diff for: tests/cases/conformance/classes/classDeclarations/classDeclarationLoop.ts

@@ -0,0 +1,7 @@
+const arr = [];
+for (let i = 0; i < 10; ++i) {
+    class C {
+        prop = i;
+    }
+    arr.push(C);
+}

Diff for: tests/cases/conformance/classes/classExpressions/classExpressionLoop.ts

@@ -0,0 +1,6 @@
+let arr = [];
+for (let i = 0; i < 10; ++i) {
+    arr.push(class C {
+        prop = i;
+    });
+}