Fix microsoft#27864

Signed-off-by: Joseph Watts <jwatts43@bloomberg.net>

Author: Joseph Watts

src/compiler/checker.ts

@@ -17487,6 +17487,23 @@ namespace ts {
             const links = getNodeLinks(node.expression);
             if (!links.resolvedType) {
                 links.resolvedType = checkExpression(node.expression);
+
+                if (languageVersion < ScriptTarget.ESNext && isPropertyDeclaration(node.parent) && isClassLike(node.parent.parent)) {
+                    const container = getEnclosingBlockScopeContainer(node);
+                    let current = container;
+                    let containedInIterationStatement = false;
+                    while (current && !nodeStartsNewLexicalEnvironment(current)) {
+                        if (isIterationStatement(current, /*lookInLabeledStatements*/ false)) {
+                            containedInIterationStatement = true;
+                            break;
+                        }
+                        current = current.parent;
+                    }
+                    if (containedInIterationStatement) {
+                        getNodeLinks(current).flags |= NodeCheckFlags.LoopWithCapturedBlockScopedBinding;
+                    }
+                    links.flags |= NodeCheckFlags.BlockScopedBindingInLoop;
+                }
                 // This will allow types number, string, symbol or any. It will also allow enums, the unknown
                 // type, and any union of these types (like string | number).
                 if (links.resolvedType.flags & TypeFlags.Nullable ||

src/compiler/transformer.ts

@@ -84,6 +84,8 @@ namespace ts {
         let lexicalEnvironmentFunctionDeclarations: FunctionDeclaration[];
         let lexicalEnvironmentVariableDeclarationsStack: VariableDeclaration[][] = [];
         let lexicalEnvironmentFunctionDeclarationsStack: FunctionDeclaration[][] = [];
+        let lexicalEnvironmentScopingStack: LexicalEnvironmentScoping[] = [];
+        let lexicalEnvironmentScoping: LexicalEnvironmentScoping;
         let lexicalEnvironmentStackOffset = 0;
         let lexicalEnvironmentSuspended = false;
         let emitHelpers: EmitHelper[] | undefined;
@@ -258,7 +260,7 @@ namespace ts {
          * Starts a new lexical environment. Any existing hoisted variable or function declarations
          * are pushed onto a stack, and the related storage variables are reset.
          */
-        function startLexicalEnvironment(): void {
+        function startLexicalEnvironment(scoping: LexicalEnvironmentScoping = LexicalEnvironmentScoping.Function): void {
             Debug.assert(state > TransformationState.Uninitialized, "Cannot modify the lexical environment during initialization.");
             Debug.assert(state < TransformationState.Completed, "Cannot modify the lexical environment after transformation has completed.");
             Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is suspended.");
@@ -267,11 +269,13 @@ namespace ts {
             // stack size variable. This allows us to reuse existing array slots we've
             // already allocated between transformations to avoid allocation and GC overhead during
             // transformation.
+            lexicalEnvironmentScopingStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentScoping;
             lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentVariableDeclarations;
             lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentFunctionDeclarations;
             lexicalEnvironmentStackOffset++;
             lexicalEnvironmentVariableDeclarations = undefined!;
             lexicalEnvironmentFunctionDeclarations = undefined!;
+            lexicalEnvironmentScoping = scoping;
         }
 
         /** Suspends the current lexical environment, usually after visiting a parameter list. */
@@ -308,7 +312,10 @@ namespace ts {
                 if (lexicalEnvironmentVariableDeclarations) {
                     const statement = createVariableStatement(
                         /*modifiers*/ undefined,
-                        createVariableDeclarationList(lexicalEnvironmentVariableDeclarations)
+                        createVariableDeclarationList(
+                            lexicalEnvironmentVariableDeclarations,
+                            lexicalEnvironmentScoping === LexicalEnvironmentScoping.Block ? NodeFlags.Let : undefined
+                        )
                     );
 
                     if (!statements) {
@@ -324,9 +331,11 @@ namespace ts {
             lexicalEnvironmentStackOffset--;
             lexicalEnvironmentVariableDeclarations = lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset];
             lexicalEnvironmentFunctionDeclarations = lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset];
+            lexicalEnvironmentScoping = lexicalEnvironmentScopingStack[lexicalEnvironmentStackOffset];
             if (lexicalEnvironmentStackOffset === 0) {
                 lexicalEnvironmentVariableDeclarationsStack = [];
                 lexicalEnvironmentFunctionDeclarationsStack = [];
+                lexicalEnvironmentScopingStack = [];
             }
             return statements;
         }
@@ -358,6 +367,7 @@ namespace ts {
                 lexicalEnvironmentVariableDeclarationsStack = undefined!;
                 lexicalEnvironmentFunctionDeclarations = undefined!;
                 lexicalEnvironmentFunctionDeclarationsStack = undefined!;
+                lexicalEnvironmentScopingStack = undefined!;
                 onSubstituteNode = undefined!;
                 onEmitNode = undefined!;
                 emitHelpers = undefined;

src/compiler/transformers/esnext.ts

@@ -12,6 +12,7 @@ namespace ts {
 
     export function transformESNext(context: TransformationContext) {
         const {
+            startLexicalEnvironment,
             resumeLexicalEnvironment,
             endLexicalEnvironment,
             hoistVariableDeclaration
@@ -84,6 +85,8 @@ namespace ts {
                 return node;
             }
             switch (node.kind) {
+                case SyntaxKind.Block:
+                    return visitBlock(node as Block);
                 case SyntaxKind.AwaitExpression:
                     return visitAwaitExpression(node as AwaitExpression);
                 case SyntaxKind.YieldExpression:
@@ -503,6 +506,18 @@ namespace ts {
             }
         }
 
+        function visitBlock(node: Block): Block {
+            startLexicalEnvironment(LexicalEnvironmentScoping.Block);
+            node = visitEachChild(node, visitor, context);
+            const declarations = endLexicalEnvironment();
+            if (some(declarations)) {
+                return updateBlock(
+                    node,
+                    mergeLexicalEnvironment(node.statements, declarations)
+                );
+            }
+            return node;
+        }
 
         function visitAwaitExpression(node: AwaitExpression): Expression {
             if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) {

src/compiler/types.ts

@@ -5229,6 +5229,11 @@ namespace ts {
         writeFile: WriteFileCallback;
     }
 
+    export const enum LexicalEnvironmentScoping {
+        Function,
+        Block
+    };
+
     export interface TransformationContext {
         /*@internal*/ getEmitResolver(): EmitResolver;
         /*@internal*/ getEmitHost(): EmitHost;
@@ -5237,7 +5242,7 @@ namespace ts {
         getCompilerOptions(): CompilerOptions;
 
         /** Starts a new lexical environment. */
-        startLexicalEnvironment(): void;
+        startLexicalEnvironment(scoping?: LexicalEnvironmentScoping): void;
 
         /** Suspends the current lexical environment, usually after visiting a parameter list. */
         suspendLexicalEnvironment(): void;