From f0ba3f471adabce3df862adf89f7e8d17888c2b7 Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Sun, 11 Oct 2015 01:12:26 -0700
Subject: [PATCH 1/4] support block scoped vars captured in closures inside
 loops

---
 src/compiler/checker.ts                       |   24 +-
 src/compiler/diagnosticMessages.json          |    4 -
 src/compiler/emitter.ts                       |  560 ++++++++-
 src/compiler/types.ts                         |    4 +-
 src/compiler/utilities.ts                     |   16 +
 .../reference/capturedLetConstInLoop1.js      |  272 ++++
 .../reference/capturedLetConstInLoop1.symbols |  260 ++++
 .../reference/capturedLetConstInLoop1.types   |  428 +++++++
 .../reference/capturedLetConstInLoop1_ES6.js  |  210 ++++
 .../capturedLetConstInLoop1_ES6.symbols       |  260 ++++
 .../capturedLetConstInLoop1_ES6.types         |  428 +++++++
 .../reference/capturedLetConstInLoop2.js      |  413 ++++++
 .../reference/capturedLetConstInLoop2.symbols |  519 ++++++++
 .../reference/capturedLetConstInLoop2.types   |  726 +++++++++++
 .../reference/capturedLetConstInLoop2_ES6.js  |  330 +++++
 .../capturedLetConstInLoop2_ES6.symbols       |  518 ++++++++
 .../capturedLetConstInLoop2_ES6.types         |  725 +++++++++++
 .../reference/capturedLetConstInLoop3.js      |  473 +++++++
 .../reference/capturedLetConstInLoop3.symbols |  565 +++++++++
 .../reference/capturedLetConstInLoop3.types   |  794 ++++++++++++
 .../reference/capturedLetConstInLoop3_ES6.js  |  394 ++++++
 .../capturedLetConstInLoop3_ES6.symbols       |  566 +++++++++
 .../capturedLetConstInLoop3_ES6.types         |  795 ++++++++++++
 .../reference/capturedLetConstInLoop4.js      |  338 +++++
 .../reference/capturedLetConstInLoop4.symbols |  394 ++++++
 .../reference/capturedLetConstInLoop4.types   |  600 +++++++++
 .../reference/capturedLetConstInLoop4_ES6.js  |  266 ++++
 .../capturedLetConstInLoop4_ES6.symbols       |  394 ++++++
 .../capturedLetConstInLoop4_ES6.types         |  600 +++++++++
 .../reference/capturedLetConstInLoop5.js      |  617 +++++++++
 .../reference/capturedLetConstInLoop5.symbols |  682 ++++++++++
 .../reference/capturedLetConstInLoop5.types   |  951 ++++++++++++++
 .../reference/capturedLetConstInLoop5_ES6.js  |  518 ++++++++
 .../capturedLetConstInLoop5_ES6.symbols       |  683 ++++++++++
 .../capturedLetConstInLoop5_ES6.types         |  952 ++++++++++++++
 .../reference/capturedLetConstInLoop6.js      |  557 +++++++++
 .../reference/capturedLetConstInLoop6.symbols |  481 +++++++
 .../reference/capturedLetConstInLoop6.types   |  729 +++++++++++
 .../reference/capturedLetConstInLoop6_ES6.js  |  455 +++++++
 .../capturedLetConstInLoop6_ES6.symbols       |  481 +++++++
 .../capturedLetConstInLoop6_ES6.types         |  729 +++++++++++
 .../reference/capturedLetConstInLoop7.js      |  894 +++++++++++++
 .../reference/capturedLetConstInLoop7.symbols |  698 +++++++++++
 .../reference/capturedLetConstInLoop7.types   | 1106 +++++++++++++++++
 .../reference/capturedLetConstInLoop7_ES6.js  |  712 +++++++++++
 .../capturedLetConstInLoop7_ES6.symbols       |  698 +++++++++++
 .../capturedLetConstInLoop7_ES6.types         | 1106 +++++++++++++++++
 .../reference/capturedLetConstInLoop8.js      |  269 ++++
 .../reference/capturedLetConstInLoop8.symbols |  208 ++++
 .../reference/capturedLetConstInLoop8.types   |  329 +++++
 .../reference/capturedLetConstInLoop8_ES6.js  |  222 ++++
 .../capturedLetConstInLoop8_ES6.symbols       |  209 ++++
 .../capturedLetConstInLoop8_ES6.types         |  330 +++++
 .../reference/capturedLetConstInLoop9.js      |  252 ++++
 .../reference/capturedLetConstInLoop9.symbols |  219 ++++
 .../reference/capturedLetConstInLoop9.types   |  297 +++++
 .../reference/capturedLetConstInLoop9_ES6.js  |  221 ++++
 .../capturedLetConstInLoop9_ES6.symbols       |  220 ++++
 .../capturedLetConstInLoop9_ES6.types         |  298 +++++
 .../reference/downlevelLetConst18.errors.txt  |   23 +-
 .../reference/downlevelLetConst18.js          |   37 +-
 .../cases/compiler/capturedLetConstInLoop1.ts |  113 ++
 .../compiler/capturedLetConstInLoop1_ES6.ts   |  114 ++
 .../cases/compiler/capturedLetConstInLoop2.ts |  176 +++
 .../compiler/capturedLetConstInLoop2_ES6.ts   |  176 +++
 .../cases/compiler/capturedLetConstInLoop3.ts |  217 ++++
 .../compiler/capturedLetConstInLoop3_ES6.ts   |  219 ++++
 .../cases/compiler/capturedLetConstInLoop4.ts |  143 +++
 .../compiler/capturedLetConstInLoop4_ES6.ts   |  143 +++
 .../cases/compiler/capturedLetConstInLoop5.ts |  279 +++++
 .../compiler/capturedLetConstInLoop5_ES6.ts   |  281 +++++
 .../cases/compiler/capturedLetConstInLoop6.ts |  237 ++++
 .../compiler/capturedLetConstInLoop6_ES6.ts   |  238 ++++
 .../cases/compiler/capturedLetConstInLoop7.ts |  375 ++++++
 .../compiler/capturedLetConstInLoop7_ES6.ts   |  376 ++++++
 .../cases/compiler/capturedLetConstInLoop8.ts |  113 ++
 .../compiler/capturedLetConstInLoop8_ES6.ts   |  115 ++
 .../cases/compiler/capturedLetConstInLoop9.ts |  122 ++
 .../compiler/capturedLetConstInLoop9_ES6.ts   |  124 ++
 79 files changed, 31556 insertions(+), 64 deletions(-)
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop1.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop1.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop1.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop1_ES6.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop1_ES6.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop1_ES6.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop2.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop2.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop2.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop2_ES6.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop2_ES6.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop3.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop3.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop3.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop3_ES6.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop3_ES6.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop4.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop4.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop4.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop4_ES6.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop4_ES6.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop5.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop5.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop5.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop5_ES6.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop5_ES6.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop5_ES6.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop6.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop6.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop6.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop6_ES6.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop6_ES6.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop6_ES6.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop7.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop7.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop7.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop7_ES6.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop7_ES6.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop7_ES6.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop8.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop8.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop8.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop8_ES6.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop8_ES6.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop9.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop9.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop9.types
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop9_ES6.js
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
 create mode 100644 tests/baselines/reference/capturedLetConstInLoop9_ES6.types
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop1.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop1_ES6.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop2.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop2_ES6.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop3.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop3_ES6.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop4.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop4_ES6.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop5.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop5_ES6.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop6.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop6_ES6.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop7.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop7_ES6.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop8.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop8_ES6.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop9.ts
 create mode 100644 tests/cases/compiler/capturedLetConstInLoop9_ES6.ts

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index d4ce6655a21..5e73da9a7d4 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -6550,7 +6550,7 @@ namespace ts {
             while (current && !nodeStartsNewLexicalEnvironment(current)) {
                 if (isIterationStatement(current, /*lookInLabeledStatements*/ false)) {
                     if (inFunction) {
-                        grammarErrorOnFirstToken(current, Diagnostics.Loop_contains_block_scoped_variable_0_referenced_by_a_function_in_the_loop_This_is_only_supported_in_ECMAScript_6_or_higher, declarationNameToString(node));
+                        getNodeLinks(current).flags |= NodeCheckFlags.LoopWithBlockScopedBindingCapturedInFunction;
                     }
                     // mark value declaration so during emit they can have a special handling
                     getNodeLinks(<VariableDeclaration>symbol.valueDeclaration).flags |= NodeCheckFlags.BlockScopedBindingInLoop;
@@ -14533,6 +14533,10 @@ namespace ts {
 
         // Emitter support
 
+        function isArgumentsLocalBinding(node: Identifier): boolean {
+            return getReferencedValueSymbol(node) === argumentsSymbol;
+        }
+
         // When resolved as an expression identifier, if the given node references an exported entity, return the declaration
         // node of the exported entity's container. Otherwise, return undefined.
         function getReferencedExportContainer(node: Identifier): SourceFile | ModuleDeclaration | EnumDeclaration {
@@ -14837,7 +14841,8 @@ namespace ts {
                 collectLinkedAliases,
                 getReferencedValueDeclaration,
                 getTypeReferenceSerializationKind,
-                isOptionalParameter
+                isOptionalParameter,
+                isArgumentsLocalBinding
             };
         }
 
@@ -15664,21 +15669,6 @@ namespace ts {
             }
         }
 
-        function isIterationStatement(node: Node, lookInLabeledStatements: boolean): boolean {
-            switch (node.kind) {
-                case SyntaxKind.ForStatement:
-                case SyntaxKind.ForInStatement:
-                case SyntaxKind.ForOfStatement:
-                case SyntaxKind.DoStatement:
-                case SyntaxKind.WhileStatement:
-                    return true;
-                case SyntaxKind.LabeledStatement:
-                    return lookInLabeledStatements && isIterationStatement((<LabeledStatement>node).statement, lookInLabeledStatements);
-            }
-
-            return false;
-        }
-
         function checkGrammarBreakOrContinueStatement(node: BreakOrContinueStatement): boolean {
             let current: Node = node;
             while (current) {
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index b391545a733..9635610c133 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -2008,10 +2008,6 @@
         "category": "Error",
         "code": 4082
     },
-    "Loop contains block-scoped variable '{0}' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.": {
-        "category": "Error",
-        "code": 4091
-    },
     "The current host does not support the '{0}' option.": {
         "category": "Error",
         "code": 5001
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index f01b7cb54a4..cd0967c5717 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -379,6 +379,93 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             return true;
         }
 
+        const enum Jump {
+            Break       = 1 << 1,
+            Continue    = 1 << 2,
+            Return      = 1 << 3
+        }
+
+        interface ConvertedLoopState {
+            // set of labels that occured inside the converted loop
+            // used to determine if labeled jump can be emitted as is or it should be dispatched to calling code
+            labels?: Map<string>;
+            // collection of labeled jumps that transfer control outside the converted loop.
+            // maps store association 'label -> labelMarker' where
+            // - label - value of label as it apprear in code
+            // - label marker - return value that should be interpreted by calling code as 'jump to <label>' 
+            labeledNonLocalBreaks?: Map<string>;
+            labeledNonLocalContinues?: Map<string>;
+
+            // set of non-labeled jumps that transfer control outside the converted loop
+            // used to emit dispatching logic in the caller of converted loop
+            nonLocalJumps?: Jump;
+
+            // set of non-labeled jumps that should be interpreted as local
+            // i.e. if converted loop contains normal loop or switch statement then inside this loop break should be treated as local jump
+            allowedNonLabeledJumps?: Jump;
+
+            // alias for 'arguments' object from the calling code stack frame
+            // i.e.
+            // for (let x;;) <statement that captures x in closure and uses 'arguments'>
+            // should be converted to
+            // var loop = function(x) { <code where 'arguments' is replaced witg 'arguments_1'> }
+            // var arguments_1 = arguments
+            // for (var x;;) loop(x);
+            // otherwise semantics of the code will be different since 'arguments' inside converted loop body 
+            // will refer to function that holds converted loop.
+            // This value is set on demand.
+            argumentsName?: string;
+
+            // list of non-block scoped variable declarations that appear inside converted loop
+            // such variable declarations should be moved outside the loop body 
+            // for (let x;;) {
+            //     var y = 1;
+            //     ... 
+            // }
+            // should be converted to
+            // var loop = function(x) {
+            //    y = 1;
+            //    ...
+            // }
+            // var y;
+            // for (var x;;) loop(x);
+            hoistedLocalVariables?: Identifier[];
+        }
+
+        function setLabeledJump(state: ConvertedLoopState, isBreak: boolean, labelText: string, labelMarker: string): void {
+            if (isBreak) {
+                if (!state.labeledNonLocalBreaks) {
+                    state.labeledNonLocalBreaks = {};
+                }
+                state.labeledNonLocalBreaks[labelText] = labelMarker;
+            }
+            else {
+                if (!state.labeledNonLocalContinues) {
+                    state.labeledNonLocalContinues = {};
+                }
+                state.labeledNonLocalContinues[labelText] = labelMarker;
+            }
+        }
+
+        function hoistVariableDeclarationFromLoop(state: ConvertedLoopState, declaration: VariableDeclaration): void {
+            if (!state.hoistedLocalVariables) {
+                state.hoistedLocalVariables = [];
+            }
+
+            visit(declaration.name);
+
+            function visit(node: Identifier | BindingPattern) {
+                if (node.kind === SyntaxKind.Identifier) {
+                    state.hoistedLocalVariables.push((<Identifier>node));
+                }
+                else {
+                    for (const element of (<BindingPattern>node).elements) {
+                        visit(element.name);
+                    }
+                }
+            }
+        }
+
         function emitJavaScript(jsFilePath: string, root?: SourceFile) {
             let writer = createTextWriter(newLine);
             let { write, writeTextOfNode, writeLine, increaseIndent, decreaseIndent } = writer;
@@ -396,6 +483,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             let nodeToGeneratedName: string[] = [];
             let computedPropertyNamesToGeneratedNames: string[];
 
+            let convertedLoopState: ConvertedLoopState;
+
             let extendsEmitted = false;
             let decorateEmitted = false;
             let paramEmitted = false;
@@ -1823,6 +1912,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitIdentifier(node: Identifier) {
+                if (convertedLoopState) {
+                    if (node.text == "arguments" && resolver.isArgumentsLocalBinding(node)) {
+                        // in converted loop body arguments cannot be used directly.
+                        let name = convertedLoopState.argumentsName || (convertedLoopState.argumentsName = makeUniqueName("arguments"));
+                        write(name);
+                        return;
+                    }
+                }
+
                 if (!node.parent) {
                     write(node.text);
                 }
@@ -2914,8 +3012,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitDoStatement(node: DoStatement) {
+                emitLoop(node, emitDoStatementWorker);
+            }
+
+            function emitDoStatementWorker(node: DoStatement, loop: ConvertedLoop) {
                 write("do");
-                emitEmbeddedStatement(node.statement);
+                if (loop) {
+                    emitConvertedLoopCall(loop, /* emitAsBlock */ true);
+                }
+                else {
+                    emitNormalLoopBody(node, /* emitAsEmbeddedStatement */ true);
+                }
                 if (node.statement.kind === SyntaxKind.Block) {
                     write(" ");
                 }
@@ -2928,10 +3035,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitWhileStatement(node: WhileStatement) {
+                emitLoop(node, emitWhileStatementWorker);
+            }
+
+            function emitWhileStatementWorker(node: WhileStatement, loop: ConvertedLoop) {
                 write("while (");
                 emit(node.expression);
                 write(")");
-                emitEmbeddedStatement(node.statement);
+
+                if (loop) {
+                    emitConvertedLoopCall(loop, /* emitAsBlock */ true);
+                }
+                else {
+                    emitNormalLoopBody(node, /* emitAsEmbeddedStatement */ true);
+                }
             }
 
             /**
@@ -2945,6 +3062,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     return false;
                 }
 
+                if (convertedLoopState && (getCombinedNodeFlags(decl) & NodeFlags.BlockScoped) === 0) {
+                    // we are inside a converted loop - this can only happen in downlevel scenarios 
+                    // record names for all variable declarations
+                    for (const varDecl of decl.declarations) {
+                        hoistVariableDeclarationFromLoop(convertedLoopState, varDecl);
+                    }
+                    return false;
+                }
+
                 let tokenKind = SyntaxKind.VarKeyword;
                 if (decl && languageVersion >= ScriptTarget.ES6) {
                     if (isLet(decl)) {
@@ -2996,7 +3122,293 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 return started;
             }
 
+            interface ConvertedLoop {
+                functionName: string;
+                paramList: string;
+                state: ConvertedLoopState;
+            }
+
+            function shouldConvertLoopBody(node: IterationStatement): boolean {
+                return languageVersion < ScriptTarget.ES6 &&
+                    (resolver.getNodeCheckFlags(node) & NodeCheckFlags.LoopWithBlockScopedBindingCapturedInFunction) !== 0;
+            }
+
+            function emitLoop(node: IterationStatement, loopEmitter: (n: IterationStatement, convertedLoop: ConvertedLoop) => void): void {
+                const shouldConvert = shouldConvertLoopBody(node);
+                if (!shouldConvert) {
+                    loopEmitter(node, /* convertedLoop*/ undefined);
+                }
+                else {
+                    const loop = convertLoopBody(node);
+                    if (node.parent.kind === SyntaxKind.LabeledStatement) {
+                        // if parent of the loop was labeled statement - attach the label to loop skipping converted loop body
+                        emitLabelAndColon(<LabeledStatement>node.parent);
+                    }
+                    loopEmitter(node, loop);
+                }
+            }
+
+            function convertLoopBody(node: IterationStatement): ConvertedLoop {
+                const functionName = makeUniqueName("_loop");
+
+                let loopInitializer: VariableDeclarationList;
+                switch (node.kind) {
+                    case SyntaxKind.ForStatement:
+                    case SyntaxKind.ForInStatement:
+                    case SyntaxKind.ForOfStatement:
+                        if ((<ForStatement | ForInStatement | ForOfStatement>node).initializer.kind === SyntaxKind.VariableDeclarationList) {
+                            loopInitializer = <VariableDeclarationList>(<ForStatement | ForInStatement | ForOfStatement>node).initializer;
+                        }
+                        break;
+                }
+
+                let loopParameters: string[];
+                if (loopInitializer && (getCombinedNodeFlags(loopInitializer) & NodeFlags.BlockScoped)) {
+                    // if loop initializer contains block scoped variables - they should be passed to converted loop body as parameters
+                    loopParameters = [];
+                    for (const varDeclaration of loopInitializer.declarations) {
+                        collectNames(varDeclaration.name);
+                    }
+                }
+
+                const bodyIsBlock = node.statement.kind === SyntaxKind.Block;
+                const paramList = loopParameters ? loopParameters.join(", ") : "";
+
+                writeLine();
+                write(`var ${functionName} = function(${paramList})`);
+
+                if (!bodyIsBlock) {
+                    write(" {");
+                    writeLine();
+                    increaseIndent();
+                }
+
+                const convertedOuterLoopState = convertedLoopState;
+                convertedLoopState = {};
+
+                if (convertedOuterLoopState) {
+                    // convertedOuterLoopState !== undefined means that this converted loop is nested in another converted loop
+                    // if outer converted loop has already accumulated some state - pass it through
+                    if (convertedOuterLoopState.argumentsName) {
+                        // outer loop has already used 'arguments' so we've already have some name to alias it
+                        // use the same name in all nested loops
+                        convertedLoopState.argumentsName = convertedOuterLoopState.argumentsName;
+                    }
+
+                    if (convertedOuterLoopState.hoistedLocalVariables) {
+                        // we've already collected some non-block scoped variable declarations in enclosing loop
+                        // use the same storage in nested loop
+                        convertedLoopState.hoistedLocalVariables = convertedOuterLoopState.hoistedLocalVariables;
+                    }
+                }
+
+                emitEmbeddedStatement(node.statement);
+
+                if (!bodyIsBlock) {
+                    decreaseIndent();
+                    writeLine();
+                    write("}");
+                }
+                write(";");
+                writeLine();
+
+                if (convertedLoopState.argumentsName) {
+                    // if alias for arguments is set
+                    if (convertedOuterLoopState) {
+                        // pass it to outer converted loop
+                        convertedOuterLoopState.argumentsName = convertedLoopState.argumentsName;
+                    }
+                    else {
+                        // this is top level converted loop and 
+                        // create an alias for 'arguments' object
+                        write(`var ${convertedLoopState.argumentsName} = arguments;`);
+                        writeLine();
+                    }
+                }
+
+                if (convertedLoopState.hoistedLocalVariables) {
+                    // if hoistedLocalVariables !== undefined this means that we've possibly collected some variable declarations to be hoisted later
+                    if (convertedOuterLoopState) {
+                        // pass them to outer converted loop
+                        convertedOuterLoopState.hoistedLocalVariables = convertedLoopState.hoistedLocalVariables;
+                    }
+                    else {
+                        // deduplicate and hoist collected variable declarations
+                        write("var ");
+                        let seen: Map<string>;
+                        for (const id of convertedLoopState.hoistedLocalVariables) {
+                           if (!seen) {
+                               seen = {};
+                           }
+                           else {
+                               write(", ");
+                           }
+                           if (!hasProperty(seen, id.text)) {
+                               emit(id);
+                               seen[id.text] = id.text;
+                           }
+                        }
+                        write(";");
+                        writeLine();
+                    }
+                }
+
+                const currentLoopState = convertedLoopState;
+                convertedLoopState = convertedOuterLoopState;
+
+                return { functionName, paramList, state: currentLoopState };
+
+                function collectNames(name: Identifier | BindingPattern): void {
+                    if (name.kind === SyntaxKind.Identifier) {
+                        const nameText = isNameOfNestedRedeclaration(<Identifier>name) ? getGeneratedNameForNode(name) : (<Identifier>name).text;
+                        loopParameters.push(nameText);
+                    }
+                    else {
+                        for (const element of (<BindingPattern>name).elements) {
+                            collectNames(element.name);
+                        }
+                    }
+                }
+            }
+
+            function emitNormalLoopBody(node: IterationStatement, emitAsEmbeddedStatement: boolean): void {
+                let saveAllowedNonLabeledJumps: Jump;
+                if (convertedLoopState) {
+                    // we get here if we are trying to emit normal loop loop inside converted loop
+                    // set allowedNonLabeledJumps to Break | Continue to mark that break\continue inside the loop should be emitted as is
+                    saveAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps;
+                    convertedLoopState.allowedNonLabeledJumps = Jump.Break | Jump.Continue;
+                }
+
+                if (emitAsEmbeddedStatement) {
+                    emitEmbeddedStatement(node.statement);
+                }
+                else if (node.statement.kind === SyntaxKind.Block) {
+                    emitLines((<Block>node.statement).statements);
+                }
+                else {
+                    writeLine();
+                    emit(node.statement);
+                }
+
+                if (convertedLoopState) {
+                    convertedLoopState.allowedNonLabeledJumps = saveAllowedNonLabeledJumps;
+                }
+            }
+
+            function emitConvertedLoopCall(loop: ConvertedLoop, emitAsBlock: boolean): void {
+                if (emitAsBlock) {
+                    write(" {");
+                    writeLine();
+                    increaseIndent();
+                }
+
+                // loop is considered simple if it does not have any return statements or break\continue that transfer control outside of the loop
+                // simple loops are emitted as just 'loop()';
+                const isSimpleLoop =
+                    !loop.state.nonLocalJumps &&
+                    !loop.state.labeledNonLocalBreaks &&
+                    !loop.state.labeledNonLocalContinues;
+
+                const loopResult = makeUniqueName("state");
+                if (!isSimpleLoop) {
+                    write(`var ${loopResult} = `);
+                }
+
+                write(`${loop.functionName}(${loop.paramList});`);
+
+                if (!isSimpleLoop) {
+                    // for non simple loops we need to store result returned from converted loop function and use it to do dispatching
+                    // converted loop function can return:
+                    // - object - used when body of the converted loop contains return statement. Property "value" of this object stores retuned value
+                    // - string - used to dispatch jumps. "break" and "continue" are used to non-labeled jumps, other values are used to transfer control to
+                    //   different labels
+                    writeLine();
+                    if (loop.state.nonLocalJumps & Jump.Return) {
+                        write(`if (typeof ${loopResult} === "object") `);
+                        if (convertedLoopState) {
+                            // we are currently nested in another converted loop - return unwrapped result
+                            write(`return ${loopResult};`);
+                            // propagate 'hasReturn' flag to outer loop
+                            convertedLoopState.nonLocalJumps |= Jump.Return;
+                        }
+                        else {
+                            // top level converted loop - return unwrapped value
+                            write(`return ${loopResult}.value`);
+                        }
+                        writeLine();
+                    }
+
+                    if (loop.state.nonLocalJumps & Jump.Break) {
+                        write(`if (${loopResult} === "break") break;`);
+                        writeLine();
+                    }
+
+                    if (loop.state.nonLocalJumps & Jump.Continue) {
+                        write(`if (${loopResult} === "continue") continue;`);
+                        writeLine();
+                    }
+
+                    // in case of labeled breaks emit code that either breaks to some known label inside outer loop or delegates jump decision to outer loop
+                    emitDispatchTableForLabeledJumps(loopResult, loop.state, convertedLoopState);
+                }
+
+                if (emitAsBlock) {
+                    writeLine();
+                    decreaseIndent();
+                    write("}");
+                }
+
+                function emitDispatchTableForLabeledJumps(loopResultVariable: string, currentLoop: ConvertedLoopState, outerLoop: ConvertedLoopState) {
+                    if (!currentLoop.labeledNonLocalBreaks && !currentLoop.labeledNonLocalContinues) {
+                        return;
+                    }
+
+                    write(`switch(${loopResultVariable}) {`);
+                    increaseIndent();
+
+                    emitDispatchEntriesForLabeledJumps(currentLoop.labeledNonLocalBreaks, /* isBreak */ true, loopResultVariable, outerLoop);
+                    emitDispatchEntriesForLabeledJumps(currentLoop.labeledNonLocalContinues, /* isBreak */ false, loopResultVariable, outerLoop);
+
+                    decreaseIndent();
+                    writeLine();
+                    write("}");
+                }
+
+                function emitDispatchEntriesForLabeledJumps(table: Map<string>, isBreak: boolean, loopResultVariable: string, outerLoop: ConvertedLoopState): void {
+                    if (!table) {
+                        return;
+                    }
+
+                    for (let labelText in table) {
+                        let labelMarker = table[labelText];
+                        writeLine();
+                        write(`case "${labelMarker}": `);
+                        // if there are no outer converted loop or outer label in question is located inside outer converted loop
+                        // then emit labeled break\continue
+                        // otherwise propagate pair 'label -> marker' to outer converted loop and emit 'return labelMarker' so outer loop can later decide what to do  
+                        if (!outerLoop || (outerLoop.labels && outerLoop.labels[labelText])) {
+                            if (isBreak) {
+                                write("break ");
+                            }
+                            else {
+                                write("continue ");
+                            }
+                            write(`${labelText};`);
+                        }
+                        else {
+                            setLabeledJump(outerLoop, isBreak, labelText, labelMarker);
+                            write(`return ${loopResultVariable};`);
+                        }
+                    }
+                }
+            }
+
             function emitForStatement(node: ForStatement) {
+                emitLoop(node, emitForStatementWorker);
+            }
+
+            function emitForStatementWorker(node: ForStatement, loop: ConvertedLoop) {
                 let endPos = emitToken(SyntaxKind.ForKeyword, node.pos);
                 write(" ");
                 endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
@@ -3018,14 +3430,25 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(";");
                 emitOptional(" ", node.incrementor);
                 write(")");
-                emitEmbeddedStatement(node.statement);
+
+                if (loop) {
+                    emitConvertedLoopCall(loop, /* emitAsBlock */ true);
+                }
+                else {
+                    emitNormalLoopBody(node, /* emitAsEmbeddedStatement */ true);
+                }
             }
 
             function emitForInOrForOfStatement(node: ForInStatement | ForOfStatement) {
                 if (languageVersion < ScriptTarget.ES6 && node.kind === SyntaxKind.ForOfStatement) {
-                    return emitDownLevelForOfStatement(node);
+                    emitLoop(node, emitDownLevelForOfStatementWorker);
                 }
+                else {
+                    emitLoop(node, emitForInOrForOfStatementWorker);
+                }
+            }
 
+            function emitForInOrForOfStatementWorker(node: ForInStatement | ForOfStatement, loop: ConvertedLoop) {
                 let endPos = emitToken(SyntaxKind.ForKeyword, node.pos);
                 write(" ");
                 endPos = emitToken(SyntaxKind.OpenParenToken, endPos);
@@ -3048,10 +3471,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
                 emit(node.expression);
                 emitToken(SyntaxKind.CloseParenToken, node.expression.end);
-                emitEmbeddedStatement(node.statement);
+
+                if (loop) {
+                    emitConvertedLoopCall(loop, /* emitAsBlock */ true);
+                }
+                else {
+                    emitNormalLoopBody(node, /* emitAsEmbeddedStatement */ true);
+                }
             }
 
             function emitDownLevelForOfStatement(node: ForOfStatement) {
+                emitLoop(node, emitDownLevelForOfStatementWorker);
+            }
+
+            function emitDownLevelForOfStatementWorker(node: ForOfStatement, loop: ConvertedLoop) {
                 // The following ES6 code:
                 //
                 //    for (let v of expr) { }
@@ -3181,12 +3614,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 emitEnd(node.initializer);
                 write(";");
 
-                if (node.statement.kind === SyntaxKind.Block) {
-                    emitLines((<Block>node.statement).statements);
+                if (loop) {
+                    writeLine();
+                    emitConvertedLoopCall(loop, /* emitAsBlock */ false);
                 }
                 else {
-                    writeLine();
-                    emit(node.statement);
+                    emitNormalLoopBody(node, /* emitAsEmbeddedStatement */ false);
                 }
 
                 writeLine();
@@ -3195,12 +3628,63 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitBreakOrContinueStatement(node: BreakOrContinueStatement) {
+                if (convertedLoopState) {
+                    // check if we can emit break\continue as is
+                    // it is possible if either
+                    //   - break\continue is statement labeled and label is located inside the converted loop
+                    //   - break\continue is non-labeled and located in non-converted loop\switch statement
+                    const jump = node.kind === SyntaxKind.BreakStatement ? Jump.Break : Jump.Continue;
+                    const canUseBreakOrContinue =
+                        (node.label && convertedLoopState.labels && convertedLoopState.labels[node.label.text]) ||
+                        (!node.label && (convertedLoopState.allowedNonLabeledJumps & jump));
+
+                    if (!canUseBreakOrContinue) {
+                        if (!node.label) {
+                            if (node.kind === SyntaxKind.BreakStatement) {
+                                convertedLoopState.nonLocalJumps |= Jump.Break;
+                                write(`return "break";`);
+                            }
+                            else {
+                                convertedLoopState.nonLocalJumps |= Jump.Continue;
+                                write(`return "continue";`);
+                            }
+                        }
+                        else {
+                            let labelMarker: string;
+                            if (node.kind === SyntaxKind.BreakStatement) {
+                                labelMarker = `break-${node.label.text}`;
+                                setLabeledJump(convertedLoopState, /* isBreak */ true, node.label.text, labelMarker);
+                            }
+                            else {
+                                labelMarker = `continue-${node.label.text}`;
+                                setLabeledJump(convertedLoopState, /* isBreak */ false, node.label.text, labelMarker);
+                            }
+                            write(`return "${labelMarker}";`);
+                        }
+
+                        return;
+                    }
+                }
+
                 emitToken(node.kind === SyntaxKind.BreakStatement ? SyntaxKind.BreakKeyword : SyntaxKind.ContinueKeyword, node.pos);
                 emitOptional(" ", node.label);
                 write(";");
             }
 
             function emitReturnStatement(node: ReturnStatement) {
+                if (convertedLoopState) {
+                    convertedLoopState.nonLocalJumps |= Jump.Return;
+                    write(`return { value: `);
+                    if (node.expression) {
+                        emit(node.expression);
+                    }
+                    else {
+                        write("undefined");
+                    }
+                    write(" };");
+                    return;
+                }
+
                 emitToken(SyntaxKind.ReturnKeyword, node.pos);
                 emitOptional(" ", node.expression);
                 write(";");
@@ -3220,7 +3704,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 emit(node.expression);
                 endPos = emitToken(SyntaxKind.CloseParenToken, node.expression.end);
                 write(" ");
+
+                let saveAllowedNonLabeledJumps: Jump;
+                if (convertedLoopState) {
+                    saveAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps;
+                    // for switch statement allow only non-labeled break
+                    convertedLoopState.allowedNonLabeledJumps |= Jump.Break;
+                }
                 emitCaseBlock(node.caseBlock, endPos);
+                if (convertedLoopState) {
+                    convertedLoopState.allowedNonLabeledJumps = saveAllowedNonLabeledJumps;
+                }
             }
 
             function emitCaseBlock(node: CaseBlock, startPos: number): void {
@@ -3301,10 +3795,28 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(";");
             }
 
-            function emitLabelledStatement(node: LabeledStatement) {
+            function emitLabelAndColon(node: LabeledStatement): void {
                 emit(node.label);
                 write(": ");
+            }
+
+            function emitLabelledStatement(node: LabeledStatement) {
+                if (!isIterationStatement(node.statement, /* lookInLabeledStatements */ false) || !shouldConvertLoopBody(<IterationStatement>node.statement)) {
+                    emitLabelAndColon(node);
+                }
+
+                if (convertedLoopState) {
+                    if (!convertedLoopState.labels) {
+                        convertedLoopState.labels = {};
+                    }
+                    convertedLoopState.labels[node.label.text] = node.label.text;
+                }
+
                 emit(node.statement);
+
+                if (convertedLoopState) {
+                    convertedLoopState.labels[node.label.text] = undefined;
+                }
             }
 
             function getContainingModule(node: Node): ModuleDeclaration {
@@ -3717,12 +4229,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         // for (...) { var <some-uniqie-name> = void 0; }
                         // this is necessary to preserve ES6 semantic in scenarios like
                         // for (...) { let x; console.log(x); x = 1 } // assignment on one iteration should not affect other iterations
-                        let isUninitializedLet =
+                        let isLetDefinedInLoop =
                             (resolver.getNodeCheckFlags(node) & NodeCheckFlags.BlockScopedBindingInLoop) &&
                             (getCombinedFlagsForIdentifier(<Identifier>node.name) & NodeFlags.Let);
 
                         // NOTE: default initialization should not be added to let bindings in for-in\for-of statements
-                        if (isUninitializedLet &&
+                        if (isLetDefinedInLoop &&
                             node.parent.parent.kind !== SyntaxKind.ForInStatement &&
                             node.parent.parent.kind !== SyntaxKind.ForOfStatement) {
                             initializer = createVoidZero();
@@ -4205,9 +4717,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitSignatureAndBody(node: FunctionLikeDeclaration) {
+                const saveConvertedLoopState = convertedLoopState;
                 let saveTempFlags = tempFlags;
                 let saveTempVariables = tempVariables;
                 let saveTempParameters = tempParameters;
+
+                convertedLoopState = undefined;
                 tempFlags = 0;
                 tempVariables = undefined;
                 tempParameters = undefined;
@@ -4233,6 +4748,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     emitExportMemberAssignment(node);
                 }
 
+                Debug.assert(convertedLoopState === undefined);
+                convertedLoopState = saveConvertedLoopState;
+
                 tempFlags = saveTempFlags;
                 tempVariables = saveTempVariables;
                 tempParameters = saveTempParameters;
@@ -4554,15 +5072,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             }
 
             function emitConstructor(node: ClassLikeDeclaration, baseTypeElement: ExpressionWithTypeArguments) {
+                const saveConvertedLoopState = convertedLoopState;
                 let saveTempFlags = tempFlags;
                 let saveTempVariables = tempVariables;
                 let saveTempParameters = tempParameters;
+
+                convertedLoopState = undefined;
                 tempFlags = 0;
                 tempVariables = undefined;
                 tempParameters = undefined;
 
                 emitConstructorWorker(node, baseTypeElement);
 
+                Debug.assert(convertedLoopState === undefined);
+                convertedLoopState = saveConvertedLoopState;
+
                 tempFlags = saveTempFlags;
                 tempVariables = saveTempVariables;
                 tempParameters = saveTempParameters;
@@ -4900,6 +5424,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 let saveTempVariables = tempVariables;
                 let saveTempParameters = tempParameters;
                 let saveComputedPropertyNamesToGeneratedNames = computedPropertyNamesToGeneratedNames;
+                let saveConvertedLoopState = convertedLoopState;
+
+                convertedLoopState = undefined;
                 tempFlags = 0;
                 tempVariables = undefined;
                 tempParameters = undefined;
@@ -4927,6 +5454,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 });
                 write(";");
                 emitTempDeclarations(/*newLine*/ true);
+
+                Debug.assert(convertedLoopState === undefined);
+                convertedLoopState = saveConvertedLoopState;
+
                 tempFlags = saveTempFlags;
                 tempVariables = saveTempVariables;
                 tempParameters = saveTempParameters;
@@ -5608,13 +6139,18 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 emitEnd(node.name);
                 write(") ");
                 if (node.body.kind === SyntaxKind.ModuleBlock) {
+                    const saveConvertedLoopState = convertedLoopState;
                     let saveTempFlags = tempFlags;
                     let saveTempVariables = tempVariables;
+                    convertedLoopState = undefined;
                     tempFlags = 0;
                     tempVariables = undefined;
 
                     emit(node.body);
 
+                    Debug.assert(convertedLoopState === undefined);
+                    convertedLoopState = saveConvertedLoopState;
+
                     tempFlags = saveTempFlags;
                     tempVariables = saveTempVariables;
                 }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index cbaa3e65e27..8a7500f6870 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1605,6 +1605,7 @@ namespace ts {
         getReferencedValueDeclaration(reference: Identifier): Declaration;
         getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind;
         isOptionalParameter(node: ParameterDeclaration): boolean;
+        isArgumentsLocalBinding(node: Identifier): boolean;
     }
 
     export const enum SymbolFlags {
@@ -1749,7 +1750,8 @@ namespace ts {
         // Values for enum members have been computed, and any errors have been reported for them.
         EnumValuesComputed          = 0x00002000,
         BlockScopedBindingInLoop    = 0x00004000,
-        LexicalModuleMergesWithClass= 0x00008000,  // Instantiated lexical module declaration is merged with a previous class declaration.
+        LexicalModuleMergesWithClass = 0x00008000,  // Instantiated lexical module declaration is merged with a previous class declaration.
+        LoopWithBlockScopedBindingCapturedInFunction = 0x00010000, // Loop that contains block scoped variable captured in closure
     }
 
     /* @internal */
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 5127b98ab3a..127159033ab 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -657,6 +657,22 @@ namespace ts {
         return false;
     }
 
+    export function isIterationStatement(node: Node, lookInLabeledStatements: boolean): boolean {
+        switch (node.kind) {
+            case SyntaxKind.ForStatement:
+            case SyntaxKind.ForInStatement:
+            case SyntaxKind.ForOfStatement:
+            case SyntaxKind.DoStatement:
+            case SyntaxKind.WhileStatement:
+                return true;
+            case SyntaxKind.LabeledStatement:
+                return lookInLabeledStatements && isIterationStatement((<LabeledStatement>node).statement, lookInLabeledStatements);
+        }
+
+        return false;
+    }
+
+
     export function isFunctionBlock(node: Node) {
         return node && node.kind === SyntaxKind.Block && isFunctionLike(node.parent);
     }
diff --git a/tests/baselines/reference/capturedLetConstInLoop1.js b/tests/baselines/reference/capturedLetConstInLoop1.js
new file mode 100644
index 00000000000..633b78af510
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop1.js
@@ -0,0 +1,272 @@
+//// [capturedLetConstInLoop1.ts]
+//==== let
+for (let x in {}) {
+    (function() { return x});
+    (() => x);
+}
+
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+}
+
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+}
+
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+}
+
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+//=========const
+for (const x in {}) {
+    (function() { return x});
+    (() => x);
+}
+
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+}
+
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+}
+
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+//// [capturedLetConstInLoop1.js]
+//==== let
+var _loop_1 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+};
+for (var x in {}) {
+    _loop_1(x);
+}
+var _loop_2 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+};
+for (var _i = 0, _a = []; _i < _a.length; _i++) {
+    var x = _a[_i];
+    _loop_2(x);
+}
+var _loop_3 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+};
+for (var x = 0; x < 1; ++x) {
+    _loop_3(x);
+}
+var _loop_4 = function() {
+    var x = void 0;
+    (function () { return x; });
+    (function () { return x; });
+};
+while (1 === 1) {
+    _loop_4();
+}
+var _loop_5 = function() {
+    var x = void 0;
+    (function () { return x; });
+    (function () { return x; });
+};
+do {
+    _loop_5();
+} while (1 === 1);
+var _loop_6 = function(y) {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+};
+for (var y = 0; y < 1; ++y) {
+    _loop_6(y);
+}
+var _loop_7 = function(x, y) {
+    (function () { return x + y; });
+    (function () { return x + y; });
+};
+for (var x = 0, y = 1; x < 1; ++x) {
+    _loop_7(x, y);
+}
+var _loop_8 = function() {
+    var x = void 0, y = void 0;
+    (function () { return x + y; });
+    (function () { return x + y; });
+};
+while (1 === 1) {
+    _loop_8();
+}
+var _loop_9 = function() {
+    var x = void 0, y = void 0;
+    (function () { return x + y; });
+    (function () { return x + y; });
+};
+do {
+    _loop_9();
+} while (1 === 1);
+var _loop_10 = function(y) {
+    var x = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+};
+for (var y = 0; y < 1; ++y) {
+    _loop_10(y);
+}
+//=========const
+var _loop_11 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+};
+for (var x in {}) {
+    _loop_11(x);
+}
+var _loop_12 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+};
+for (var _b = 0, _c = []; _b < _c.length; _b++) {
+    var x = _c[_b];
+    _loop_12(x);
+}
+var _loop_13 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+};
+for (var x = 0; x < 1;) {
+    _loop_13(x);
+}
+var _loop_14 = function() {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+};
+while (1 === 1) {
+    _loop_14();
+}
+var _loop_15 = function() {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+};
+do {
+    _loop_15();
+} while (1 === 1);
+var _loop_16 = function(y) {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+};
+for (var y = 0; y < 1;) {
+    _loop_16(y);
+}
+var _loop_17 = function(x, y) {
+    (function () { return x + y; });
+    (function () { return x + y; });
+};
+for (var x = 0, y = 1; x < 1;) {
+    _loop_17(x, y);
+}
+var _loop_18 = function() {
+    var x = 1, y = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+};
+while (1 === 1) {
+    _loop_18();
+}
+var _loop_19 = function() {
+    var x = 1, y = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+};
+do {
+    _loop_19();
+} while (1 === 1);
+var _loop_20 = function(y) {
+    var x = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+};
+for (var y = 0; y < 1;) {
+    _loop_20(y);
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop1.symbols b/tests/baselines/reference/capturedLetConstInLoop1.symbols
new file mode 100644
index 00000000000..51e2d4c4112
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop1.symbols
@@ -0,0 +1,260 @@
+=== tests/cases/compiler/capturedLetConstInLoop1.ts ===
+//==== let
+for (let x in {}) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 1, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 1, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 1, 8))
+}
+
+for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 6, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 6, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 6, 8))
+}
+
+for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 11, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 11, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 11, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 11, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 11, 8))
+}
+
+while (1 === 1) {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 17, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 17, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 17, 7))
+}
+
+do {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 23, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 23, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 23, 7))
+
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 28, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 28, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 28, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 29, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 29, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 29, 7))
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 34, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 34, 15))
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 34, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 34, 8))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 34, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 34, 15))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 34, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 34, 15))
+}
+
+while (1 === 1) {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 40, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 40, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 40, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 40, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 40, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 40, 10))
+}
+
+do {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 46, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 46, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 46, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 46, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 46, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 46, 10))
+
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 51, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 51, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 51, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 52, 7))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 52, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 51, 8))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 52, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 51, 8))
+}
+
+//=========const
+for (const x in {}) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 58, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 58, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 58, 10))
+}
+
+for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 63, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 63, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 63, 10))
+}
+
+for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 68, 10))
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 68, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 68, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 68, 10))
+}
+
+while (1 === 1) {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 74, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 74, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 74, 9))
+}
+
+do {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 80, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 80, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 80, 9))
+
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 85, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 85, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 86, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 86, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 86, 9))
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 91, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 91, 17))
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 91, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 91, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 91, 17))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 91, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 91, 17))
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 97, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 97, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 97, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 97, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 97, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 97, 16))
+}
+
+do {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 103, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 103, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 103, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 103, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 103, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 103, 16))
+
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 108, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 108, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 109, 9))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 109, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 108, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1.ts, 109, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1.ts, 108, 10))
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop1.types b/tests/baselines/reference/capturedLetConstInLoop1.types
new file mode 100644
index 00000000000..c68f2422f43
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop1.types
@@ -0,0 +1,428 @@
+=== tests/cases/compiler/capturedLetConstInLoop1.ts ===
+//==== let
+for (let x in {}) {
+>x : any
+>{} : {}
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (let x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+do {
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+}
+
+do {
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+//=========const
+for (const x in {}) {
+>x : any
+>{} : {}
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (const x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+do {
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+do {
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop1_ES6.js b/tests/baselines/reference/capturedLetConstInLoop1_ES6.js
new file mode 100644
index 00000000000..0a68f8e1cf6
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop1_ES6.js
@@ -0,0 +1,210 @@
+//// [capturedLetConstInLoop1_ES6.ts]
+//==== let
+for (let x in {}) {
+    (function() { return x});
+    (() => x);
+}
+
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+}
+
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+}
+
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+}
+
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+//=========const
+for (const x in {}) {
+    (function() { return x});
+    (() => x);
+}
+
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+}
+
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+}
+
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+//// [capturedLetConstInLoop1_ES6.js]
+//==== let
+for (let x in {}) {
+    (function () { return x; });
+    (() => x);
+}
+for (let x of []) {
+    (function () { return x; });
+    (() => x);
+}
+for (let x = 0; x < 1; ++x) {
+    (function () { return x; });
+    (() => x);
+}
+while (1 === 1) {
+    let x;
+    (function () { return x; });
+    (() => x);
+}
+do {
+    let x;
+    (function () { return x; });
+    (() => x);
+} while (1 === 1);
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function () { return x; });
+    (() => x);
+}
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function () { return x + y; });
+    (() => x + y);
+}
+while (1 === 1) {
+    let x, y;
+    (function () { return x + y; });
+    (() => x + y);
+}
+do {
+    let x, y;
+    (function () { return x + y; });
+    (() => x + y);
+} while (1 === 1);
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function () { return x + y; });
+    (() => x + y);
+}
+//=========const
+for (const x in {}) {
+    (function () { return x; });
+    (() => x);
+}
+for (const x of []) {
+    (function () { return x; });
+    (() => x);
+}
+for (const x = 0; x < 1;) {
+    (function () { return x; });
+    (() => x);
+}
+while (1 === 1) {
+    const x = 1;
+    (function () { return x; });
+    (() => x);
+}
+do {
+    const x = 1;
+    (function () { return x; });
+    (() => x);
+} while (1 === 1);
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function () { return x; });
+    (() => x);
+}
+for (const x = 0, y = 1; x < 1;) {
+    (function () { return x + y; });
+    (() => x + y);
+}
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function () { return x + y; });
+    (() => x + y);
+}
+do {
+    const x = 1, y = 1;
+    (function () { return x + y; });
+    (() => x + y);
+} while (1 === 1);
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function () { return x + y; });
+    (() => x + y);
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop1_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop1_ES6.symbols
new file mode 100644
index 00000000000..f275ad26db2
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop1_ES6.symbols
@@ -0,0 +1,260 @@
+=== tests/cases/compiler/capturedLetConstInLoop1_ES6.ts ===
+//==== let
+for (let x in {}) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 1, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 1, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 1, 8))
+}
+
+for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 6, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 6, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 6, 8))
+}
+
+for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 11, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 11, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 11, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 11, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 11, 8))
+}
+
+while (1 === 1) {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 17, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 17, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 17, 7))
+}
+
+do {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 23, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 23, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 23, 7))
+
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 28, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 28, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 28, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 29, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 29, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 29, 7))
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 34, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 34, 15))
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 34, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 34, 8))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 34, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 34, 15))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 34, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 34, 15))
+}
+
+while (1 === 1) {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 40, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 40, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 40, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 40, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 40, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 40, 10))
+}
+
+do {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 46, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 46, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 46, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 46, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 46, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 46, 10))
+
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 51, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 51, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 51, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 52, 7))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 52, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 51, 8))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 52, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 51, 8))
+}
+
+//=========const
+for (const x in {}) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 58, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 58, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 58, 10))
+}
+
+for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 63, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 63, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 63, 10))
+}
+
+for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 68, 10))
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 68, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 68, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 68, 10))
+}
+
+while (1 === 1) {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 74, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 74, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 74, 9))
+}
+
+do {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 80, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 80, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 80, 9))
+
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 85, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 85, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 86, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 86, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 86, 9))
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 91, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 91, 17))
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 91, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 91, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 91, 17))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 91, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 91, 17))
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 97, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 97, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 97, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 97, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 97, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 97, 16))
+}
+
+do {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 103, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 103, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 103, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 103, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 103, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 103, 16))
+
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 108, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 108, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 109, 9))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 109, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 108, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop1_ES6.ts, 109, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop1_ES6.ts, 108, 10))
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop1_ES6.types b/tests/baselines/reference/capturedLetConstInLoop1_ES6.types
new file mode 100644
index 00000000000..5e25e1f930d
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop1_ES6.types
@@ -0,0 +1,428 @@
+=== tests/cases/compiler/capturedLetConstInLoop1_ES6.ts ===
+//==== let
+for (let x in {}) {
+>x : any
+>{} : {}
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (let x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+do {
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+}
+
+do {
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+//=========const
+for (const x in {}) {
+>x : any
+>{} : {}
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (const x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+do {
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+do {
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop2.js b/tests/baselines/reference/capturedLetConstInLoop2.js
new file mode 100644
index 00000000000..b9fbcf46f57
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop2.js
@@ -0,0 +1,413 @@
+//// [capturedLetConstInLoop2.ts]
+
+
+// ========let
+function foo0(x) {
+    for (let x of []) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo0_1(x) {
+    for (let x in []) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo3(x) {
+    do {
+        let x;
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    } while (1 === 1)
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        let a = arguments.length;
+        let x = 1;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    } while (1 === 1)
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+///=======const
+function foo0_c(x) {
+    for (const x of []) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo0_1_c(x) {
+    for (const x in []) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    } while (1 === 1)
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        const a = arguments.length;
+        const x = 1;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y =1 ;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    } while (1 === 1)
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+//// [capturedLetConstInLoop2.js]
+// ========let
+function foo0(x) {
+    var _loop_1 = function(x_1) {
+        var a = arguments_1.length;
+        (function () { return x_1 + a; });
+        (function () { return x_1 + a; });
+    };
+    var arguments_1 = arguments;
+    for (var _i = 0, _a = []; _i < _a.length; _i++) {
+        var x_1 = _a[_i];
+        _loop_1(x_1);
+    }
+}
+function foo0_1(x) {
+    var _loop_2 = function(x_2) {
+        var a = arguments_2.length;
+        (function () { return x_2 + a; });
+        (function () { return x_2 + a; });
+    };
+    var arguments_2 = arguments;
+    for (var x_2 in []) {
+        _loop_2(x_2);
+    }
+}
+function foo1(x) {
+    var _loop_3 = function(x_3) {
+        var a = arguments_3.length;
+        (function () { return x_3 + a; });
+        (function () { return x_3 + a; });
+    };
+    var arguments_3 = arguments;
+    for (var x_3 = 0; x_3 < 1; ++x_3) {
+        _loop_3(x_3);
+    }
+}
+function foo2(x) {
+    var _loop_4 = function() {
+        var a = arguments_4.length;
+        (function () { return x + a; });
+        (function () { return x + a; });
+    };
+    var arguments_4 = arguments;
+    while (1 === 1) {
+        _loop_4();
+    }
+}
+function foo3(x) {
+    var _loop_5 = function() {
+        var x_4 = void 0;
+        var a = arguments_5.length;
+        (function () { return x_4 + a; });
+        (function () { return x_4 + a; });
+    };
+    var arguments_5 = arguments;
+    do {
+        _loop_5();
+    } while (1 === 1);
+}
+function foo4(x) {
+    var _loop_6 = function(y) {
+        var a = arguments_6.length;
+        var x_5 = 1;
+        (function () { return x_5 + a; });
+        (function () { return x_5 + a; });
+    };
+    var arguments_6 = arguments;
+    for (var y = 0; y < 1; ++y) {
+        _loop_6(y);
+    }
+}
+function foo5(x) {
+    var _loop_7 = function(x_6, y) {
+        var a = arguments_7.length;
+        (function () { return x_6 + y + a; });
+        (function () { return x_6 + y + a; });
+    };
+    var arguments_7 = arguments;
+    for (var x_6 = 0, y = 1; x_6 < 1; ++x_6) {
+        _loop_7(x_6, y);
+    }
+}
+function foo6(x) {
+    var _loop_8 = function() {
+        var x_7 = void 0, y = void 0;
+        var a = arguments_8.length;
+        (function () { return x_7 + y + a; });
+        (function () { return x_7 + y + a; });
+    };
+    var arguments_8 = arguments;
+    while (1 === 1) {
+        _loop_8();
+    }
+}
+function foo7(x) {
+    var _loop_9 = function() {
+        var x_8 = void 0, y = void 0;
+        var a = arguments_9.length;
+        (function () { return x_8 + y + a; });
+        (function () { return x_8 + y + a; });
+    };
+    var arguments_9 = arguments;
+    do {
+        _loop_9();
+    } while (1 === 1);
+}
+function foo8(x) {
+    var _loop_10 = function(y) {
+        var x_9 = 1;
+        var a = arguments_10.length;
+        (function () { return x_9 + y + a; });
+        (function () { return x_9 + y + a; });
+    };
+    var arguments_10 = arguments;
+    for (var y = 0; y < 1; ++y) {
+        _loop_10(y);
+    }
+}
+///=======const
+function foo0_c(x) {
+    var _loop_11 = function(x_10) {
+        var a = arguments_11.length;
+        (function () { return x_10 + a; });
+        (function () { return x_10 + a; });
+    };
+    var arguments_11 = arguments;
+    for (var _i = 0, _a = []; _i < _a.length; _i++) {
+        var x_10 = _a[_i];
+        _loop_11(x_10);
+    }
+}
+function foo0_1_c(x) {
+    var _loop_12 = function(x_11) {
+        var a = arguments_12.length;
+        (function () { return x_11 + a; });
+        (function () { return x_11 + a; });
+    };
+    var arguments_12 = arguments;
+    for (var x_11 in []) {
+        _loop_12(x_11);
+    }
+}
+function foo1_c(x) {
+    var _loop_13 = function(x_12) {
+        var a = arguments_13.length;
+        (function () { return x_12 + a; });
+        (function () { return x_12 + a; });
+    };
+    var arguments_13 = arguments;
+    for (var x_12 = 0; x_12 < 1;) {
+        _loop_13(x_12);
+    }
+}
+function foo2_c(x) {
+    var _loop_14 = function() {
+        var a = arguments_14.length;
+        (function () { return x + a; });
+        (function () { return x + a; });
+    };
+    var arguments_14 = arguments;
+    while (1 === 1) {
+        _loop_14();
+    }
+}
+function foo3_c(x) {
+    var _loop_15 = function() {
+        var x_13 = 1;
+        var a = arguments_15.length;
+        (function () { return x_13 + a; });
+        (function () { return x_13 + a; });
+    };
+    var arguments_15 = arguments;
+    do {
+        _loop_15();
+    } while (1 === 1);
+}
+function foo4_c(x) {
+    var _loop_16 = function(y) {
+        var a = arguments_16.length;
+        var x_14 = 1;
+        (function () { return x_14 + a; });
+        (function () { return x_14 + a; });
+    };
+    var arguments_16 = arguments;
+    for (var y = 0; y < 1;) {
+        _loop_16(y);
+    }
+}
+function foo5_c(x) {
+    var _loop_17 = function(x_15, y) {
+        var a = arguments_17.length;
+        (function () { return x_15 + y + a; });
+        (function () { return x_15 + y + a; });
+    };
+    var arguments_17 = arguments;
+    for (var x_15 = 0, y = 1; x_15 < 1;) {
+        _loop_17(x_15, y);
+    }
+}
+function foo6_c(x) {
+    var _loop_18 = function() {
+        var x_16 = 1, y = 1;
+        var a = arguments_18.length;
+        (function () { return x_16 + y + a; });
+        (function () { return x_16 + y + a; });
+    };
+    var arguments_18 = arguments;
+    while (1 === 1) {
+        _loop_18();
+    }
+}
+function foo7_c(x) {
+    var _loop_19 = function() {
+        var x_17 = 1, y = 1;
+        var a = arguments_19.length;
+        (function () { return x_17 + y + a; });
+        (function () { return x_17 + y + a; });
+    };
+    var arguments_19 = arguments;
+    do {
+        _loop_19();
+    } while (1 === 1);
+}
+function foo8_c(x) {
+    var _loop_20 = function(y) {
+        var x_18 = 1;
+        var a = arguments_20.length;
+        (function () { return x_18 + y + a; });
+        (function () { return x_18 + y + a; });
+    };
+    var arguments_20 = arguments;
+    for (var y = 0; y < 1;) {
+        _loop_20(y);
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop2.symbols b/tests/baselines/reference/capturedLetConstInLoop2.symbols
new file mode 100644
index 00000000000..8fb2de72999
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop2.symbols
@@ -0,0 +1,519 @@
+=== tests/cases/compiler/capturedLetConstInLoop2.ts ===
+
+
+// ========let
+function foo0(x) {
+>foo0 : Symbol(foo0, Decl(capturedLetConstInLoop2.ts, 0, 0))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 3, 14))
+
+    for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 4, 12))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 5, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 4, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 5, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 4, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 5, 11))
+    }
+}
+
+function foo0_1(x) {
+>foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop2.ts, 9, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 11, 16))
+
+    for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 12, 12))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 13, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 12, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 13, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 12, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 13, 11))
+    }
+}
+
+function foo1(x) {
+>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop2.ts, 17, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 19, 14))
+
+    for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 21, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 21, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 20, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 21, 11))
+    }
+}
+
+function foo2(x) {
+>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop2.ts, 25, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 27, 14))
+
+    while (1 === 1) {
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 29, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 27, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 29, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 27, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 29, 11))
+    }
+}
+
+function foo3(x) {
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop2.ts, 33, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 35, 14))
+
+    do {
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 37, 11))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 38, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 37, 11))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 38, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 37, 11))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 38, 11))
+
+    } while (1 === 1)
+}
+
+function foo4(x) {
+>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop2.ts, 42, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 44, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 45, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 45, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 45, 12))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 46, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 47, 11))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 47, 11))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 46, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 47, 11))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 46, 11))
+    }
+}
+
+function foo5(x) {
+>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop2.ts, 51, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 53, 14))
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 54, 19))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 55, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 54, 19))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 55, 11))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 54, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 54, 19))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 55, 11))
+    }
+}
+
+
+function foo6(x) {
+>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop2.ts, 59, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 62, 14))
+
+    while (1 === 1) {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 64, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 64, 14))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 65, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 64, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 64, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 65, 11))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 64, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 64, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 65, 11))
+    }
+}
+
+function foo7(x) {
+>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop2.ts, 69, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 71, 14))
+
+    do {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 73, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 73, 14))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 74, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 73, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 73, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 74, 11))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 73, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 73, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 74, 11))
+
+    } while (1 === 1)
+}
+
+
+function foo8(x) {
+>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop2.ts, 78, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 81, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 83, 11))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 84, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 83, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 84, 11))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 83, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 82, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 84, 11))
+    }
+}
+///=======const
+function foo0_c(x) {
+>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop2.ts, 88, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 90, 16))
+
+    for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 91, 14))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 92, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 91, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 92, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 91, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 92, 13))
+    }
+}
+
+function foo0_1_c(x) {
+>foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop2.ts, 96, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 98, 18))
+
+    for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 99, 14))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 100, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 99, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 100, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 99, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 100, 13))
+    }
+}
+
+function foo1_c(x) {
+>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop2.ts, 104, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 106, 16))
+
+    for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 108, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 108, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 107, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 108, 13))
+    }
+}
+
+function foo2_c(x) {
+>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop2.ts, 112, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 114, 16))
+
+    while (1 === 1) {
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 116, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 114, 16))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 116, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 114, 16))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 116, 13))
+    }
+}
+
+function foo3_c(x) {
+>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop2.ts, 120, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 122, 16))
+
+    do {
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 124, 13))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 125, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 124, 13))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 125, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 124, 13))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 125, 13))
+
+    } while (1 === 1)
+}
+
+function foo4_c(x) {
+>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop2.ts, 129, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 131, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 132, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 132, 14))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 133, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 134, 13))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 134, 13))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 133, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 134, 13))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 133, 13))
+    }
+}
+
+function foo5_c(x) {
+>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop2.ts, 138, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 140, 16))
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 141, 21))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 142, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 141, 21))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 142, 13))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 141, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 141, 21))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 142, 13))
+    }
+}
+
+
+function foo6_c(x) {
+>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop2.ts, 146, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 149, 16))
+
+    while (1 === 1) {
+        const x = 1, y =1 ;
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 151, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 151, 20))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 152, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 151, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 151, 20))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 152, 13))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 151, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 151, 20))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 152, 13))
+    }
+}
+
+function foo7_c(x) {
+>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop2.ts, 156, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 158, 16))
+
+    do {
+        const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 160, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 160, 20))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 161, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 160, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 160, 20))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 161, 13))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 160, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 160, 20))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 161, 13))
+
+    } while (1 === 1)
+}
+
+
+function foo8_c(x) {
+>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop2.ts, 165, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 168, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14))
+
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 170, 13))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 171, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 170, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 171, 13))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2.ts, 170, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2.ts, 169, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2.ts, 171, 13))
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop2.types b/tests/baselines/reference/capturedLetConstInLoop2.types
new file mode 100644
index 00000000000..5108fc399ee
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop2.types
@@ -0,0 +1,726 @@
+=== tests/cases/compiler/capturedLetConstInLoop2.ts ===
+
+
+// ========let
+function foo0(x) {
+>foo0 : (x: any) => void
+>x : any
+
+    for (let x of []) {
+>x : any
+>[] : undefined[]
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo0_1(x) {
+>foo0_1 : (x: any) => void
+>x : any
+
+    for (let x in []) {
+>x : any
+>[] : undefined[]
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo1(x) {
+>foo1 : (x: any) => void
+>x : any
+
+    for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => number
+>function() { return x + a } : () => number
+>x + a : number
+>x : number
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => number
+>() => x + a : () => number
+>x + a : number
+>x : number
+>a : number
+    }
+}
+
+function foo2(x) {
+>foo2 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo3(x) {
+>foo3 : (x: any) => void
+>x : any
+
+    do {
+        let x;
+>x : any
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+}
+
+function foo4(x) {
+>foo4 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => number
+>function() { return x + a } : () => number
+>x + a : number
+>x : number
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => number
+>() => x + a : () => number
+>x + a : number
+>x : number
+>a : number
+    }
+}
+
+function foo5(x) {
+>foo5 : (x: any) => void
+>x : any
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+    }
+}
+
+
+function foo6(x) {
+>foo6 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let x, y;
+>x : any
+>y : any
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => any
+>function() { return x + y + a } : () => any
+>x + y + a : any
+>x + y : any
+>x : any
+>y : any
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => any
+>() => x + y + a : () => any
+>x + y + a : any
+>x + y : any
+>x : any
+>y : any
+>a : number
+    }
+}
+
+function foo7(x) {
+>foo7 : (x: any) => void
+>x : any
+
+    do {
+        let x, y;
+>x : any
+>y : any
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => any
+>function() { return x + y + a } : () => any
+>x + y + a : any
+>x + y : any
+>x : any
+>y : any
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => any
+>() => x + y + a : () => any
+>x + y + a : any
+>x + y : any
+>x : any
+>y : any
+>a : number
+
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+}
+
+
+function foo8(x) {
+>foo8 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+    }
+}
+///=======const
+function foo0_c(x) {
+>foo0_c : (x: any) => void
+>x : any
+
+    for (const x of []) {
+>x : any
+>[] : undefined[]
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo0_1_c(x) {
+>foo0_1_c : (x: any) => void
+>x : any
+
+    for (const x in []) {
+>x : any
+>[] : undefined[]
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo1_c(x) {
+>foo1_c : (x: any) => void
+>x : any
+
+    for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => number
+>function() { return x + a } : () => number
+>x + a : number
+>x : number
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => number
+>() => x + a : () => number
+>x + a : number
+>x : number
+>a : number
+    }
+}
+
+function foo2_c(x) {
+>foo2_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo3_c(x) {
+>foo3_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1;
+>x : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => number
+>function() { return x + a } : () => number
+>x + a : number
+>x : number
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => number
+>() => x + a : () => number
+>x + a : number
+>x : number
+>a : number
+
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+}
+
+function foo4_c(x) {
+>foo4_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => number
+>function() { return x + a } : () => number
+>x + a : number
+>x : number
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => number
+>() => x + a : () => number
+>x + a : number
+>x : number
+>a : number
+    }
+}
+
+function foo5_c(x) {
+>foo5_c : (x: any) => void
+>x : any
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+    }
+}
+
+
+function foo6_c(x) {
+>foo6_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const x = 1, y =1 ;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+    }
+}
+
+function foo7_c(x) {
+>foo7_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+}
+
+
+function foo8_c(x) {
+>foo8_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop2_ES6.js b/tests/baselines/reference/capturedLetConstInLoop2_ES6.js
new file mode 100644
index 00000000000..aac040d4d29
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop2_ES6.js
@@ -0,0 +1,330 @@
+//// [capturedLetConstInLoop2_ES6.ts]
+
+// ========let
+function foo0(x) {
+    for (let x of []) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo0_1(x) {
+    for (let x in []) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo3(x) {
+    do {
+        let x;
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    } while (1 === 1)
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        let a = arguments.length;
+        let x = 1;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    } while (1 === 1)
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+///=======const
+function foo0_c(x) {
+    for (const x of []) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo0_1_c(x) {
+    for (const x in []) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    } while (1 === 1)
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        const a = arguments.length;
+        const x = 1;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y =1 ;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    } while (1 === 1)
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+//// [capturedLetConstInLoop2_ES6.js]
+// ========let
+function foo0(x) {
+    for (let x of []) {
+        let a = arguments.length;
+        (function () { return x + a; });
+        (() => x + a);
+    }
+}
+function foo0_1(x) {
+    for (let x in []) {
+        let a = arguments.length;
+        (function () { return x + a; });
+        (() => x + a);
+    }
+}
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        let a = arguments.length;
+        (function () { return x + a; });
+        (() => x + a);
+    }
+}
+function foo2(x) {
+    while (1 === 1) {
+        let a = arguments.length;
+        (function () { return x + a; });
+        (() => x + a);
+    }
+}
+function foo3(x) {
+    do {
+        let x;
+        let a = arguments.length;
+        (function () { return x + a; });
+        (() => x + a);
+    } while (1 === 1);
+}
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        let a = arguments.length;
+        let x = 1;
+        (function () { return x + a; });
+        (() => x + a);
+    }
+}
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        let a = arguments.length;
+        (function () { return x + y + a; });
+        (() => x + y + a);
+    }
+}
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        let a = arguments.length;
+        (function () { return x + y + a; });
+        (() => x + y + a);
+    }
+}
+function foo7(x) {
+    do {
+        let x, y;
+        let a = arguments.length;
+        (function () { return x + y + a; });
+        (() => x + y + a);
+    } while (1 === 1);
+}
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        let a = arguments.length;
+        (function () { return x + y + a; });
+        (() => x + y + a);
+    }
+}
+///=======const
+function foo0_c(x) {
+    for (const x of []) {
+        const a = arguments.length;
+        (function () { return x + a; });
+        (() => x + a);
+    }
+}
+function foo0_1_c(x) {
+    for (const x in []) {
+        const a = arguments.length;
+        (function () { return x + a; });
+        (() => x + a);
+    }
+}
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        const a = arguments.length;
+        (function () { return x + a; });
+        (() => x + a);
+    }
+}
+function foo2_c(x) {
+    while (1 === 1) {
+        const a = arguments.length;
+        (function () { return x + a; });
+        (() => x + a);
+    }
+}
+function foo3_c(x) {
+    do {
+        const x = 1;
+        const a = arguments.length;
+        (function () { return x + a; });
+        (() => x + a);
+    } while (1 === 1);
+}
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        const a = arguments.length;
+        const x = 1;
+        (function () { return x + a; });
+        (() => x + a);
+    }
+}
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        const a = arguments.length;
+        (function () { return x + y + a; });
+        (() => x + y + a);
+    }
+}
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        const a = arguments.length;
+        (function () { return x + y + a; });
+        (() => x + y + a);
+    }
+}
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        const a = arguments.length;
+        (function () { return x + y + a; });
+        (() => x + y + a);
+    } while (1 === 1);
+}
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        const a = arguments.length;
+        (function () { return x + y + a; });
+        (() => x + y + a);
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols
new file mode 100644
index 00000000000..32812c89370
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop2_ES6.symbols
@@ -0,0 +1,518 @@
+=== tests/cases/compiler/capturedLetConstInLoop2_ES6.ts ===
+
+// ========let
+function foo0(x) {
+>foo0 : Symbol(foo0, Decl(capturedLetConstInLoop2_ES6.ts, 0, 0))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 2, 14))
+
+    for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 3, 12))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 4, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 3, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 4, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 3, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 4, 11))
+    }
+}
+
+function foo0_1(x) {
+>foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop2_ES6.ts, 8, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 10, 16))
+
+    for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 11, 12))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 12, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 11, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 12, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 11, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 12, 11))
+    }
+}
+
+function foo1(x) {
+>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop2_ES6.ts, 16, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 18, 14))
+
+    for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 20, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 20, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 19, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 20, 11))
+    }
+}
+
+function foo2(x) {
+>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop2_ES6.ts, 24, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 26, 14))
+
+    while (1 === 1) {
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 28, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 26, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 28, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 26, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 28, 11))
+    }
+}
+
+function foo3(x) {
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop2_ES6.ts, 32, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 34, 14))
+
+    do {
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 37, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 37, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 36, 11))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 37, 11))
+
+    } while (1 === 1)
+}
+
+function foo4(x) {
+>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop2_ES6.ts, 41, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 43, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 44, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 44, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 44, 12))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 46, 11))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 46, 11))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 46, 11))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 45, 11))
+    }
+}
+
+function foo5(x) {
+>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop2_ES6.ts, 50, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 52, 14))
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 53, 19))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 54, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 53, 19))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 54, 11))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 53, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 53, 19))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 54, 11))
+    }
+}
+
+
+function foo6(x) {
+>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop2_ES6.ts, 58, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 61, 14))
+
+    while (1 === 1) {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 63, 14))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 64, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 63, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 64, 11))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 63, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 63, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 64, 11))
+    }
+}
+
+function foo7(x) {
+>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop2_ES6.ts, 68, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 70, 14))
+
+    do {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 72, 14))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 73, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 72, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 73, 11))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 72, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 72, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 73, 11))
+
+    } while (1 === 1)
+}
+
+
+function foo8(x) {
+>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop2_ES6.ts, 77, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 80, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11))
+
+        let a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 83, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 83, 11))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 82, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 81, 12))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 83, 11))
+    }
+}
+///=======const
+function foo0_c(x) {
+>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop2_ES6.ts, 87, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 89, 16))
+
+    for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 90, 14))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 91, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 90, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 91, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 90, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 91, 13))
+    }
+}
+
+function foo0_1_c(x) {
+>foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop2_ES6.ts, 95, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 97, 18))
+
+    for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 98, 14))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 99, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 98, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 99, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 98, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 99, 13))
+    }
+}
+
+function foo1_c(x) {
+>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop2_ES6.ts, 103, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 105, 16))
+
+    for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 107, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 107, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 106, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 107, 13))
+    }
+}
+
+function foo2_c(x) {
+>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop2_ES6.ts, 111, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 113, 16))
+
+    while (1 === 1) {
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 115, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 113, 16))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 115, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 113, 16))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 115, 13))
+    }
+}
+
+function foo3_c(x) {
+>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop2_ES6.ts, 119, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 121, 16))
+
+    do {
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 124, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 124, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 123, 13))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 124, 13))
+
+    } while (1 === 1)
+}
+
+function foo4_c(x) {
+>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop2_ES6.ts, 128, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 130, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 131, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 131, 14))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 133, 13))
+
+        (function() { return x + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 133, 13))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13))
+
+        (() => x + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 133, 13))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 132, 13))
+    }
+}
+
+function foo5_c(x) {
+>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop2_ES6.ts, 137, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 139, 16))
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 140, 21))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 141, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 140, 21))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 141, 13))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 140, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 140, 21))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 141, 13))
+    }
+}
+
+
+function foo6_c(x) {
+>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop2_ES6.ts, 145, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 148, 16))
+
+    while (1 === 1) {
+        const x = 1, y =1 ;
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 150, 20))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 151, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 150, 20))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 151, 13))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 150, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 150, 20))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 151, 13))
+    }
+}
+
+function foo7_c(x) {
+>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop2_ES6.ts, 155, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 157, 16))
+
+    do {
+        const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 159, 20))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 160, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 159, 20))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 160, 13))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 159, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 159, 20))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 160, 13))
+
+    } while (1 === 1)
+}
+
+
+function foo8_c(x) {
+>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop2_ES6.ts, 164, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 167, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14))
+
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13))
+
+        const a = arguments.length;
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 170, 13))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return x + y + a });
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 170, 13))
+
+        (() => x + y + a);
+>x : Symbol(x, Decl(capturedLetConstInLoop2_ES6.ts, 169, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop2_ES6.ts, 168, 14))
+>a : Symbol(a, Decl(capturedLetConstInLoop2_ES6.ts, 170, 13))
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop2_ES6.types b/tests/baselines/reference/capturedLetConstInLoop2_ES6.types
new file mode 100644
index 00000000000..9fea265da44
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop2_ES6.types
@@ -0,0 +1,725 @@
+=== tests/cases/compiler/capturedLetConstInLoop2_ES6.ts ===
+
+// ========let
+function foo0(x) {
+>foo0 : (x: any) => void
+>x : any
+
+    for (let x of []) {
+>x : any
+>[] : undefined[]
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo0_1(x) {
+>foo0_1 : (x: any) => void
+>x : any
+
+    for (let x in []) {
+>x : any
+>[] : undefined[]
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo1(x) {
+>foo1 : (x: any) => void
+>x : any
+
+    for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => number
+>function() { return x + a } : () => number
+>x + a : number
+>x : number
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => number
+>() => x + a : () => number
+>x + a : number
+>x : number
+>a : number
+    }
+}
+
+function foo2(x) {
+>foo2 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo3(x) {
+>foo3 : (x: any) => void
+>x : any
+
+    do {
+        let x;
+>x : any
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+}
+
+function foo4(x) {
+>foo4 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => number
+>function() { return x + a } : () => number
+>x + a : number
+>x : number
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => number
+>() => x + a : () => number
+>x + a : number
+>x : number
+>a : number
+    }
+}
+
+function foo5(x) {
+>foo5 : (x: any) => void
+>x : any
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+    }
+}
+
+
+function foo6(x) {
+>foo6 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let x, y;
+>x : any
+>y : any
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => any
+>function() { return x + y + a } : () => any
+>x + y + a : any
+>x + y : any
+>x : any
+>y : any
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => any
+>() => x + y + a : () => any
+>x + y + a : any
+>x + y : any
+>x : any
+>y : any
+>a : number
+    }
+}
+
+function foo7(x) {
+>foo7 : (x: any) => void
+>x : any
+
+    do {
+        let x, y;
+>x : any
+>y : any
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => any
+>function() { return x + y + a } : () => any
+>x + y + a : any
+>x + y : any
+>x : any
+>y : any
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => any
+>() => x + y + a : () => any
+>x + y + a : any
+>x + y : any
+>x : any
+>y : any
+>a : number
+
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+}
+
+
+function foo8(x) {
+>foo8 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        let a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+    }
+}
+///=======const
+function foo0_c(x) {
+>foo0_c : (x: any) => void
+>x : any
+
+    for (const x of []) {
+>x : any
+>[] : undefined[]
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo0_1_c(x) {
+>foo0_1_c : (x: any) => void
+>x : any
+
+    for (const x in []) {
+>x : any
+>[] : undefined[]
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo1_c(x) {
+>foo1_c : (x: any) => void
+>x : any
+
+    for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => number
+>function() { return x + a } : () => number
+>x + a : number
+>x : number
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => number
+>() => x + a : () => number
+>x + a : number
+>x : number
+>a : number
+    }
+}
+
+function foo2_c(x) {
+>foo2_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => any
+>function() { return x + a } : () => any
+>x + a : any
+>x : any
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => any
+>() => x + a : () => any
+>x + a : any
+>x : any
+>a : number
+    }
+}
+
+function foo3_c(x) {
+>foo3_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1;
+>x : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => number
+>function() { return x + a } : () => number
+>x + a : number
+>x : number
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => number
+>() => x + a : () => number
+>x + a : number
+>x : number
+>a : number
+
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+}
+
+function foo4_c(x) {
+>foo4_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + a });
+>(function() { return x + a }) : () => number
+>function() { return x + a } : () => number
+>x + a : number
+>x : number
+>a : number
+
+        (() => x + a);
+>(() => x + a) : () => number
+>() => x + a : () => number
+>x + a : number
+>x : number
+>a : number
+    }
+}
+
+function foo5_c(x) {
+>foo5_c : (x: any) => void
+>x : any
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+    }
+}
+
+
+function foo6_c(x) {
+>foo6_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const x = 1, y =1 ;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+    }
+}
+
+function foo7_c(x) {
+>foo7_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+}
+
+
+function foo8_c(x) {
+>foo8_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        const a = arguments.length;
+>a : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return x + y + a });
+>(function() { return x + y + a }) : () => number
+>function() { return x + y + a } : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+
+        (() => x + y + a);
+>(() => x + y + a) : () => number
+>() => x + y + a : () => number
+>x + y + a : number
+>x + y : number
+>x : number
+>y : number
+>a : number
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop3.js b/tests/baselines/reference/capturedLetConstInLoop3.js
new file mode 100644
index 00000000000..b38c12967dd
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop3.js
@@ -0,0 +1,473 @@
+//// [capturedLetConstInLoop3.ts]
+///=========let
+declare function use(a: any);
+function foo0(x) {
+    for (let x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo0_1(x) {
+    for (let x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo3(x) {
+    do {
+        let x;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v)
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+//===const
+function foo0_c(x) {
+    for (const x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo0_1_c(x) {
+    for (const x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        var v = y;
+        const x = 1;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v)
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+
+//// [capturedLetConstInLoop3.js]
+function foo0(x) {
+    var _loop_1 = function(x_1) {
+        v = x_1;
+        (function () { return x_1 + v; });
+        (function () { return x_1 + v; });
+    };
+    var v;
+    for (var _i = 0, _a = []; _i < _a.length; _i++) {
+        var x_1 = _a[_i];
+        _loop_1(x_1);
+    }
+    use(v);
+}
+function foo0_1(x) {
+    var _loop_2 = function(x_2) {
+        v = x_2;
+        (function () { return x_2 + v; });
+        (function () { return x_2 + v; });
+    };
+    var v;
+    for (var x_2 in []) {
+        _loop_2(x_2);
+    }
+    use(v);
+}
+function foo1(x) {
+    var _loop_3 = function(x_3) {
+        v = x_3;
+        (function () { return x_3 + v; });
+        (function () { return x_3 + v; });
+    };
+    var v;
+    for (var x_3 = 0; x_3 < 1; ++x_3) {
+        _loop_3(x_3);
+    }
+    use(v);
+}
+function foo2(x) {
+    var _loop_4 = function() {
+        var x_4 = 1;
+        v = x_4;
+        (function () { return x_4 + v; });
+        (function () { return x_4 + v; });
+    };
+    var v;
+    while (1 === 1) {
+        _loop_4();
+    }
+    use(v);
+}
+function foo3(x) {
+    var _loop_5 = function() {
+        var x_5 = void 0;
+        (function () { return x_5 + v; });
+        (function () { return x_5 + v; });
+    };
+    var v;
+    do {
+        _loop_5();
+    } while (1 === 1);
+    use(v);
+}
+function foo4(x) {
+    var _loop_6 = function(y) {
+        v = y;
+        var x_6 = 1;
+        (function () { return x_6 + v; });
+        (function () { return x_6 + v; });
+    };
+    var v;
+    for (var y = 0; y < 1; ++y) {
+        _loop_6(y);
+    }
+    use(v);
+}
+function foo5(x) {
+    var _loop_7 = function(x_7, y) {
+        v = x_7;
+        (function () { return x_7 + y + v; });
+        (function () { return x_7 + y + v; });
+    };
+    var v;
+    for (var x_7 = 0, y = 1; x_7 < 1; ++x_7) {
+        _loop_7(x_7, y);
+    }
+    use(v);
+}
+function foo6(x) {
+    var _loop_8 = function() {
+        var x_8 = void 0, y = void 0;
+        v = x_8;
+        (function () { return x_8 + y + v; });
+        (function () { return x_8 + y + v; });
+    };
+    var v;
+    while (1 === 1) {
+        _loop_8();
+    }
+    use(v);
+}
+function foo7(x) {
+    var _loop_9 = function() {
+        var x_9 = void 0, y = void 0;
+        v = x_9;
+        (function () { return x_9 + y + v; });
+        (function () { return x_9 + y + v; });
+    };
+    var v;
+    do {
+        _loop_9();
+    } while (1 === 1);
+    use(v);
+}
+function foo8(x) {
+    var _loop_10 = function(y) {
+        var x_10 = 1;
+        v = x_10;
+        (function () { return x_10 + y + v; });
+        (function () { return x_10 + y + v; });
+    };
+    var v;
+    for (var y = 0; y < 1; ++y) {
+        _loop_10(y);
+    }
+    use(v);
+}
+//===const
+function foo0_c(x) {
+    var _loop_11 = function(x_11) {
+        v = x_11;
+        (function () { return x_11 + v; });
+        (function () { return x_11 + v; });
+    };
+    var v;
+    for (var _i = 0, _a = []; _i < _a.length; _i++) {
+        var x_11 = _a[_i];
+        _loop_11(x_11);
+    }
+    use(v);
+}
+function foo0_1_c(x) {
+    var _loop_12 = function(x_12) {
+        v = x_12;
+        (function () { return x_12 + v; });
+        (function () { return x_12 + v; });
+    };
+    var v;
+    for (var x_12 in []) {
+        _loop_12(x_12);
+    }
+    use(v);
+}
+function foo1_c(x) {
+    var _loop_13 = function(x_13) {
+        v = x_13;
+        (function () { return x_13 + v; });
+        (function () { return x_13 + v; });
+    };
+    var v;
+    for (var x_13 = 0; x_13 < 1;) {
+        _loop_13(x_13);
+    }
+    use(v);
+}
+function foo2_c(x) {
+    var _loop_14 = function() {
+        var x_14 = 1;
+        v = x_14;
+        (function () { return x_14 + v; });
+        (function () { return x_14 + v; });
+    };
+    var v;
+    while (1 === 1) {
+        _loop_14();
+    }
+    use(v);
+}
+function foo3_c(x) {
+    var _loop_15 = function() {
+        var x_15 = 1;
+        (function () { return x_15 + v; });
+        (function () { return x_15 + v; });
+    };
+    var v;
+    do {
+        _loop_15();
+    } while (1 === 1);
+    use(v);
+}
+function foo4_c(x) {
+    var _loop_16 = function(y) {
+        v = y;
+        var x_16 = 1;
+        (function () { return x_16 + v; });
+        (function () { return x_16 + v; });
+    };
+    var v;
+    for (var y = 0; y < 1;) {
+        _loop_16(y);
+    }
+    use(v);
+}
+function foo5_c(x) {
+    var _loop_17 = function(x_17, y) {
+        v = x_17;
+        (function () { return x_17 + y + v; });
+        (function () { return x_17 + y + v; });
+    };
+    var v;
+    for (var x_17 = 0, y = 1; x_17 < 1;) {
+        _loop_17(x_17, y);
+    }
+    use(v);
+}
+function foo6_c(x) {
+    var _loop_18 = function() {
+        var x_18 = 1, y = 1;
+        v = x_18;
+        (function () { return x_18 + y + v; });
+        (function () { return x_18 + y + v; });
+    };
+    var v;
+    while (1 === 1) {
+        _loop_18();
+    }
+    use(v);
+}
+function foo7_c(x) {
+    var _loop_19 = function() {
+        var x_19 = 1, y = 1;
+        v = x_19;
+        (function () { return x_19 + y + v; });
+        (function () { return x_19 + y + v; });
+    };
+    var v;
+    do {
+        _loop_19();
+    } while (1 === 1);
+    use(v);
+}
+function foo8_c(x) {
+    var _loop_20 = function(y) {
+        var x_20 = 1;
+        v = x_20;
+        (function () { return x_20 + y + v; });
+        (function () { return x_20 + y + v; });
+    };
+    var v;
+    for (var y = 0; y < 1;) {
+        _loop_20(y);
+    }
+    use(v);
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop3.symbols b/tests/baselines/reference/capturedLetConstInLoop3.symbols
new file mode 100644
index 00000000000..f80992139a1
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop3.symbols
@@ -0,0 +1,565 @@
+=== tests/cases/compiler/capturedLetConstInLoop3.ts ===
+///=========let
+declare function use(a: any);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>a : Symbol(a, Decl(capturedLetConstInLoop3.ts, 1, 21))
+
+function foo0(x) {
+>foo0 : Symbol(foo0, Decl(capturedLetConstInLoop3.ts, 1, 29))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 2, 14))
+
+    for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 3, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 4, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 3, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 3, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 4, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 3, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 4, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 4, 11))
+}
+
+function foo0_1(x) {
+>foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop3.ts, 10, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 12, 16))
+
+    for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 13, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 14, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 13, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 13, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 14, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 13, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 14, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 14, 11))
+}
+
+function foo1(x) {
+>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop3.ts, 20, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 22, 14))
+
+    for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 23, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 23, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 23, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 24, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 23, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 23, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 24, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 23, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 24, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 24, 11))
+}
+
+function foo2(x) {
+>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop3.ts, 30, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 32, 14))
+
+    while (1 === 1) {
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 34, 11))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 35, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 34, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 34, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 35, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 34, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 35, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 35, 11))
+}
+
+function foo3(x) {
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop3.ts, 41, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 43, 14))
+
+    do {
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 45, 11))
+
+        var v;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 46, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 45, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 46, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 45, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 46, 11))
+
+    } while (1 === 1);
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 46, 11))
+}
+
+function foo4(x) {
+>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop3.ts, 52, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 54, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 55, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 55, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 55, 12))
+
+        var v = y;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 56, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 55, 12))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 57, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 57, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 56, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 57, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 56, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 56, 11))
+}
+
+function foo5(x) {
+>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop3.ts, 63, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 65, 14))
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 66, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 66, 19))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 66, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 66, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 67, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 66, 12))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 66, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 66, 19))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 67, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 66, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 66, 19))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 67, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 67, 11))
+}
+
+
+function foo6(x) {
+>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop3.ts, 73, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 76, 14))
+
+    while (1 === 1) {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 78, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 78, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 79, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 78, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 78, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 78, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 79, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 78, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 78, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 79, 11))
+    }
+    
+    use(v)
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 79, 11))
+}
+
+function foo7(x) {
+>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop3.ts, 85, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 87, 14))
+
+    do {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 89, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 89, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 90, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 89, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 89, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 89, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 90, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 89, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 89, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 90, 11))
+
+    } while (1 === 1);
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 90, 11))
+}
+
+
+function foo8(x) {
+>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop3.ts, 96, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 99, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 100, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 100, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 100, 12))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 101, 11))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 102, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 101, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 101, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 100, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 102, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 101, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 100, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 102, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 102, 11))
+}
+//===const
+function foo0_c(x) {
+>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop3.ts, 108, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 110, 16))
+
+    for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 111, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 112, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 111, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 111, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 112, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 111, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 112, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 112, 11))
+}
+
+function foo0_1_c(x) {
+>foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop3.ts, 118, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 120, 18))
+
+    for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 121, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 122, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 121, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 121, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 122, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 121, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 122, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 122, 11))
+}
+
+function foo1_c(x) {
+>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop3.ts, 128, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 130, 16))
+
+    for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 131, 14))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 131, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 132, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 131, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 131, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 132, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 131, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 132, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 132, 11))
+}
+
+function foo2_c(x) {
+>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop3.ts, 138, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 140, 16))
+
+    while (1 === 1) {
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 142, 13))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 143, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 142, 13))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 142, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 143, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 142, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 143, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 143, 11))
+}
+
+function foo3_c(x) {
+>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop3.ts, 149, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 151, 16))
+
+    do {
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 153, 13))
+
+        var v;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 154, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 153, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 154, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 153, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 154, 11))
+
+    } while (1 === 1);
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 154, 11))
+}
+
+function foo4_c(x) {
+>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop3.ts, 160, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 162, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 163, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 163, 14))
+
+        var v = y;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 164, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 163, 14))
+
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 165, 13))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 165, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 164, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 165, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 164, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 164, 11))
+}
+
+function foo5_c(x) {
+>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop3.ts, 171, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 173, 16))
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 174, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 174, 21))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 174, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 175, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 174, 14))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 174, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 174, 21))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 175, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 174, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 174, 21))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 175, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 175, 11))
+}
+
+
+function foo6_c(x) {
+>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop3.ts, 181, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 184, 16))
+
+    while (1 === 1) {
+        const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 186, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 186, 20))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 187, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 186, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 186, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 186, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 187, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 186, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 186, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 187, 11))
+    }
+    
+    use(v)
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 187, 11))
+}
+
+function foo7_c(x) {
+>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop3.ts, 193, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 195, 16))
+
+    do {
+        const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 197, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 197, 20))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 198, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 197, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 197, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 197, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 198, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 197, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 197, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 198, 11))
+
+    } while (1 === 1);
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 198, 11))
+}
+
+
+function foo8_c(x) {
+>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop3.ts, 204, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 207, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 208, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 208, 14))
+
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 209, 13))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 210, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 209, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 209, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 208, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 210, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3.ts, 209, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3.ts, 208, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 210, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3.ts, 210, 11))
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop3.types b/tests/baselines/reference/capturedLetConstInLoop3.types
new file mode 100644
index 00000000000..51646f5a98b
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop3.types
@@ -0,0 +1,794 @@
+=== tests/cases/compiler/capturedLetConstInLoop3.ts ===
+///=========let
+declare function use(a: any);
+>use : (a: any) => any
+>a : any
+
+function foo0(x) {
+>foo0 : (x: any) => void
+>x : any
+
+    for (let x of []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo0_1(x) {
+>foo0_1 : (x: any) => void
+>x : any
+
+    for (let x in []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo1(x) {
+>foo1 : (x: any) => void
+>x : any
+
+    for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo2(x) {
+>foo2 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo3(x) {
+>foo3 : (x: any) => void
+>x : any
+
+    do {
+        let x;
+>x : any
+
+        var v;
+>v : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+    } while (1 === 1);
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo4(x) {
+>foo4 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        var v = y;
+>v : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo5(x) {
+>foo5 : (x: any) => void
+>x : any
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo6(x) {
+>foo6 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let x, y;
+>x : any
+>y : any
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => any
+>function() { return x + y + v } : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        (() => x + y + v);
+>(() => x + y + v) : () => any
+>() => x + y + v : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+    }
+    
+    use(v)
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo7(x) {
+>foo7 : (x: any) => void
+>x : any
+
+    do {
+        let x, y;
+>x : any
+>y : any
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => any
+>function() { return x + y + v } : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        (() => x + y + v);
+>(() => x + y + v) : () => any
+>() => x + y + v : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+    } while (1 === 1);
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+
+function foo8(x) {
+>foo8 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+//===const
+function foo0_c(x) {
+>foo0_c : (x: any) => void
+>x : any
+
+    for (const x of []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo0_1_c(x) {
+>foo0_1_c : (x: any) => void
+>x : any
+
+    for (const x in []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo1_c(x) {
+>foo1_c : (x: any) => void
+>x : any
+
+    for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo2_c(x) {
+>foo2_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo3_c(x) {
+>foo3_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1;
+>x : number
+>1 : number
+
+        var v;
+>v : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : number
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : number
+>v : any
+
+    } while (1 === 1);
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo4_c(x) {
+>foo4_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        var v = y;
+>v : number
+>y : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo5_c(x) {
+>foo5_c : (x: any) => void
+>x : any
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo6_c(x) {
+>foo6_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+    }
+    
+    use(v)
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo7_c(x) {
+>foo7_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+    } while (1 === 1);
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo8_c(x) {
+>foo8_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop3_ES6.js b/tests/baselines/reference/capturedLetConstInLoop3_ES6.js
new file mode 100644
index 00000000000..f27713a52a8
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop3_ES6.js
@@ -0,0 +1,394 @@
+//// [capturedLetConstInLoop3_ES6.ts]
+
+///=========let
+declare function use(a: any);
+function foo0(x) {
+    for (let x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo0_1(x) {
+    for (let x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo3(x) {
+    do {
+        let x;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v)
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+//===const
+function foo0_c(x) {
+    for (const x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo0_1_c(x) {
+    for (const x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        var v = y;
+        const x = 1;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v)
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+
+//// [capturedLetConstInLoop3_ES6.js]
+function foo0(x) {
+    for (let x of []) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+    }
+    use(v);
+}
+function foo0_1(x) {
+    for (let x in []) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+    }
+    use(v);
+}
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+    }
+    use(v);
+}
+function foo2(x) {
+    while (1 === 1) {
+        let x = 1;
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+    }
+    use(v);
+}
+function foo3(x) {
+    do {
+        let x;
+        var v;
+        (function () { return x + v; });
+        (() => x + v);
+    } while (1 === 1);
+    use(v);
+}
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        var v = y;
+        let x = 1;
+        (function () { return x + v; });
+        (() => x + v);
+    }
+    use(v);
+}
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+    }
+    use(v);
+}
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+    }
+    use(v);
+}
+function foo7(x) {
+    do {
+        let x, y;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+    } while (1 === 1);
+    use(v);
+}
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+    }
+    use(v);
+}
+//===const
+function foo0_c(x) {
+    for (const x of []) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+    }
+    use(v);
+}
+function foo0_1_c(x) {
+    for (const x in []) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+    }
+    use(v);
+}
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+    }
+    use(v);
+}
+function foo2_c(x) {
+    while (1 === 1) {
+        const x = 1;
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+    }
+    use(v);
+}
+function foo3_c(x) {
+    do {
+        const x = 1;
+        var v;
+        (function () { return x + v; });
+        (() => x + v);
+    } while (1 === 1);
+    use(v);
+}
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        var v = y;
+        const x = 1;
+        (function () { return x + v; });
+        (() => x + v);
+    }
+    use(v);
+}
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+    }
+    use(v);
+}
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+    }
+    use(v);
+}
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+    } while (1 === 1);
+    use(v);
+}
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+    }
+    use(v);
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols
new file mode 100644
index 00000000000..b07a724cbbe
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop3_ES6.symbols
@@ -0,0 +1,566 @@
+=== tests/cases/compiler/capturedLetConstInLoop3_ES6.ts ===
+
+///=========let
+declare function use(a: any);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>a : Symbol(a, Decl(capturedLetConstInLoop3_ES6.ts, 2, 21))
+
+function foo0(x) {
+>foo0 : Symbol(foo0, Decl(capturedLetConstInLoop3_ES6.ts, 2, 29))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 3, 14))
+
+    for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 4, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 5, 11))
+}
+
+function foo0_1(x) {
+>foo0_1 : Symbol(foo0_1, Decl(capturedLetConstInLoop3_ES6.ts, 11, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 13, 16))
+
+    for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 14, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 15, 11))
+}
+
+function foo1(x) {
+>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop3_ES6.ts, 21, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 23, 14))
+
+    for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 24, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 25, 11))
+}
+
+function foo2(x) {
+>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop3_ES6.ts, 31, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 33, 14))
+
+    while (1 === 1) {
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 35, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 36, 11))
+}
+
+function foo3(x) {
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop3_ES6.ts, 42, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 44, 14))
+
+    do {
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11))
+
+        var v;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 46, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11))
+
+    } while (1 === 1);
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 47, 11))
+}
+
+function foo4(x) {
+>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop3_ES6.ts, 53, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 55, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12))
+
+        var v = y;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 56, 12))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 58, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 58, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 58, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 57, 11))
+}
+
+function foo5(x) {
+>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop3_ES6.ts, 64, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 66, 14))
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 67, 19))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 67, 19))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 67, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 67, 19))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 68, 11))
+}
+
+
+function foo6(x) {
+>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop3_ES6.ts, 74, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 77, 14))
+
+    while (1 === 1) {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 79, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 79, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 79, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 79, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11))
+    }
+    
+    use(v)
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 80, 11))
+}
+
+function foo7(x) {
+>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop3_ES6.ts, 86, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 88, 14))
+
+    do {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 90, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 90, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 90, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 90, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11))
+
+    } while (1 === 1);
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 91, 11))
+}
+
+
+function foo8(x) {
+>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop3_ES6.ts, 97, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 100, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 102, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 101, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 103, 11))
+}
+//===const
+function foo0_c(x) {
+>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop3_ES6.ts, 109, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 111, 16))
+
+    for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 112, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 113, 11))
+}
+
+function foo0_1_c(x) {
+>foo0_1_c : Symbol(foo0_1_c, Decl(capturedLetConstInLoop3_ES6.ts, 119, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 121, 18))
+
+    for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 122, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 123, 11))
+}
+
+function foo1_c(x) {
+>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop3_ES6.ts, 129, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 131, 16))
+
+    for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 132, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11))
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 133, 11))
+}
+
+function foo2_c(x) {
+>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop3_ES6.ts, 139, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 141, 16))
+
+    while (1 === 1) {
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 143, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 144, 11))
+}
+
+function foo3_c(x) {
+>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop3_ES6.ts, 150, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 152, 16))
+
+    do {
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 154, 13))
+
+        var v;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 154, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 154, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11))
+
+    } while (1 === 1);
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 155, 11))
+}
+
+function foo4_c(x) {
+>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop3_ES6.ts, 161, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 163, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 164, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 164, 14))
+
+        var v = y;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 164, 14))
+
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 166, 13))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 166, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 166, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 165, 11))
+}
+
+function foo5_c(x) {
+>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop3_ES6.ts, 172, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 174, 16))
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 175, 21))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 175, 21))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 175, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 175, 21))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 176, 11))
+}
+
+
+function foo6_c(x) {
+>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop3_ES6.ts, 182, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 185, 16))
+
+    while (1 === 1) {
+        const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 187, 20))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 187, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 187, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 187, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11))
+    }
+    
+    use(v)
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 188, 11))
+}
+
+function foo7_c(x) {
+>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop3_ES6.ts, 194, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 196, 16))
+
+    do {
+        const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 198, 20))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 198, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 198, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 198, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11))
+
+    } while (1 === 1);
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 199, 11))
+}
+
+
+function foo8_c(x) {
+>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop3_ES6.ts, 205, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 208, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14))
+
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop3_ES6.ts, 210, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop3_ES6.ts, 209, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11))
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop3_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop3_ES6.ts, 211, 11))
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop3_ES6.types b/tests/baselines/reference/capturedLetConstInLoop3_ES6.types
new file mode 100644
index 00000000000..cc4b57ff9ea
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop3_ES6.types
@@ -0,0 +1,795 @@
+=== tests/cases/compiler/capturedLetConstInLoop3_ES6.ts ===
+
+///=========let
+declare function use(a: any);
+>use : (a: any) => any
+>a : any
+
+function foo0(x) {
+>foo0 : (x: any) => void
+>x : any
+
+    for (let x of []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo0_1(x) {
+>foo0_1 : (x: any) => void
+>x : any
+
+    for (let x in []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo1(x) {
+>foo1 : (x: any) => void
+>x : any
+
+    for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo2(x) {
+>foo2 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo3(x) {
+>foo3 : (x: any) => void
+>x : any
+
+    do {
+        let x;
+>x : any
+
+        var v;
+>v : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+    } while (1 === 1);
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo4(x) {
+>foo4 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        var v = y;
+>v : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo5(x) {
+>foo5 : (x: any) => void
+>x : any
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo6(x) {
+>foo6 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let x, y;
+>x : any
+>y : any
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => any
+>function() { return x + y + v } : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        (() => x + y + v);
+>(() => x + y + v) : () => any
+>() => x + y + v : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+    }
+    
+    use(v)
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo7(x) {
+>foo7 : (x: any) => void
+>x : any
+
+    do {
+        let x, y;
+>x : any
+>y : any
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => any
+>function() { return x + y + v } : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        (() => x + y + v);
+>(() => x + y + v) : () => any
+>() => x + y + v : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+    } while (1 === 1);
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+
+function foo8(x) {
+>foo8 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+//===const
+function foo0_c(x) {
+>foo0_c : (x: any) => void
+>x : any
+
+    for (const x of []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo0_1_c(x) {
+>foo0_1_c : (x: any) => void
+>x : any
+
+    for (const x in []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo1_c(x) {
+>foo1_c : (x: any) => void
+>x : any
+
+    for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo2_c(x) {
+>foo2_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo3_c(x) {
+>foo3_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1;
+>x : number
+>1 : number
+
+        var v;
+>v : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : number
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : number
+>v : any
+
+    } while (1 === 1);
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo4_c(x) {
+>foo4_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        var v = y;
+>v : number
+>y : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo5_c(x) {
+>foo5_c : (x: any) => void
+>x : any
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo6_c(x) {
+>foo6_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+    }
+    
+    use(v)
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo7_c(x) {
+>foo7_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+    } while (1 === 1);
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo8_c(x) {
+>foo8_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop4.js b/tests/baselines/reference/capturedLetConstInLoop4.js
new file mode 100644
index 00000000000..6257d1c697e
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop4.js
@@ -0,0 +1,338 @@
+//// [capturedLetConstInLoop4.ts]
+
+//======let
+export function exportedFoo() {
+    return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
+}
+
+for (let x of []) {
+    var v0 = x;
+    (function() { return x + v0});
+    (() => x);    
+}
+
+for (let x in []) {
+    var v00 = x;
+    (function() { return x + v00});
+    (() => x);    
+}
+
+for (let x = 0; x < 1; ++x) {
+    var v1 = x;
+    (function() { return x + v1});
+    (() => x);
+}
+
+while (1 === 1) {
+    let x;
+    var v2 = x;
+    (function() { return x + v2});
+    (() => x);
+}
+
+do {
+    let x;
+    var v3 = x;
+    (function() { return x + v3});
+    (() => x);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    var v4 = x;
+    (function() { return x + v4});
+    (() => x);
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    var v5 = x;
+    (function() { return x + y + v5});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    let x, y;
+    var v6 = x;
+    (function() { return x + y + v6});
+    (() => x + y);
+}
+
+do {
+    let x, y;
+    var v7 = x;
+    (function() { return x + y + v7});
+    (() => x + y);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    var v8 = x;
+    (function() { return x + y + v8});
+    (() => x + y);
+}
+
+//======const
+export function exportedFoo2() {
+    return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c;
+}
+
+for (const x of []) {
+    var v0_c = x;
+    (function() { return x + v0_c});
+    (() => x);    
+}
+
+for (const x in []) {
+    var v00_c = x;
+    (function() { return x + v00});
+    (() => x);    
+}
+
+for (const x = 0; x < 1;) {
+    var v1_c = x;
+    (function() { return x + v1_c});
+    (() => x);
+}
+
+while (1 === 1) {
+    const x =1;
+    var v2_c = x;
+    (function() { return x + v2_c});
+    (() => x);
+}
+
+do {
+    const x = 1;
+    var v3_c = x;
+    (function() { return x + v3_c});
+    (() => x);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    var v4_c = x;
+    (function() { return x + v4_c});
+    (() => x);
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    var v5_c = x;
+    (function() { return x + y + v5_c});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    var v6_c = x;
+    (function() { return x + y + v6_c});
+    (() => x + y);
+}
+
+do {
+    const x = 1, y = 1;
+    var v7_c = x;
+    (function() { return x + y + v7_c});
+    (() => x + y);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    var v8_c = x;
+    (function() { return x + y + v8_c});
+    (() => x + y);
+}
+
+
+//// [capturedLetConstInLoop4.js]
+System.register([], function(exports_1) {
+    var v0, v00, v1, v2, v3, v4, v5, v6, v7, v8, v0_c, v00_c, v1_c, v2_c, v3_c, v4_c, v5_c, v6_c, v7_c, v8_c;
+    //======let
+    function exportedFoo() {
+        return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
+    }
+    exports_1("exportedFoo", exportedFoo);
+    //======const
+    function exportedFoo2() {
+        return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c;
+    }
+    exports_1("exportedFoo2", exportedFoo2);
+    return {
+        setters:[],
+        execute: function() {
+            var _loop_1 = function(x) {
+                v0 = x;
+                (function () { return x + v0; });
+                (function () { return x; });
+            };
+            for (var _i = 0, _a = []; _i < _a.length; _i++) {
+                var x = _a[_i];
+                _loop_1(x);
+            }
+            var _loop_2 = function(x) {
+                v00 = x;
+                (function () { return x + v00; });
+                (function () { return x; });
+            };
+            for (var x in []) {
+                _loop_2(x);
+            }
+            var _loop_3 = function(x) {
+                v1 = x;
+                (function () { return x + v1; });
+                (function () { return x; });
+            };
+            for (var x = 0; x < 1; ++x) {
+                _loop_3(x);
+            }
+            var _loop_4 = function() {
+                var x = void 0;
+                v2 = x;
+                (function () { return x + v2; });
+                (function () { return x; });
+            };
+            while (1 === 1) {
+                _loop_4();
+            }
+            var _loop_5 = function() {
+                var x = void 0;
+                v3 = x;
+                (function () { return x + v3; });
+                (function () { return x; });
+            };
+            do {
+                _loop_5();
+            } while (1 === 1);
+            var _loop_6 = function(y) {
+                var x = 1;
+                v4 = x;
+                (function () { return x + v4; });
+                (function () { return x; });
+            };
+            for (var y = 0; y < 1; ++y) {
+                _loop_6(y);
+            }
+            var _loop_7 = function(x, y) {
+                v5 = x;
+                (function () { return x + y + v5; });
+                (function () { return x + y; });
+            };
+            for (var x = 0, y = 1; x < 1; ++x) {
+                _loop_7(x, y);
+            }
+            var _loop_8 = function() {
+                var x = void 0, y = void 0;
+                v6 = x;
+                (function () { return x + y + v6; });
+                (function () { return x + y; });
+            };
+            while (1 === 1) {
+                _loop_8();
+            }
+            var _loop_9 = function() {
+                var x = void 0, y = void 0;
+                v7 = x;
+                (function () { return x + y + v7; });
+                (function () { return x + y; });
+            };
+            do {
+                _loop_9();
+            } while (1 === 1);
+            var _loop_10 = function(y) {
+                var x = 1;
+                v8 = x;
+                (function () { return x + y + v8; });
+                (function () { return x + y; });
+            };
+            for (var y = 0; y < 1; ++y) {
+                _loop_10(y);
+            }
+            var _loop_11 = function(x) {
+                v0_c = x;
+                (function () { return x + v0_c; });
+                (function () { return x; });
+            };
+            for (var _b = 0, _c = []; _b < _c.length; _b++) {
+                var x = _c[_b];
+                _loop_11(x);
+            }
+            var _loop_12 = function(x) {
+                v00_c = x;
+                (function () { return x + v00; });
+                (function () { return x; });
+            };
+            for (var x in []) {
+                _loop_12(x);
+            }
+            var _loop_13 = function(x) {
+                v1_c = x;
+                (function () { return x + v1_c; });
+                (function () { return x; });
+            };
+            for (var x = 0; x < 1;) {
+                _loop_13(x);
+            }
+            var _loop_14 = function() {
+                var x = 1;
+                v2_c = x;
+                (function () { return x + v2_c; });
+                (function () { return x; });
+            };
+            while (1 === 1) {
+                _loop_14();
+            }
+            var _loop_15 = function() {
+                var x = 1;
+                v3_c = x;
+                (function () { return x + v3_c; });
+                (function () { return x; });
+            };
+            do {
+                _loop_15();
+            } while (1 === 1);
+            var _loop_16 = function(y) {
+                var x = 1;
+                v4_c = x;
+                (function () { return x + v4_c; });
+                (function () { return x; });
+            };
+            for (var y = 0; y < 1;) {
+                _loop_16(y);
+            }
+            var _loop_17 = function(x, y) {
+                v5_c = x;
+                (function () { return x + y + v5_c; });
+                (function () { return x + y; });
+            };
+            for (var x = 0, y = 1; x < 1;) {
+                _loop_17(x, y);
+            }
+            var _loop_18 = function() {
+                var x = 1, y = 1;
+                v6_c = x;
+                (function () { return x + y + v6_c; });
+                (function () { return x + y; });
+            };
+            while (1 === 1) {
+                _loop_18();
+            }
+            var _loop_19 = function() {
+                var x = 1, y = 1;
+                v7_c = x;
+                (function () { return x + y + v7_c; });
+                (function () { return x + y; });
+            };
+            do {
+                _loop_19();
+            } while (1 === 1);
+            var _loop_20 = function(y) {
+                var x = 1;
+                v8_c = x;
+                (function () { return x + y + v8_c; });
+                (function () { return x + y; });
+            };
+            for (var y = 0; y < 1;) {
+                _loop_20(y);
+            }
+        }
+    }
+});
diff --git a/tests/baselines/reference/capturedLetConstInLoop4.symbols b/tests/baselines/reference/capturedLetConstInLoop4.symbols
new file mode 100644
index 00000000000..19e78bbf2b4
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop4.symbols
@@ -0,0 +1,394 @@
+=== tests/cases/compiler/capturedLetConstInLoop4.ts ===
+
+//======let
+export function exportedFoo() {
+>exportedFoo : Symbol(exportedFoo, Decl(capturedLetConstInLoop4.ts, 0, 0))
+
+    return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
+>v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 7, 7))
+>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7))
+>v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 19, 7))
+>v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 26, 7))
+>v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 33, 7))
+>v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 40, 7))
+>v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 46, 7))
+>v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 53, 7))
+>v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 60, 7))
+>v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 67, 7))
+}
+
+for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8))
+
+    var v0 = x;
+>v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 7, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8))
+
+    (function() { return x + v0});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8))
+>v0 : Symbol(v0, Decl(capturedLetConstInLoop4.ts, 7, 7))
+
+    (() => x);    
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 6, 8))
+}
+
+for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8))
+
+    var v00 = x;
+>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8))
+
+    (function() { return x + v00});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8))
+>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7))
+
+    (() => x);    
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 12, 8))
+}
+
+for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8))
+
+    var v1 = x;
+>v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 19, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8))
+
+    (function() { return x + v1});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8))
+>v1 : Symbol(v1, Decl(capturedLetConstInLoop4.ts, 19, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 18, 8))
+}
+
+while (1 === 1) {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7))
+
+    var v2 = x;
+>v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 26, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7))
+
+    (function() { return x + v2});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7))
+>v2 : Symbol(v2, Decl(capturedLetConstInLoop4.ts, 26, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 25, 7))
+}
+
+do {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7))
+
+    var v3 = x;
+>v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 33, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7))
+
+    (function() { return x + v3});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7))
+>v3 : Symbol(v3, Decl(capturedLetConstInLoop4.ts, 33, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 32, 7))
+
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 38, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 38, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 38, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7))
+
+    var v4 = x;
+>v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 40, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7))
+
+    (function() { return x + v4});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7))
+>v4 : Symbol(v4, Decl(capturedLetConstInLoop4.ts, 40, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 39, 7))
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 45, 15))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8))
+
+    var v5 = x;
+>v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 46, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8))
+
+    (function() { return x + y + v5});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 45, 15))
+>v5 : Symbol(v5, Decl(capturedLetConstInLoop4.ts, 46, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 45, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 45, 15))
+}
+
+while (1 === 1) {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 52, 10))
+
+    var v6 = x;
+>v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 53, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7))
+
+    (function() { return x + y + v6});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 52, 10))
+>v6 : Symbol(v6, Decl(capturedLetConstInLoop4.ts, 53, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 52, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 52, 10))
+}
+
+do {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 59, 10))
+
+    var v7 = x;
+>v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 60, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7))
+
+    (function() { return x + y + v7});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 59, 10))
+>v7 : Symbol(v7, Decl(capturedLetConstInLoop4.ts, 60, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 59, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 59, 10))
+
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7))
+
+    var v8 = x;
+>v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 67, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7))
+
+    (function() { return x + y + v8});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8))
+>v8 : Symbol(v8, Decl(capturedLetConstInLoop4.ts, 67, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 66, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 65, 8))
+}
+
+//======const
+export function exportedFoo2() {
+>exportedFoo2 : Symbol(exportedFoo2, Decl(capturedLetConstInLoop4.ts, 70, 1))
+
+    return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c;
+>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 78, 7))
+>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4.ts, 84, 7))
+>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 90, 7))
+>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 97, 7))
+>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 104, 7))
+>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 111, 7))
+>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 117, 7))
+>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 124, 7))
+>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 131, 7))
+>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 138, 7))
+}
+
+for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10))
+
+    var v0_c = x;
+>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 78, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10))
+
+    (function() { return x + v0_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10))
+>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4.ts, 78, 7))
+
+    (() => x);    
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 77, 10))
+}
+
+for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10))
+
+    var v00_c = x;
+>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4.ts, 84, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10))
+
+    (function() { return x + v00});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10))
+>v00 : Symbol(v00, Decl(capturedLetConstInLoop4.ts, 13, 7))
+
+    (() => x);    
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 83, 10))
+}
+
+for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10))
+
+    var v1_c = x;
+>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 90, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10))
+
+    (function() { return x + v1_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10))
+>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4.ts, 90, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 89, 10))
+}
+
+while (1 === 1) {
+    const x =1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9))
+
+    var v2_c = x;
+>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 97, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9))
+
+    (function() { return x + v2_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9))
+>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4.ts, 97, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 96, 9))
+}
+
+do {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9))
+
+    var v3_c = x;
+>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 104, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9))
+
+    (function() { return x + v3_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9))
+>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4.ts, 104, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 103, 9))
+
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 109, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 109, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9))
+
+    var v4_c = x;
+>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 111, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9))
+
+    (function() { return x + v4_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9))
+>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4.ts, 111, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 110, 9))
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 116, 17))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10))
+
+    var v5_c = x;
+>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 117, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10))
+
+    (function() { return x + y + v5_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 116, 17))
+>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4.ts, 117, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 116, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 116, 17))
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 123, 16))
+
+    var v6_c = x;
+>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 124, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9))
+
+    (function() { return x + y + v6_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 123, 16))
+>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4.ts, 124, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 123, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 123, 16))
+}
+
+do {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 130, 16))
+
+    var v7_c = x;
+>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 131, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9))
+
+    (function() { return x + y + v7_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 130, 16))
+>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4.ts, 131, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 130, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 130, 16))
+
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9))
+
+    var v8_c = x;
+>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 138, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9))
+
+    (function() { return x + y + v8_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10))
+>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4.ts, 138, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4.ts, 137, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4.ts, 136, 10))
+}
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop4.types b/tests/baselines/reference/capturedLetConstInLoop4.types
new file mode 100644
index 00000000000..f19e5d109b8
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop4.types
@@ -0,0 +1,600 @@
+=== tests/cases/compiler/capturedLetConstInLoop4.ts ===
+
+//======let
+export function exportedFoo() {
+>exportedFoo : () => any
+
+    return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
+>v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 : any
+>v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 : any
+>v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 : any
+>v0 + v00 + v1 + v2 + v3 + v4 + v5 : any
+>v0 + v00 + v1 + v2 + v3 + v4 : any
+>v0 + v00 + v1 + v2 + v3 : any
+>v0 + v00 + v1 + v2 : any
+>v0 + v00 + v1 : any
+>v0 + v00 : any
+>v0 : any
+>v00 : any
+>v1 : number
+>v2 : any
+>v3 : any
+>v4 : number
+>v5 : number
+>v6 : any
+>v7 : any
+>v8 : number
+}
+
+for (let x of []) {
+>x : any
+>[] : undefined[]
+
+    var v0 = x;
+>v0 : any
+>x : any
+
+    (function() { return x + v0});
+>(function() { return x + v0}) : () => any
+>function() { return x + v0} : () => any
+>x + v0 : any
+>x : any
+>v0 : any
+
+    (() => x);    
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (let x in []) {
+>x : any
+>[] : undefined[]
+
+    var v00 = x;
+>v00 : any
+>x : any
+
+    (function() { return x + v00});
+>(function() { return x + v00}) : () => any
+>function() { return x + v00} : () => any
+>x + v00 : any
+>x : any
+>v00 : any
+
+    (() => x);    
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    var v1 = x;
+>v1 : number
+>x : number
+
+    (function() { return x + v1});
+>(function() { return x + v1}) : () => number
+>function() { return x + v1} : () => number
+>x + v1 : number
+>x : number
+>v1 : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x;
+>x : any
+
+    var v2 = x;
+>v2 : any
+>x : any
+
+    (function() { return x + v2});
+>(function() { return x + v2}) : () => any
+>function() { return x + v2} : () => any
+>x + v2 : any
+>x : any
+>v2 : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+do {
+    let x;
+>x : any
+
+    var v3 = x;
+>v3 : any
+>x : any
+
+    (function() { return x + v3});
+>(function() { return x + v3}) : () => any
+>function() { return x + v3} : () => any
+>x + v3 : any
+>x : any
+>v3 : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    var v4 = x;
+>v4 : number
+>x : number
+
+    (function() { return x + v4});
+>(function() { return x + v4}) : () => number
+>function() { return x + v4} : () => number
+>x + v4 : number
+>x : number
+>v4 : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    var v5 = x;
+>v5 : number
+>x : number
+
+    (function() { return x + y + v5});
+>(function() { return x + y + v5}) : () => number
+>function() { return x + y + v5} : () => number
+>x + y + v5 : number
+>x + y : number
+>x : number
+>y : number
+>v5 : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x, y;
+>x : any
+>y : any
+
+    var v6 = x;
+>v6 : any
+>x : any
+
+    (function() { return x + y + v6});
+>(function() { return x + y + v6}) : () => any
+>function() { return x + y + v6} : () => any
+>x + y + v6 : any
+>x + y : any
+>x : any
+>y : any
+>v6 : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+}
+
+do {
+    let x, y;
+>x : any
+>y : any
+
+    var v7 = x;
+>v7 : any
+>x : any
+
+    (function() { return x + y + v7});
+>(function() { return x + y + v7}) : () => any
+>function() { return x + y + v7} : () => any
+>x + y + v7 : any
+>x + y : any
+>x : any
+>y : any
+>v7 : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    var v8 = x;
+>v8 : number
+>x : number
+
+    (function() { return x + y + v8});
+>(function() { return x + y + v8}) : () => number
+>function() { return x + y + v8} : () => number
+>x + y + v8 : number
+>x + y : number
+>x : number
+>y : number
+>v8 : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+//======const
+export function exportedFoo2() {
+>exportedFoo2 : () => any
+
+    return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c;
+>v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c : any
+>v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c : any
+>v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c : any
+>v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c : any
+>v0_c + v00_c + v1_c + v2_c + v3_c + v4_c : any
+>v0_c + v00_c + v1_c + v2_c + v3_c : any
+>v0_c + v00_c + v1_c + v2_c : any
+>v0_c + v00_c + v1_c : any
+>v0_c + v00_c : any
+>v0_c : any
+>v00_c : any
+>v1_c : number
+>v2_c : number
+>v3_c : number
+>v4_c : number
+>v5_c : number
+>v6_c : number
+>v7_c : number
+>v8_c : number
+}
+
+for (const x of []) {
+>x : any
+>[] : undefined[]
+
+    var v0_c = x;
+>v0_c : any
+>x : any
+
+    (function() { return x + v0_c});
+>(function() { return x + v0_c}) : () => any
+>function() { return x + v0_c} : () => any
+>x + v0_c : any
+>x : any
+>v0_c : any
+
+    (() => x);    
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (const x in []) {
+>x : any
+>[] : undefined[]
+
+    var v00_c = x;
+>v00_c : any
+>x : any
+
+    (function() { return x + v00});
+>(function() { return x + v00}) : () => any
+>function() { return x + v00} : () => any
+>x + v00 : any
+>x : any
+>v00 : any
+
+    (() => x);    
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    var v1_c = x;
+>v1_c : number
+>x : number
+
+    (function() { return x + v1_c});
+>(function() { return x + v1_c}) : () => number
+>function() { return x + v1_c} : () => number
+>x + v1_c : number
+>x : number
+>v1_c : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x =1;
+>x : number
+>1 : number
+
+    var v2_c = x;
+>v2_c : number
+>x : number
+
+    (function() { return x + v2_c});
+>(function() { return x + v2_c}) : () => number
+>function() { return x + v2_c} : () => number
+>x + v2_c : number
+>x : number
+>v2_c : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+do {
+    const x = 1;
+>x : number
+>1 : number
+
+    var v3_c = x;
+>v3_c : number
+>x : number
+
+    (function() { return x + v3_c});
+>(function() { return x + v3_c}) : () => number
+>function() { return x + v3_c} : () => number
+>x + v3_c : number
+>x : number
+>v3_c : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    var v4_c = x;
+>v4_c : number
+>x : number
+
+    (function() { return x + v4_c});
+>(function() { return x + v4_c}) : () => number
+>function() { return x + v4_c} : () => number
+>x + v4_c : number
+>x : number
+>v4_c : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    var v5_c = x;
+>v5_c : number
+>x : number
+
+    (function() { return x + y + v5_c});
+>(function() { return x + y + v5_c}) : () => number
+>function() { return x + y + v5_c} : () => number
+>x + y + v5_c : number
+>x + y : number
+>x : number
+>y : number
+>v5_c : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    var v6_c = x;
+>v6_c : number
+>x : number
+
+    (function() { return x + y + v6_c});
+>(function() { return x + y + v6_c}) : () => number
+>function() { return x + y + v6_c} : () => number
+>x + y + v6_c : number
+>x + y : number
+>x : number
+>y : number
+>v6_c : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+do {
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    var v7_c = x;
+>v7_c : number
+>x : number
+
+    (function() { return x + y + v7_c});
+>(function() { return x + y + v7_c}) : () => number
+>function() { return x + y + v7_c} : () => number
+>x + y + v7_c : number
+>x + y : number
+>x : number
+>y : number
+>v7_c : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    var v8_c = x;
+>v8_c : number
+>x : number
+
+    (function() { return x + y + v8_c});
+>(function() { return x + y + v8_c}) : () => number
+>function() { return x + y + v8_c} : () => number
+>x + y + v8_c : number
+>x + y : number
+>x : number
+>y : number
+>v8_c : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop4_ES6.js b/tests/baselines/reference/capturedLetConstInLoop4_ES6.js
new file mode 100644
index 00000000000..83b0af1f23c
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop4_ES6.js
@@ -0,0 +1,266 @@
+//// [capturedLetConstInLoop4_ES6.ts]
+
+//======let
+export function exportedFoo() {
+    return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
+}
+
+for (let x of []) {
+    var v0 = x;
+    (function() { return x + v0});
+    (() => x);    
+}
+
+for (let x in []) {
+    var v00 = x;
+    (function() { return x + v00});
+    (() => x);    
+}
+
+for (let x = 0; x < 1; ++x) {
+    var v1 = x;
+    (function() { return x + v1});
+    (() => x);
+}
+
+while (1 === 1) {
+    let x;
+    var v2 = x;
+    (function() { return x + v2});
+    (() => x);
+}
+
+do {
+    let x;
+    var v3 = x;
+    (function() { return x + v3});
+    (() => x);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    var v4 = x;
+    (function() { return x + v4});
+    (() => x);
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    var v5 = x;
+    (function() { return x + y + v5});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    let x, y;
+    var v6 = x;
+    (function() { return x + y + v6});
+    (() => x + y);
+}
+
+do {
+    let x, y;
+    var v7 = x;
+    (function() { return x + y + v7});
+    (() => x + y);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    var v8 = x;
+    (function() { return x + y + v8});
+    (() => x + y);
+}
+
+//======const
+export function exportedFoo2() {
+    return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c;
+}
+
+for (const x of []) {
+    var v0_c = x;
+    (function() { return x + v0_c});
+    (() => x);    
+}
+
+for (const x in []) {
+    var v00_c = x;
+    (function() { return x + v00});
+    (() => x);    
+}
+
+for (const x = 0; x < 1;) {
+    var v1_c = x;
+    (function() { return x + v1_c});
+    (() => x);
+}
+
+while (1 === 1) {
+    const x =1;
+    var v2_c = x;
+    (function() { return x + v2_c});
+    (() => x);
+}
+
+do {
+    const x = 1;
+    var v3_c = x;
+    (function() { return x + v3_c});
+    (() => x);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    var v4_c = x;
+    (function() { return x + v4_c});
+    (() => x);
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    var v5_c = x;
+    (function() { return x + y + v5_c});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    var v6_c = x;
+    (function() { return x + y + v6_c});
+    (() => x + y);
+}
+
+do {
+    const x = 1, y = 1;
+    var v7_c = x;
+    (function() { return x + y + v7_c});
+    (() => x + y);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    var v8_c = x;
+    (function() { return x + y + v8_c});
+    (() => x + y);
+}
+
+
+//// [capturedLetConstInLoop4_ES6.js]
+//======let
+export function exportedFoo() {
+    return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
+}
+for (let x of []) {
+    var v0 = x;
+    (function () { return x + v0; });
+    (() => x);
+}
+for (let x in []) {
+    var v00 = x;
+    (function () { return x + v00; });
+    (() => x);
+}
+for (let x = 0; x < 1; ++x) {
+    var v1 = x;
+    (function () { return x + v1; });
+    (() => x);
+}
+while (1 === 1) {
+    let x;
+    var v2 = x;
+    (function () { return x + v2; });
+    (() => x);
+}
+do {
+    let x;
+    var v3 = x;
+    (function () { return x + v3; });
+    (() => x);
+} while (1 === 1);
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    var v4 = x;
+    (function () { return x + v4; });
+    (() => x);
+}
+for (let x = 0, y = 1; x < 1; ++x) {
+    var v5 = x;
+    (function () { return x + y + v5; });
+    (() => x + y);
+}
+while (1 === 1) {
+    let x, y;
+    var v6 = x;
+    (function () { return x + y + v6; });
+    (() => x + y);
+}
+do {
+    let x, y;
+    var v7 = x;
+    (function () { return x + y + v7; });
+    (() => x + y);
+} while (1 === 1);
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    var v8 = x;
+    (function () { return x + y + v8; });
+    (() => x + y);
+}
+//======const
+export function exportedFoo2() {
+    return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c;
+}
+for (const x of []) {
+    var v0_c = x;
+    (function () { return x + v0_c; });
+    (() => x);
+}
+for (const x in []) {
+    var v00_c = x;
+    (function () { return x + v00; });
+    (() => x);
+}
+for (const x = 0; x < 1;) {
+    var v1_c = x;
+    (function () { return x + v1_c; });
+    (() => x);
+}
+while (1 === 1) {
+    const x = 1;
+    var v2_c = x;
+    (function () { return x + v2_c; });
+    (() => x);
+}
+do {
+    const x = 1;
+    var v3_c = x;
+    (function () { return x + v3_c; });
+    (() => x);
+} while (1 === 1);
+for (const y = 0; y < 1;) {
+    const x = 1;
+    var v4_c = x;
+    (function () { return x + v4_c; });
+    (() => x);
+}
+for (const x = 0, y = 1; x < 1;) {
+    var v5_c = x;
+    (function () { return x + y + v5_c; });
+    (() => x + y);
+}
+while (1 === 1) {
+    const x = 1, y = 1;
+    var v6_c = x;
+    (function () { return x + y + v6_c; });
+    (() => x + y);
+}
+do {
+    const x = 1, y = 1;
+    var v7_c = x;
+    (function () { return x + y + v7_c; });
+    (() => x + y);
+} while (1 === 1);
+for (const y = 0; y < 1;) {
+    const x = 1;
+    var v8_c = x;
+    (function () { return x + y + v8_c; });
+    (() => x + y);
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols
new file mode 100644
index 00000000000..cc5a2ad54bc
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop4_ES6.symbols
@@ -0,0 +1,394 @@
+=== tests/cases/compiler/capturedLetConstInLoop4_ES6.ts ===
+
+//======let
+export function exportedFoo() {
+>exportedFoo : Symbol(exportedFoo, Decl(capturedLetConstInLoop4_ES6.ts, 0, 0))
+
+    return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
+>v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 7, 7))
+>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7))
+>v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 19, 7))
+>v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 26, 7))
+>v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 33, 7))
+>v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 40, 7))
+>v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 46, 7))
+>v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 53, 7))
+>v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 60, 7))
+>v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 67, 7))
+}
+
+for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8))
+
+    var v0 = x;
+>v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 7, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8))
+
+    (function() { return x + v0});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8))
+>v0 : Symbol(v0, Decl(capturedLetConstInLoop4_ES6.ts, 7, 7))
+
+    (() => x);    
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 6, 8))
+}
+
+for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8))
+
+    var v00 = x;
+>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8))
+
+    (function() { return x + v00});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8))
+>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7))
+
+    (() => x);    
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 12, 8))
+}
+
+for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8))
+
+    var v1 = x;
+>v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 19, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8))
+
+    (function() { return x + v1});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8))
+>v1 : Symbol(v1, Decl(capturedLetConstInLoop4_ES6.ts, 19, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 18, 8))
+}
+
+while (1 === 1) {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7))
+
+    var v2 = x;
+>v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 26, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7))
+
+    (function() { return x + v2});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7))
+>v2 : Symbol(v2, Decl(capturedLetConstInLoop4_ES6.ts, 26, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 25, 7))
+}
+
+do {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7))
+
+    var v3 = x;
+>v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 33, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7))
+
+    (function() { return x + v3});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7))
+>v3 : Symbol(v3, Decl(capturedLetConstInLoop4_ES6.ts, 33, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 32, 7))
+
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 38, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 38, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 38, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7))
+
+    var v4 = x;
+>v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 40, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7))
+
+    (function() { return x + v4});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7))
+>v4 : Symbol(v4, Decl(capturedLetConstInLoop4_ES6.ts, 40, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 39, 7))
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 45, 15))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8))
+
+    var v5 = x;
+>v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 46, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8))
+
+    (function() { return x + y + v5});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 45, 15))
+>v5 : Symbol(v5, Decl(capturedLetConstInLoop4_ES6.ts, 46, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 45, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 45, 15))
+}
+
+while (1 === 1) {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 52, 10))
+
+    var v6 = x;
+>v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 53, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7))
+
+    (function() { return x + y + v6});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 52, 10))
+>v6 : Symbol(v6, Decl(capturedLetConstInLoop4_ES6.ts, 53, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 52, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 52, 10))
+}
+
+do {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 59, 10))
+
+    var v7 = x;
+>v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 60, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7))
+
+    (function() { return x + y + v7});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 59, 10))
+>v7 : Symbol(v7, Decl(capturedLetConstInLoop4_ES6.ts, 60, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 59, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 59, 10))
+
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7))
+
+    var v8 = x;
+>v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 67, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7))
+
+    (function() { return x + y + v8});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8))
+>v8 : Symbol(v8, Decl(capturedLetConstInLoop4_ES6.ts, 67, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 66, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 65, 8))
+}
+
+//======const
+export function exportedFoo2() {
+>exportedFoo2 : Symbol(exportedFoo2, Decl(capturedLetConstInLoop4_ES6.ts, 70, 1))
+
+    return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c;
+>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 78, 7))
+>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4_ES6.ts, 84, 7))
+>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 90, 7))
+>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 97, 7))
+>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 104, 7))
+>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 111, 7))
+>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 117, 7))
+>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 124, 7))
+>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 131, 7))
+>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 138, 7))
+}
+
+for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10))
+
+    var v0_c = x;
+>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 78, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10))
+
+    (function() { return x + v0_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10))
+>v0_c : Symbol(v0_c, Decl(capturedLetConstInLoop4_ES6.ts, 78, 7))
+
+    (() => x);    
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 77, 10))
+}
+
+for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10))
+
+    var v00_c = x;
+>v00_c : Symbol(v00_c, Decl(capturedLetConstInLoop4_ES6.ts, 84, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10))
+
+    (function() { return x + v00});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10))
+>v00 : Symbol(v00, Decl(capturedLetConstInLoop4_ES6.ts, 13, 7))
+
+    (() => x);    
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 83, 10))
+}
+
+for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10))
+
+    var v1_c = x;
+>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 90, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10))
+
+    (function() { return x + v1_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10))
+>v1_c : Symbol(v1_c, Decl(capturedLetConstInLoop4_ES6.ts, 90, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 89, 10))
+}
+
+while (1 === 1) {
+    const x =1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9))
+
+    var v2_c = x;
+>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 97, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9))
+
+    (function() { return x + v2_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9))
+>v2_c : Symbol(v2_c, Decl(capturedLetConstInLoop4_ES6.ts, 97, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 96, 9))
+}
+
+do {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9))
+
+    var v3_c = x;
+>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 104, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9))
+
+    (function() { return x + v3_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9))
+>v3_c : Symbol(v3_c, Decl(capturedLetConstInLoop4_ES6.ts, 104, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 103, 9))
+
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 109, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 109, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9))
+
+    var v4_c = x;
+>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 111, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9))
+
+    (function() { return x + v4_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9))
+>v4_c : Symbol(v4_c, Decl(capturedLetConstInLoop4_ES6.ts, 111, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 110, 9))
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 116, 17))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10))
+
+    var v5_c = x;
+>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 117, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10))
+
+    (function() { return x + y + v5_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 116, 17))
+>v5_c : Symbol(v5_c, Decl(capturedLetConstInLoop4_ES6.ts, 117, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 116, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 116, 17))
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 123, 16))
+
+    var v6_c = x;
+>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 124, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9))
+
+    (function() { return x + y + v6_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 123, 16))
+>v6_c : Symbol(v6_c, Decl(capturedLetConstInLoop4_ES6.ts, 124, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 123, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 123, 16))
+}
+
+do {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 130, 16))
+
+    var v7_c = x;
+>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 131, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9))
+
+    (function() { return x + y + v7_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 130, 16))
+>v7_c : Symbol(v7_c, Decl(capturedLetConstInLoop4_ES6.ts, 131, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 130, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 130, 16))
+
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9))
+
+    var v8_c = x;
+>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 138, 7))
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9))
+
+    (function() { return x + y + v8_c});
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10))
+>v8_c : Symbol(v8_c, Decl(capturedLetConstInLoop4_ES6.ts, 138, 7))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop4_ES6.ts, 137, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop4_ES6.ts, 136, 10))
+}
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop4_ES6.types b/tests/baselines/reference/capturedLetConstInLoop4_ES6.types
new file mode 100644
index 00000000000..fd5f6dadf62
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop4_ES6.types
@@ -0,0 +1,600 @@
+=== tests/cases/compiler/capturedLetConstInLoop4_ES6.ts ===
+
+//======let
+export function exportedFoo() {
+>exportedFoo : () => any
+
+    return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
+>v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8 : any
+>v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 : any
+>v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 : any
+>v0 + v00 + v1 + v2 + v3 + v4 + v5 : any
+>v0 + v00 + v1 + v2 + v3 + v4 : any
+>v0 + v00 + v1 + v2 + v3 : any
+>v0 + v00 + v1 + v2 : any
+>v0 + v00 + v1 : any
+>v0 + v00 : any
+>v0 : any
+>v00 : any
+>v1 : number
+>v2 : any
+>v3 : any
+>v4 : number
+>v5 : number
+>v6 : any
+>v7 : any
+>v8 : number
+}
+
+for (let x of []) {
+>x : any
+>[] : undefined[]
+
+    var v0 = x;
+>v0 : any
+>x : any
+
+    (function() { return x + v0});
+>(function() { return x + v0}) : () => any
+>function() { return x + v0} : () => any
+>x + v0 : any
+>x : any
+>v0 : any
+
+    (() => x);    
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (let x in []) {
+>x : any
+>[] : undefined[]
+
+    var v00 = x;
+>v00 : any
+>x : any
+
+    (function() { return x + v00});
+>(function() { return x + v00}) : () => any
+>function() { return x + v00} : () => any
+>x + v00 : any
+>x : any
+>v00 : any
+
+    (() => x);    
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    var v1 = x;
+>v1 : number
+>x : number
+
+    (function() { return x + v1});
+>(function() { return x + v1}) : () => number
+>function() { return x + v1} : () => number
+>x + v1 : number
+>x : number
+>v1 : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x;
+>x : any
+
+    var v2 = x;
+>v2 : any
+>x : any
+
+    (function() { return x + v2});
+>(function() { return x + v2}) : () => any
+>function() { return x + v2} : () => any
+>x + v2 : any
+>x : any
+>v2 : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+do {
+    let x;
+>x : any
+
+    var v3 = x;
+>v3 : any
+>x : any
+
+    (function() { return x + v3});
+>(function() { return x + v3}) : () => any
+>function() { return x + v3} : () => any
+>x + v3 : any
+>x : any
+>v3 : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    var v4 = x;
+>v4 : number
+>x : number
+
+    (function() { return x + v4});
+>(function() { return x + v4}) : () => number
+>function() { return x + v4} : () => number
+>x + v4 : number
+>x : number
+>v4 : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    var v5 = x;
+>v5 : number
+>x : number
+
+    (function() { return x + y + v5});
+>(function() { return x + y + v5}) : () => number
+>function() { return x + y + v5} : () => number
+>x + y + v5 : number
+>x + y : number
+>x : number
+>y : number
+>v5 : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x, y;
+>x : any
+>y : any
+
+    var v6 = x;
+>v6 : any
+>x : any
+
+    (function() { return x + y + v6});
+>(function() { return x + y + v6}) : () => any
+>function() { return x + y + v6} : () => any
+>x + y + v6 : any
+>x + y : any
+>x : any
+>y : any
+>v6 : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+}
+
+do {
+    let x, y;
+>x : any
+>y : any
+
+    var v7 = x;
+>v7 : any
+>x : any
+
+    (function() { return x + y + v7});
+>(function() { return x + y + v7}) : () => any
+>function() { return x + y + v7} : () => any
+>x + y + v7 : any
+>x + y : any
+>x : any
+>y : any
+>v7 : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    var v8 = x;
+>v8 : number
+>x : number
+
+    (function() { return x + y + v8});
+>(function() { return x + y + v8}) : () => number
+>function() { return x + y + v8} : () => number
+>x + y + v8 : number
+>x + y : number
+>x : number
+>y : number
+>v8 : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+//======const
+export function exportedFoo2() {
+>exportedFoo2 : () => any
+
+    return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c;
+>v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c : any
+>v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c : any
+>v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c : any
+>v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c : any
+>v0_c + v00_c + v1_c + v2_c + v3_c + v4_c : any
+>v0_c + v00_c + v1_c + v2_c + v3_c : any
+>v0_c + v00_c + v1_c + v2_c : any
+>v0_c + v00_c + v1_c : any
+>v0_c + v00_c : any
+>v0_c : any
+>v00_c : any
+>v1_c : number
+>v2_c : number
+>v3_c : number
+>v4_c : number
+>v5_c : number
+>v6_c : number
+>v7_c : number
+>v8_c : number
+}
+
+for (const x of []) {
+>x : any
+>[] : undefined[]
+
+    var v0_c = x;
+>v0_c : any
+>x : any
+
+    (function() { return x + v0_c});
+>(function() { return x + v0_c}) : () => any
+>function() { return x + v0_c} : () => any
+>x + v0_c : any
+>x : any
+>v0_c : any
+
+    (() => x);    
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (const x in []) {
+>x : any
+>[] : undefined[]
+
+    var v00_c = x;
+>v00_c : any
+>x : any
+
+    (function() { return x + v00});
+>(function() { return x + v00}) : () => any
+>function() { return x + v00} : () => any
+>x + v00 : any
+>x : any
+>v00 : any
+
+    (() => x);    
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+}
+
+for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    var v1_c = x;
+>v1_c : number
+>x : number
+
+    (function() { return x + v1_c});
+>(function() { return x + v1_c}) : () => number
+>function() { return x + v1_c} : () => number
+>x + v1_c : number
+>x : number
+>v1_c : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x =1;
+>x : number
+>1 : number
+
+    var v2_c = x;
+>v2_c : number
+>x : number
+
+    (function() { return x + v2_c});
+>(function() { return x + v2_c}) : () => number
+>function() { return x + v2_c} : () => number
+>x + v2_c : number
+>x : number
+>v2_c : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+do {
+    const x = 1;
+>x : number
+>1 : number
+
+    var v3_c = x;
+>v3_c : number
+>x : number
+
+    (function() { return x + v3_c});
+>(function() { return x + v3_c}) : () => number
+>function() { return x + v3_c} : () => number
+>x + v3_c : number
+>x : number
+>v3_c : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    var v4_c = x;
+>v4_c : number
+>x : number
+
+    (function() { return x + v4_c});
+>(function() { return x + v4_c}) : () => number
+>function() { return x + v4_c} : () => number
+>x + v4_c : number
+>x : number
+>v4_c : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    var v5_c = x;
+>v5_c : number
+>x : number
+
+    (function() { return x + y + v5_c});
+>(function() { return x + y + v5_c}) : () => number
+>function() { return x + y + v5_c} : () => number
+>x + y + v5_c : number
+>x + y : number
+>x : number
+>y : number
+>v5_c : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    var v6_c = x;
+>v6_c : number
+>x : number
+
+    (function() { return x + y + v6_c});
+>(function() { return x + y + v6_c}) : () => number
+>function() { return x + y + v6_c} : () => number
+>x + y + v6_c : number
+>x + y : number
+>x : number
+>y : number
+>v6_c : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
+do {
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    var v7_c = x;
+>v7_c : number
+>x : number
+
+    (function() { return x + y + v7_c});
+>(function() { return x + y + v7_c}) : () => number
+>function() { return x + y + v7_c} : () => number
+>x + y + v7_c : number
+>x + y : number
+>x : number
+>y : number
+>v7_c : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    var v8_c = x;
+>v8_c : number
+>x : number
+
+    (function() { return x + y + v8_c});
+>(function() { return x + y + v8_c}) : () => number
+>function() { return x + y + v8_c} : () => number
+>x + y + v8_c : number
+>x + y : number
+>x : number
+>y : number
+>v8_c : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+}
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop5.js b/tests/baselines/reference/capturedLetConstInLoop5.js
new file mode 100644
index 00000000000..0ce9cf3d57c
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop5.js
@@ -0,0 +1,617 @@
+//// [capturedLetConstInLoop5.ts]
+declare function use(a: any);
+
+//====let
+function foo0(x) {
+    for (let x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo00(x) {
+    for (let x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo3(x) {
+    do {
+        let x;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    };
+    
+    use(v)
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+//====const
+function foo0_c(x) {
+    for (const x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo00_c(x) {
+    for (const x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v)
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+//// [capturedLetConstInLoop5.js]
+//====let
+function foo0(x) {
+    var _loop_1 = function(x_1) {
+        v = x_1;
+        (function () { return x_1 + v; });
+        (function () { return x_1 + v; });
+        if (x_1 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var _i = 0, _a = []; _i < _a.length; _i++) {
+        var x_1 = _a[_i];
+        var state_1 = _loop_1(x_1);
+        if (typeof state_1 === "object") return state_1.value
+    }
+    use(v);
+}
+function foo00(x) {
+    var _loop_2 = function(x_2) {
+        v = x_2;
+        (function () { return x_2 + v; });
+        (function () { return x_2 + v; });
+        if (x_2 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var x_2 in []) {
+        var state_2 = _loop_2(x_2);
+        if (typeof state_2 === "object") return state_2.value
+    }
+    use(v);
+}
+function foo1(x) {
+    var _loop_3 = function(x_3) {
+        v = x_3;
+        (function () { return x_3 + v; });
+        (function () { return x_3 + v; });
+        if (x_3 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var x_3 = 0; x_3 < 1; ++x_3) {
+        var state_3 = _loop_3(x_3);
+        if (typeof state_3 === "object") return state_3.value
+    }
+    use(v);
+}
+function foo2(x) {
+    var _loop_4 = function() {
+        var x_4 = 1;
+        v = x_4;
+        (function () { return x_4 + v; });
+        (function () { return x_4 + v; });
+        if (x_4 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    while (1 === 1) {
+        var state_4 = _loop_4();
+        if (typeof state_4 === "object") return state_4.value
+    }
+    use(v);
+}
+function foo3(x) {
+    var _loop_5 = function() {
+        var x_5 = void 0;
+        (function () { return x_5 + v; });
+        (function () { return x_5 + v; });
+        if (x_5 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    do {
+        var state_5 = _loop_5();
+        if (typeof state_5 === "object") return state_5.value
+    } while (1 === 1);
+    use(v);
+}
+function foo4(x) {
+    var _loop_6 = function(y) {
+        v = y;
+        var x_6 = 1;
+        (function () { return x_6 + v; });
+        (function () { return x_6 + v; });
+        if (x_6 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var y = 0; y < 1; ++y) {
+        var state_6 = _loop_6(y);
+        if (typeof state_6 === "object") return state_6.value
+    }
+    use(v);
+}
+function foo5(x) {
+    var _loop_7 = function(x_7, y) {
+        v = x_7;
+        (function () { return x_7 + y + v; });
+        (function () { return x_7 + y + v; });
+        if (x_7 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var x_7 = 0, y = 1; x_7 < 1; ++x_7) {
+        var state_7 = _loop_7(x_7, y);
+        if (typeof state_7 === "object") return state_7.value
+    }
+    use(v);
+}
+function foo6(x) {
+    var _loop_8 = function() {
+        var x_8 = void 0, y = void 0;
+        v = x_8;
+        (function () { return x_8 + y + v; });
+        (function () { return x_8 + y + v; });
+        if (x_8 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    while (1 === 1) {
+        var state_8 = _loop_8();
+        if (typeof state_8 === "object") return state_8.value
+    }
+    ;
+    use(v);
+}
+function foo7(x) {
+    var _loop_9 = function() {
+        var x_9 = void 0, y = void 0;
+        v = x_9;
+        (function () { return x_9 + y + v; });
+        (function () { return x_9 + y + v; });
+        if (x_9 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    do {
+        var state_9 = _loop_9();
+        if (typeof state_9 === "object") return state_9.value
+    } while (1 === 1);
+    use(v);
+}
+function foo8(x) {
+    var _loop_10 = function(y) {
+        var x_10 = 1;
+        v = x_10;
+        (function () { return x_10 + y + v; });
+        (function () { return x_10 + y + v; });
+        if (x_10 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var y = 0; y < 1; ++y) {
+        var state_10 = _loop_10(y);
+        if (typeof state_10 === "object") return state_10.value
+    }
+    use(v);
+}
+//====const
+function foo0_c(x) {
+    var _loop_11 = function(x_11) {
+        v = x_11;
+        (function () { return x_11 + v; });
+        (function () { return x_11 + v; });
+        if (x_11 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var _i = 0, _a = []; _i < _a.length; _i++) {
+        var x_11 = _a[_i];
+        var state_11 = _loop_11(x_11);
+        if (typeof state_11 === "object") return state_11.value
+    }
+    use(v);
+}
+function foo00_c(x) {
+    var _loop_12 = function(x_12) {
+        v = x_12;
+        (function () { return x_12 + v; });
+        (function () { return x_12 + v; });
+        if (x_12 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var x_12 in []) {
+        var state_12 = _loop_12(x_12);
+        if (typeof state_12 === "object") return state_12.value
+    }
+    use(v);
+}
+function foo1_c(x) {
+    var _loop_13 = function(x_13) {
+        v = x_13;
+        (function () { return x_13 + v; });
+        (function () { return x_13 + v; });
+        if (x_13 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var x_13 = 0; x_13 < 1;) {
+        var state_13 = _loop_13(x_13);
+        if (typeof state_13 === "object") return state_13.value
+    }
+    use(v);
+}
+function foo2_c(x) {
+    var _loop_14 = function() {
+        var x_14 = 1;
+        v = x_14;
+        (function () { return x_14 + v; });
+        (function () { return x_14 + v; });
+        if (x_14 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    while (1 === 1) {
+        var state_14 = _loop_14();
+        if (typeof state_14 === "object") return state_14.value
+    }
+    use(v);
+}
+function foo3_c(x) {
+    var _loop_15 = function() {
+        var x_15 = 1;
+        (function () { return x_15 + v; });
+        (function () { return x_15 + v; });
+        if (x_15 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    do {
+        var state_15 = _loop_15();
+        if (typeof state_15 === "object") return state_15.value
+    } while (1 === 1);
+    use(v);
+}
+function foo4_c(x) {
+    var _loop_16 = function(y) {
+        v = y;
+        var x_16 = 1;
+        (function () { return x_16 + v; });
+        (function () { return x_16 + v; });
+        if (x_16 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var y = 0; y < 1;) {
+        var state_16 = _loop_16(y);
+        if (typeof state_16 === "object") return state_16.value
+    }
+    use(v);
+}
+function foo5_c(x) {
+    var _loop_17 = function(x_17, y) {
+        v = x_17;
+        (function () { return x_17 + y + v; });
+        (function () { return x_17 + y + v; });
+        if (x_17 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var x_17 = 0, y = 1; x_17 < 1;) {
+        var state_17 = _loop_17(x_17, y);
+        if (typeof state_17 === "object") return state_17.value
+    }
+    use(v);
+}
+function foo6_c(x) {
+    var _loop_18 = function() {
+        var x_18 = 1, y = 1;
+        v = x_18;
+        (function () { return x_18 + y + v; });
+        (function () { return x_18 + y + v; });
+        if (x_18 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    while (1 === 1) {
+        var state_18 = _loop_18();
+        if (typeof state_18 === "object") return state_18.value
+    }
+    use(v);
+}
+function foo7_c(x) {
+    var _loop_19 = function() {
+        var x_19 = 1, y = 1;
+        v = x_19;
+        (function () { return x_19 + y + v; });
+        (function () { return x_19 + y + v; });
+        if (x_19 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    do {
+        var state_19 = _loop_19();
+        if (typeof state_19 === "object") return state_19.value
+    } while (1 === 1);
+    use(v);
+}
+function foo8_c(x) {
+    var _loop_20 = function(y) {
+        var x_20 = 1;
+        v = x_20;
+        (function () { return x_20 + y + v; });
+        (function () { return x_20 + y + v; });
+        if (x_20 == 1) {
+            return { value: undefined };
+        }
+    };
+    var v;
+    for (var y = 0; y < 1;) {
+        var state_20 = _loop_20(y);
+        if (typeof state_20 === "object") return state_20.value
+    }
+    use(v);
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop5.symbols b/tests/baselines/reference/capturedLetConstInLoop5.symbols
new file mode 100644
index 00000000000..2d514e8c88c
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop5.symbols
@@ -0,0 +1,682 @@
+=== tests/cases/compiler/capturedLetConstInLoop5.ts ===
+declare function use(a: any);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>a : Symbol(a, Decl(capturedLetConstInLoop5.ts, 0, 21))
+
+//====let
+function foo0(x) {
+>foo0 : Symbol(foo0, Decl(capturedLetConstInLoop5.ts, 0, 29))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 3, 14))
+
+    for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 4, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 5, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 4, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 4, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 5, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 4, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 5, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 4, 12))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 5, 11))
+}
+
+function foo00(x) {
+>foo00 : Symbol(foo00, Decl(capturedLetConstInLoop5.ts, 14, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 16, 15))
+
+    for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 17, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 18, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 17, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 17, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 18, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 17, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 18, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 17, 12))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 18, 11))
+}
+
+function foo1(x) {
+>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop5.ts, 27, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 29, 14))
+
+    for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 30, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 30, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 30, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 31, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 30, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 30, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 31, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 30, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 31, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 30, 12))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 31, 11))
+}
+
+function foo2(x) {
+>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop5.ts, 40, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 42, 14))
+
+    while (1 === 1) {
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 44, 11))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 45, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 44, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 44, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 45, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 44, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 45, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 44, 11))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 45, 11))
+}
+
+function foo3(x) {
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop5.ts, 54, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 56, 14))
+
+    do {
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 58, 11))
+
+        var v;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 59, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 58, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 59, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 58, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 59, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 58, 11))
+
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 59, 11))
+}
+
+function foo4(x) {
+>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop5.ts, 68, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 70, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 71, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 71, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 71, 12))
+
+        var v = y;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 72, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 71, 12))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 73, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 73, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 72, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 73, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 72, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 73, 11))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 72, 11))
+}
+
+function foo5(x) {
+>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop5.ts, 82, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 84, 14))
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 85, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 85, 19))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 85, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 85, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 86, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 85, 12))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 85, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 85, 19))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 86, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 85, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 85, 19))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 86, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 85, 12))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 86, 11))
+}
+
+
+function foo6(x) {
+>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop5.ts, 95, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 98, 14))
+
+    while (1 === 1) {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 100, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 100, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 101, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 100, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 100, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 100, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 101, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 100, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 100, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 101, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 100, 11))
+
+            return;
+        }
+    };
+    
+    use(v)
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 101, 11))
+}
+
+function foo7(x) {
+>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop5.ts, 110, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 112, 14))
+
+    do {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 114, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 114, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 115, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 114, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 114, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 114, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 115, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 114, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 114, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 115, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 114, 11))
+
+            return;
+        }
+    } while (1 === 1);
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 115, 11))
+}
+
+
+function foo8(x) {
+>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop5.ts, 124, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 127, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 128, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 128, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 128, 12))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 129, 11))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 130, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 129, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 129, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 128, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 130, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 129, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 128, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 130, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 129, 11))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 130, 11))
+}
+
+//====const
+function foo0_c(x) {
+>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop5.ts, 139, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 142, 16))
+
+    for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 143, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 144, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 143, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 143, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 144, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 143, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 144, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 143, 14))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 144, 11))
+}
+
+function foo00_c(x) {
+>foo00_c : Symbol(foo00_c, Decl(capturedLetConstInLoop5.ts, 153, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 155, 17))
+
+    for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 156, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 157, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 156, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 156, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 157, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 156, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 157, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 156, 14))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 157, 11))
+}
+
+function foo1_c(x) {
+>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop5.ts, 166, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 168, 16))
+
+    for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 169, 14))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 169, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 170, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 169, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 169, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 170, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 169, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 170, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 169, 14))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 170, 11))
+}
+
+function foo2_c(x) {
+>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop5.ts, 179, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 181, 16))
+
+    while (1 === 1) {
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 183, 13))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 184, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 183, 13))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 183, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 184, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 183, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 184, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 183, 13))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 184, 11))
+}
+
+function foo3_c(x) {
+>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop5.ts, 193, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 195, 16))
+
+    do {
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 197, 13))
+
+        var v;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 198, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 197, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 198, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 197, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 198, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 197, 13))
+
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 198, 11))
+}
+
+function foo4_c(x) {
+>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop5.ts, 207, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 209, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 210, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 210, 14))
+
+        var v = y;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 211, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 210, 14))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 212, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 212, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 211, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 212, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 211, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 212, 11))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 211, 11))
+}
+
+function foo5_c(x) {
+>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop5.ts, 221, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 223, 16))
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 224, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 224, 21))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 224, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 225, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 224, 14))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 224, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 224, 21))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 225, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 224, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 224, 21))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 225, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 224, 14))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 225, 11))
+}
+
+
+function foo6_c(x) {
+>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop5.ts, 234, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 237, 16))
+
+    while (1 === 1) {
+        const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 239, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 239, 20))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 240, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 239, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 239, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 239, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 240, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 239, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 239, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 240, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 239, 13))
+
+            return;
+        }
+    }
+    
+    use(v)
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 240, 11))
+}
+
+function foo7_c(x) {
+>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop5.ts, 249, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 251, 16))
+
+    do {
+        const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 253, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 253, 20))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 254, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 253, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 253, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 253, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 254, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 253, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 253, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 254, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 253, 13))
+
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 254, 11))
+}
+
+
+function foo8_c(x) {
+>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop5.ts, 263, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 266, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 267, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 267, 14))
+
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 268, 13))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 269, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 268, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 268, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 267, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 269, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 268, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5.ts, 267, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 269, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5.ts, 268, 13))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5.ts, 269, 11))
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop5.types b/tests/baselines/reference/capturedLetConstInLoop5.types
new file mode 100644
index 00000000000..3654ffe5820
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop5.types
@@ -0,0 +1,951 @@
+=== tests/cases/compiler/capturedLetConstInLoop5.ts ===
+declare function use(a: any);
+>use : (a: any) => any
+>a : any
+
+//====let
+function foo0(x) {
+>foo0 : (x: any) => void
+>x : any
+
+    for (let x of []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo00(x) {
+>foo00 : (x: any) => void
+>x : any
+
+    for (let x in []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo1(x) {
+>foo1 : (x: any) => void
+>x : any
+
+    for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo2(x) {
+>foo2 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo3(x) {
+>foo3 : (x: any) => void
+>x : any
+
+    do {
+        let x;
+>x : any
+
+        var v;
+>v : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo4(x) {
+>foo4 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        var v = y;
+>v : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo5(x) {
+>foo5 : (x: any) => void
+>x : any
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo6(x) {
+>foo6 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let x, y;
+>x : any
+>y : any
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => any
+>function() { return x + y + v } : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        (() => x + y + v);
+>(() => x + y + v) : () => any
+>() => x + y + v : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    };
+    
+    use(v)
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo7(x) {
+>foo7 : (x: any) => void
+>x : any
+
+    do {
+        let x, y;
+>x : any
+>y : any
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => any
+>function() { return x + y + v } : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        (() => x + y + v);
+>(() => x + y + v) : () => any
+>() => x + y + v : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    } while (1 === 1);
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+
+function foo8(x) {
+>foo8 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+//====const
+function foo0_c(x) {
+>foo0_c : (x: any) => void
+>x : any
+
+    for (const x of []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo00_c(x) {
+>foo00_c : (x: any) => void
+>x : any
+
+    for (const x in []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo1_c(x) {
+>foo1_c : (x: any) => void
+>x : any
+
+    for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo2_c(x) {
+>foo2_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo3_c(x) {
+>foo3_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1;
+>x : number
+>1 : number
+
+        var v;
+>v : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : number
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : number
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo4_c(x) {
+>foo4_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        var v = y;
+>v : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo5_c(x) {
+>foo5_c : (x: any) => void
+>x : any
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo6_c(x) {
+>foo6_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v)
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo7_c(x) {
+>foo7_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo8_c(x) {
+>foo8_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop5_ES6.js b/tests/baselines/reference/capturedLetConstInLoop5_ES6.js
new file mode 100644
index 00000000000..e5996bb3053
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop5_ES6.js
@@ -0,0 +1,518 @@
+//// [capturedLetConstInLoop5_ES6.ts]
+
+declare function use(a: any);
+
+//====let
+function foo0(x) {
+    for (let x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo00(x) {
+    for (let x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo3(x) {
+    do {
+        let x;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    };
+    
+    use(v)
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+//====const
+function foo0_c(x) {
+    for (const x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo00_c(x) {
+    for (const x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v)
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+//// [capturedLetConstInLoop5_ES6.js]
+//====let
+function foo0(x) {
+    for (let x of []) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo00(x) {
+    for (let x in []) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo2(x) {
+    while (1 === 1) {
+        let x = 1;
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo3(x) {
+    do {
+        let x;
+        var v;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1);
+    use(v);
+}
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        var v = y;
+        let x = 1;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    ;
+    use(v);
+}
+function foo7(x) {
+    do {
+        let x, y;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1);
+    use(v);
+}
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+//====const
+function foo0_c(x) {
+    for (const x of []) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo00_c(x) {
+    for (const x in []) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo2_c(x) {
+    while (1 === 1) {
+        const x = 1;
+        var v = x;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo3_c(x) {
+    do {
+        const x = 1;
+        var v;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1);
+    use(v);
+}
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        var v = y;
+        let x = 1;
+        (function () { return x + v; });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1);
+    use(v);
+}
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        var v = x;
+        (function () { return x + y + v; });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    use(v);
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop5_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop5_ES6.symbols
new file mode 100644
index 00000000000..b3d338ad60e
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop5_ES6.symbols
@@ -0,0 +1,683 @@
+=== tests/cases/compiler/capturedLetConstInLoop5_ES6.ts ===
+
+declare function use(a: any);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>a : Symbol(a, Decl(capturedLetConstInLoop5_ES6.ts, 1, 21))
+
+//====let
+function foo0(x) {
+>foo0 : Symbol(foo0, Decl(capturedLetConstInLoop5_ES6.ts, 1, 29))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 4, 14))
+
+    for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 5, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 6, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 5, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 5, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 6, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 5, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 6, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 5, 12))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 6, 11))
+}
+
+function foo00(x) {
+>foo00 : Symbol(foo00, Decl(capturedLetConstInLoop5_ES6.ts, 15, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 17, 15))
+
+    for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 18, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 19, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 18, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 18, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 19, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 18, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 19, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 18, 12))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 19, 11))
+}
+
+function foo1(x) {
+>foo1 : Symbol(foo1, Decl(capturedLetConstInLoop5_ES6.ts, 28, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 30, 14))
+
+    for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 32, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 32, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 32, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 31, 12))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 32, 11))
+}
+
+function foo2(x) {
+>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop5_ES6.ts, 41, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 43, 14))
+
+    while (1 === 1) {
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 46, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 46, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 46, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 45, 11))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 46, 11))
+}
+
+function foo3(x) {
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop5_ES6.ts, 55, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 57, 14))
+
+    do {
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11))
+
+        var v;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 60, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 60, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 60, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 59, 11))
+
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 60, 11))
+}
+
+function foo4(x) {
+>foo4 : Symbol(foo4, Decl(capturedLetConstInLoop5_ES6.ts, 69, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 71, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 72, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 72, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 72, 12))
+
+        var v = y;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 72, 12))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 74, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 74, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 74, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 74, 11))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 73, 11))
+}
+
+function foo5(x) {
+>foo5 : Symbol(foo5, Decl(capturedLetConstInLoop5_ES6.ts, 83, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 85, 14))
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 86, 19))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 87, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 86, 19))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 87, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 86, 19))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 87, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 86, 12))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 87, 11))
+}
+
+
+function foo6(x) {
+>foo6 : Symbol(foo6, Decl(capturedLetConstInLoop5_ES6.ts, 96, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 99, 14))
+
+    while (1 === 1) {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 101, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 102, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 101, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 102, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 101, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 102, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 101, 11))
+
+            return;
+        }
+    };
+    
+    use(v)
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 102, 11))
+}
+
+function foo7(x) {
+>foo7 : Symbol(foo7, Decl(capturedLetConstInLoop5_ES6.ts, 111, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 113, 14))
+
+    do {
+        let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 115, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 116, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 115, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 116, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 115, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 116, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 115, 11))
+
+            return;
+        }
+    } while (1 === 1);
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 116, 11))
+}
+
+
+function foo8(x) {
+>foo8 : Symbol(foo8, Decl(capturedLetConstInLoop5_ES6.ts, 125, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 128, 14))
+
+    for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 129, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 129, 12))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 129, 12))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 131, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 129, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 131, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 129, 12))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 131, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 130, 11))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 131, 11))
+}
+
+//====const
+function foo0_c(x) {
+>foo0_c : Symbol(foo0_c, Decl(capturedLetConstInLoop5_ES6.ts, 140, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 143, 16))
+
+    for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 144, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 145, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 144, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 144, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 145, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 144, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 145, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 144, 14))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 145, 11))
+}
+
+function foo00_c(x) {
+>foo00_c : Symbol(foo00_c, Decl(capturedLetConstInLoop5_ES6.ts, 154, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 156, 17))
+
+    for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 157, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 158, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 157, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 157, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 158, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 157, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 158, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 157, 14))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 158, 11))
+}
+
+function foo1_c(x) {
+>foo1_c : Symbol(foo1_c, Decl(capturedLetConstInLoop5_ES6.ts, 167, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 169, 16))
+
+    for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 171, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 171, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 171, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 170, 14))
+
+            return;
+        }
+    }
+
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 171, 11))
+}
+
+function foo2_c(x) {
+>foo2_c : Symbol(foo2_c, Decl(capturedLetConstInLoop5_ES6.ts, 180, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 182, 16))
+
+    while (1 === 1) {
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 184, 13))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 185, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 184, 13))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 184, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 185, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 184, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 185, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 184, 13))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 185, 11))
+}
+
+function foo3_c(x) {
+>foo3_c : Symbol(foo3_c, Decl(capturedLetConstInLoop5_ES6.ts, 194, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 196, 16))
+
+    do {
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 198, 13))
+
+        var v;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 199, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 198, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 199, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 198, 13))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 199, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 198, 13))
+
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 199, 11))
+}
+
+function foo4_c(x) {
+>foo4_c : Symbol(foo4_c, Decl(capturedLetConstInLoop5_ES6.ts, 208, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 210, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 211, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 211, 14))
+
+        var v = y;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 211, 14))
+
+        let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 213, 11))
+
+        (function() { return x + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 213, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11))
+
+        (() => x + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 213, 11))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 213, 11))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 212, 11))
+}
+
+function foo5_c(x) {
+>foo5_c : Symbol(foo5_c, Decl(capturedLetConstInLoop5_ES6.ts, 222, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 224, 16))
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 225, 21))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 226, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 225, 21))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 226, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 225, 21))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 226, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 225, 14))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 226, 11))
+}
+
+
+function foo6_c(x) {
+>foo6_c : Symbol(foo6_c, Decl(capturedLetConstInLoop5_ES6.ts, 235, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 238, 16))
+
+    while (1 === 1) {
+        const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 240, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 240, 20))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 241, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 240, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 240, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 240, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 241, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 240, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 240, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 241, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 240, 13))
+
+            return;
+        }
+    }
+    
+    use(v)
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 241, 11))
+}
+
+function foo7_c(x) {
+>foo7_c : Symbol(foo7_c, Decl(capturedLetConstInLoop5_ES6.ts, 250, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 252, 16))
+
+    do {
+        const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 254, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 254, 20))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 255, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 254, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 254, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 254, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 255, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 254, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 254, 20))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 255, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 254, 13))
+
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 255, 11))
+}
+
+
+function foo8_c(x) {
+>foo8_c : Symbol(foo8_c, Decl(capturedLetConstInLoop5_ES6.ts, 264, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 267, 16))
+
+    for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 268, 14))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 268, 14))
+
+        const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 269, 13))
+
+        var v = x;
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 270, 11))
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 269, 13))
+
+        (function() { return x + y + v });
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 269, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 268, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 270, 11))
+
+        (() => x + y + v);
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 269, 13))
+>y : Symbol(y, Decl(capturedLetConstInLoop5_ES6.ts, 268, 14))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 270, 11))
+
+        if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop5_ES6.ts, 269, 13))
+
+            return;
+        }
+    }
+    
+    use(v);
+>use : Symbol(use, Decl(capturedLetConstInLoop5_ES6.ts, 0, 0))
+>v : Symbol(v, Decl(capturedLetConstInLoop5_ES6.ts, 270, 11))
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop5_ES6.types b/tests/baselines/reference/capturedLetConstInLoop5_ES6.types
new file mode 100644
index 00000000000..8db8ae25e9b
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop5_ES6.types
@@ -0,0 +1,952 @@
+=== tests/cases/compiler/capturedLetConstInLoop5_ES6.ts ===
+
+declare function use(a: any);
+>use : (a: any) => any
+>a : any
+
+//====let
+function foo0(x) {
+>foo0 : (x: any) => void
+>x : any
+
+    for (let x of []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo00(x) {
+>foo00 : (x: any) => void
+>x : any
+
+    for (let x in []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo1(x) {
+>foo1 : (x: any) => void
+>x : any
+
+    for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo2(x) {
+>foo2 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo3(x) {
+>foo3 : (x: any) => void
+>x : any
+
+    do {
+        let x;
+>x : any
+
+        var v;
+>v : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo4(x) {
+>foo4 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        var v = y;
+>v : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo5(x) {
+>foo5 : (x: any) => void
+>x : any
+
+    for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo6(x) {
+>foo6 : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        let x, y;
+>x : any
+>y : any
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => any
+>function() { return x + y + v } : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        (() => x + y + v);
+>(() => x + y + v) : () => any
+>() => x + y + v : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    };
+    
+    use(v)
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo7(x) {
+>foo7 : (x: any) => void
+>x : any
+
+    do {
+        let x, y;
+>x : any
+>y : any
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => any
+>function() { return x + y + v } : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        (() => x + y + v);
+>(() => x + y + v) : () => any
+>() => x + y + v : () => any
+>x + y + v : any
+>x + y : any
+>x : any
+>y : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    } while (1 === 1);
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+
+function foo8(x) {
+>foo8 : (x: any) => void
+>x : any
+
+    for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+//====const
+function foo0_c(x) {
+>foo0_c : (x: any) => void
+>x : any
+
+    for (const x of []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo00_c(x) {
+>foo00_c : (x: any) => void
+>x : any
+
+    for (const x in []) {
+>x : any
+>[] : undefined[]
+
+        var v = x;
+>v : any
+>x : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : any
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : any
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo1_c(x) {
+>foo1_c : (x: any) => void
+>x : any
+
+    for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo2_c(x) {
+>foo2_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo3_c(x) {
+>foo3_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1;
+>x : number
+>1 : number
+
+        var v;
+>v : any
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => any
+>function() { return x + v } : () => any
+>x + v : any
+>x : number
+>v : any
+
+        (() => x + v);
+>(() => x + v) : () => any
+>() => x + v : () => any
+>x + v : any
+>x : number
+>v : any
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : any
+}
+
+function foo4_c(x) {
+>foo4_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        var v = y;
+>v : number
+>y : number
+
+        let x = 1;
+>x : number
+>1 : number
+
+        (function() { return x + v });
+>(function() { return x + v }) : () => number
+>function() { return x + v } : () => number
+>x + v : number
+>x : number
+>v : number
+
+        (() => x + v);
+>(() => x + v) : () => number
+>() => x + v : () => number
+>x + v : number
+>x : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo5_c(x) {
+>foo5_c : (x: any) => void
+>x : any
+
+    for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo6_c(x) {
+>foo6_c : (x: any) => void
+>x : any
+
+    while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+        const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v)
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+function foo7_c(x) {
+>foo7_c : (x: any) => void
+>x : any
+
+    do {
+        const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    } while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
+
+
+function foo8_c(x) {
+>foo8_c : (x: any) => void
+>x : any
+
+    for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+        const x = 1;
+>x : number
+>1 : number
+
+        var v = x;
+>v : number
+>x : number
+
+        (function() { return x + y + v });
+>(function() { return x + y + v }) : () => number
+>function() { return x + y + v } : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        (() => x + y + v);
+>(() => x + y + v) : () => number
+>() => x + y + v : () => number
+>x + y + v : number
+>x + y : number
+>x : number
+>y : number
+>v : number
+
+        if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+            return;
+        }
+    }
+    
+    use(v);
+>use(v) : any
+>use : (a: any) => any
+>v : number
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop6.js b/tests/baselines/reference/capturedLetConstInLoop6.js
new file mode 100644
index 00000000000..187d9f10ad3
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop6.js
@@ -0,0 +1,557 @@
+//// [capturedLetConstInLoop6.ts]
+// ====let
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (let x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+// ====const
+
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (const x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+
+
+//// [capturedLetConstInLoop6.js]
+// ====let
+var _loop_1 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var _i = 0, _a = []; _i < _a.length; _i++) {
+    var x = _a[_i];
+    var state_1 = _loop_1(x);
+    if (state_1 === "break") break;
+    if (state_1 === "continue") continue;
+}
+var _loop_2 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var x in []) {
+    var state_2 = _loop_2(x);
+    if (state_2 === "break") break;
+    if (state_2 === "continue") continue;
+}
+var _loop_3 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var x = 0; x < 1; ++x) {
+    var state_3 = _loop_3(x);
+    if (state_3 === "break") break;
+    if (state_3 === "continue") continue;
+}
+var _loop_4 = function() {
+    var x = void 0;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+while (1 === 1) {
+    var state_4 = _loop_4();
+    if (state_4 === "break") break;
+    if (state_4 === "continue") continue;
+}
+var _loop_5 = function() {
+    var x = void 0;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+do {
+    var state_5 = _loop_5();
+    if (state_5 === "break") break;
+    if (state_5 === "continue") continue;
+} while (1 === 1);
+var _loop_6 = function(y) {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var y = 0; y < 1; ++y) {
+    var state_6 = _loop_6(y);
+    if (state_6 === "break") break;
+    if (state_6 === "continue") continue;
+}
+var _loop_7 = function(x, y) {
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var x = 0, y = 1; x < 1; ++x) {
+    var state_7 = _loop_7(x, y);
+    if (state_7 === "break") break;
+    if (state_7 === "continue") continue;
+}
+var _loop_8 = function() {
+    var x = void 0, y = void 0;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+while (1 === 1) {
+    var state_8 = _loop_8();
+    if (state_8 === "break") break;
+    if (state_8 === "continue") continue;
+}
+var _loop_9 = function() {
+    var x = void 0, y = void 0;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+do {
+    var state_9 = _loop_9();
+    if (state_9 === "break") break;
+    if (state_9 === "continue") continue;
+} while (1 === 1);
+var _loop_10 = function(y) {
+    var x = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var y = 0; y < 1; ++y) {
+    var state_10 = _loop_10(y);
+    if (state_10 === "break") break;
+    if (state_10 === "continue") continue;
+}
+// ====const
+var _loop_11 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var _b = 0, _c = []; _b < _c.length; _b++) {
+    var x = _c[_b];
+    var state_11 = _loop_11(x);
+    if (state_11 === "break") break;
+    if (state_11 === "continue") continue;
+}
+var _loop_12 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var x in []) {
+    var state_12 = _loop_12(x);
+    if (state_12 === "break") break;
+    if (state_12 === "continue") continue;
+}
+var _loop_13 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var x = 0; x < 1;) {
+    var state_13 = _loop_13(x);
+    if (state_13 === "break") break;
+    if (state_13 === "continue") continue;
+}
+var _loop_14 = function() {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+while (1 === 1) {
+    var state_14 = _loop_14();
+    if (state_14 === "break") break;
+    if (state_14 === "continue") continue;
+}
+var _loop_15 = function() {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+do {
+    var state_15 = _loop_15();
+    if (state_15 === "break") break;
+    if (state_15 === "continue") continue;
+} while (1 === 1);
+var _loop_16 = function(y) {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var y = 0; y < 1;) {
+    var state_16 = _loop_16(y);
+    if (state_16 === "break") break;
+    if (state_16 === "continue") continue;
+}
+var _loop_17 = function(x, y) {
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var x = 0, y = 1; x < 1;) {
+    var state_17 = _loop_17(x, y);
+    if (state_17 === "break") break;
+    if (state_17 === "continue") continue;
+}
+var _loop_18 = function() {
+    var x = 1, y = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+while (1 === 1) {
+    var state_18 = _loop_18();
+    if (state_18 === "break") break;
+    if (state_18 === "continue") continue;
+}
+var _loop_19 = function() {
+    var x = 1, y = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+do {
+    var state_19 = _loop_19();
+    if (state_19 === "break") break;
+    if (state_19 === "continue") continue;
+} while (1 === 1);
+var _loop_20 = function(y) {
+    var x = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+};
+for (var y = 0; y < 1;) {
+    var state_20 = _loop_20(y);
+    if (state_20 === "break") break;
+    if (state_20 === "continue") continue;
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop6.symbols b/tests/baselines/reference/capturedLetConstInLoop6.symbols
new file mode 100644
index 00000000000..8d8e6d6ce59
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop6.symbols
@@ -0,0 +1,481 @@
+=== tests/cases/compiler/capturedLetConstInLoop6.ts ===
+// ====let
+for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 1, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 1, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 1, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 1, 8))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 1, 8))
+
+        continue;
+    }
+}
+
+for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 12, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 12, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 12, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 12, 8))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 12, 8))
+
+        continue;
+    }
+}
+
+
+for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 24, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 24, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 24, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 24, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 24, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 24, 8))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 24, 8))
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 36, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 36, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 36, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 36, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 36, 7))
+
+        continue;
+    }
+}
+
+do {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 48, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 48, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 48, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 48, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 48, 7))
+
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 59, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 59, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 59, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 60, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 60, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 60, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 60, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 60, 7))
+
+        continue;
+    }
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 71, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 71, 15))
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 71, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 71, 8))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 71, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 71, 15))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 71, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 71, 15))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 71, 8))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 71, 8))
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 83, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 83, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 83, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 83, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 83, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 83, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 83, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 83, 7))
+
+        continue;
+    }
+}
+
+do {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 95, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 95, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 95, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 95, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 95, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 95, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 95, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 95, 7))
+
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 106, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 106, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 106, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 107, 7))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 107, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 106, 8))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 107, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 106, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 107, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 107, 7))
+
+        continue;
+    }
+}
+
+// ====const
+
+for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 120, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 120, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 120, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 120, 10))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 120, 10))
+
+        continue;
+    }
+}
+
+for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 131, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 131, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 131, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 131, 10))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 131, 10))
+
+        continue;
+    }
+}
+
+
+for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 143, 10))
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 143, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 143, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 143, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 143, 10))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 143, 10))
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 155, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 155, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 155, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 155, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 155, 9))
+
+        continue;
+    }
+}
+
+do {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 167, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 167, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 167, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 167, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 167, 9))
+
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 178, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 178, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 179, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 179, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 179, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 179, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 179, 9))
+
+        continue;
+    }
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 190, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 190, 17))
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 190, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 190, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 190, 17))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 190, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 190, 17))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 190, 10))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 190, 10))
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 202, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 202, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 202, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 202, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 202, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 202, 16))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 202, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 202, 9))
+
+        continue;
+    }
+}
+
+do {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 214, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 214, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 214, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 214, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 214, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 214, 16))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 214, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 214, 9))
+
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 225, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 225, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 226, 9))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 226, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 225, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 226, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6.ts, 225, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 226, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6.ts, 226, 9))
+
+        continue;
+    }
+}
+
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop6.types b/tests/baselines/reference/capturedLetConstInLoop6.types
new file mode 100644
index 00000000000..6c31bdef31b
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop6.types
@@ -0,0 +1,729 @@
+=== tests/cases/compiler/capturedLetConstInLoop6.ts ===
+// ====let
+for (let x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+for (let x in []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+
+for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+do {
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+do {
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+// ====const
+
+for (const x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+for (const x in []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+
+for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+do {
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+do {
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop6_ES6.js b/tests/baselines/reference/capturedLetConstInLoop6_ES6.js
new file mode 100644
index 00000000000..924f55b6915
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop6_ES6.js
@@ -0,0 +1,455 @@
+//// [capturedLetConstInLoop6_ES6.ts]
+// ====let
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (let x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+// ====const
+
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (const x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+
+
+//// [capturedLetConstInLoop6_ES6.js]
+// ====let
+for (let x of []) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+for (let x in []) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+for (let x = 0; x < 1; ++x) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+while (1 === 1) {
+    let x;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+do {
+    let x;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1);
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+while (1 === 1) {
+    let x, y;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+do {
+    let x, y;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1);
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+// ====const
+for (const x of []) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+for (const x in []) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+for (const x = 0; x < 1;) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+while (1 === 1) {
+    const x = 1;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+do {
+    const x = 1;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1);
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+for (const x = 0, y = 1; x < 1;) {
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+do {
+    const x = 1, y = 1;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1);
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop6_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop6_ES6.symbols
new file mode 100644
index 00000000000..acd557e4714
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop6_ES6.symbols
@@ -0,0 +1,481 @@
+=== tests/cases/compiler/capturedLetConstInLoop6_ES6.ts ===
+// ====let
+for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 1, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 1, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 1, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 1, 8))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 1, 8))
+
+        continue;
+    }
+}
+
+for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 12, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 12, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 12, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 12, 8))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 12, 8))
+
+        continue;
+    }
+}
+
+
+for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 24, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 24, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 24, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 24, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 24, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 24, 8))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 24, 8))
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 36, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 36, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 36, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 36, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 36, 7))
+
+        continue;
+    }
+}
+
+do {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 48, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 48, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 48, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 48, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 48, 7))
+
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 59, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 59, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 59, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 60, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 60, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 60, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 60, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 60, 7))
+
+        continue;
+    }
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 71, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 71, 15))
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 71, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 71, 8))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 71, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 71, 15))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 71, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 71, 15))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 71, 8))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 71, 8))
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 83, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 83, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 83, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 83, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 83, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 83, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 83, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 83, 7))
+
+        continue;
+    }
+}
+
+do {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 95, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 95, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 95, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 95, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 95, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 95, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 95, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 95, 7))
+
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 106, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 106, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 106, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 107, 7))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 107, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 106, 8))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 107, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 106, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 107, 7))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 107, 7))
+
+        continue;
+    }
+}
+
+// ====const
+
+for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 120, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 120, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 120, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 120, 10))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 120, 10))
+
+        continue;
+    }
+}
+
+for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 131, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 131, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 131, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 131, 10))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 131, 10))
+
+        continue;
+    }
+}
+
+
+for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 143, 10))
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 143, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 143, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 143, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 143, 10))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 143, 10))
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 155, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 155, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 155, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 155, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 155, 9))
+
+        continue;
+    }
+}
+
+do {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 167, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 167, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 167, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 167, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 167, 9))
+
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 178, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 178, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 179, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 179, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 179, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 179, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 179, 9))
+
+        continue;
+    }
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 190, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 190, 17))
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 190, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 190, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 190, 17))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 190, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 190, 17))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 190, 10))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 190, 10))
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 202, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 202, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 202, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 202, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 202, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 202, 16))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 202, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 202, 9))
+
+        continue;
+    }
+}
+
+do {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 214, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 214, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 214, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 214, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 214, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 214, 16))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 214, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 214, 9))
+
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 225, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 225, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 226, 9))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 226, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 225, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 226, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop6_ES6.ts, 225, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 226, 9))
+
+        break;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop6_ES6.ts, 226, 9))
+
+        continue;
+    }
+}
+
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop6_ES6.types b/tests/baselines/reference/capturedLetConstInLoop6_ES6.types
new file mode 100644
index 00000000000..87f21709120
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop6_ES6.types
@@ -0,0 +1,729 @@
+=== tests/cases/compiler/capturedLetConstInLoop6_ES6.ts ===
+// ====let
+for (let x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+for (let x in []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+
+for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+do {
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+do {
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+// ====const
+
+for (const x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+for (const x in []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+}
+
+
+for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+do {
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+do {
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+}
+
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop7.js b/tests/baselines/reference/capturedLetConstInLoop7.js
new file mode 100644
index 00000000000..ce6769d2b1a
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop7.js
@@ -0,0 +1,894 @@
+//// [capturedLetConstInLoop7.ts]
+//===let
+l0:
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l0;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l0;
+    }
+}
+
+l00:
+for (let x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l00;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l00;
+    }
+}
+
+l1:
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l1;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l1;
+    }
+}
+
+l2:
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l2;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l2;
+    }
+}
+
+l3:
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l3;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l3;
+    }
+} while (1 === 1)
+
+l4:
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l4;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l4;
+    }
+}
+
+l5:
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l5;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l5;
+    }
+}
+
+l6:
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l6;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l6;
+    }
+
+}
+
+l7:
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l7;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l7;
+    }
+} while (1 === 1)
+
+l8:
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l8;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l8;
+    }
+}
+
+//===const
+l0_c:
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l0_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l0_c;
+    }
+}
+
+l00_c:
+for (const x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l00_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l00_c;
+    }
+}
+
+l1_c:
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l1_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l1_c;
+    }
+}
+
+l2_c:
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l2_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l2_c;
+    }
+}
+
+l3_c:
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l3_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l3_c;
+    }
+} while (1 === 1)
+
+l4_c:
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l4_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l4_c;
+    }
+}
+
+l5_c:
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l5_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l5_c;
+    }
+}
+
+l6_c:
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l6_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l6_c;
+    }
+
+}
+
+l7_c:
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l7_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l7_c;
+    }
+} while (1 === 1)
+
+l8_c:
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l8_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l8_c;
+    }
+}
+
+//// [capturedLetConstInLoop7.js]
+//===let
+var _loop_1 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l0";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l0";
+    }
+};
+l0: for (var _i = 0, _a = []; _i < _a.length; _i++) {
+    var x = _a[_i];
+    var state_1 = _loop_1(x);
+    if (state_1 === "break") break;
+    if (state_1 === "continue") continue;
+    switch(state_1) {
+        case "break-l0": break l0;
+        case "continue-l0": continue l0;
+    }
+}
+var _loop_2 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l00";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l00";
+    }
+};
+l00: for (var x in []) {
+    var state_2 = _loop_2(x);
+    if (state_2 === "break") break;
+    if (state_2 === "continue") continue;
+    switch(state_2) {
+        case "break-l00": break l00;
+        case "continue-l00": continue l00;
+    }
+}
+var _loop_3 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l1";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l1";
+    }
+};
+l1: for (var x = 0; x < 1; ++x) {
+    var state_3 = _loop_3(x);
+    if (state_3 === "break") break;
+    if (state_3 === "continue") continue;
+    switch(state_3) {
+        case "break-l1": break l1;
+        case "continue-l1": continue l1;
+    }
+}
+var _loop_4 = function() {
+    var x = void 0;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l2";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l2";
+    }
+};
+l2: while (1 === 1) {
+    var state_4 = _loop_4();
+    if (state_4 === "break") break;
+    if (state_4 === "continue") continue;
+    switch(state_4) {
+        case "break-l2": break l2;
+        case "continue-l2": continue l2;
+    }
+}
+var _loop_5 = function() {
+    var x = void 0;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l3";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l3";
+    }
+};
+l3: do {
+    var state_5 = _loop_5();
+    if (state_5 === "break") break;
+    if (state_5 === "continue") continue;
+    switch(state_5) {
+        case "break-l3": break l3;
+        case "continue-l3": continue l3;
+    }
+} while (1 === 1);
+var _loop_6 = function(y) {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l4";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l4";
+    }
+};
+l4: for (var y = 0; y < 1; ++y) {
+    var state_6 = _loop_6(y);
+    if (state_6 === "break") break;
+    if (state_6 === "continue") continue;
+    switch(state_6) {
+        case "break-l4": break l4;
+        case "continue-l4": continue l4;
+    }
+}
+var _loop_7 = function(x, y) {
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l5";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l5";
+    }
+};
+l5: for (var x = 0, y = 1; x < 1; ++x) {
+    var state_7 = _loop_7(x, y);
+    if (state_7 === "break") break;
+    if (state_7 === "continue") continue;
+    switch(state_7) {
+        case "break-l5": break l5;
+        case "continue-l5": continue l5;
+    }
+}
+var _loop_8 = function() {
+    var x = void 0, y = void 0;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l6";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l6";
+    }
+};
+l6: while (1 === 1) {
+    var state_8 = _loop_8();
+    if (state_8 === "break") break;
+    if (state_8 === "continue") continue;
+    switch(state_8) {
+        case "break-l6": break l6;
+        case "continue-l6": continue l6;
+    }
+}
+var _loop_9 = function() {
+    var x = void 0, y = void 0;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l7";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l7";
+    }
+};
+l7: do {
+    var state_9 = _loop_9();
+    if (state_9 === "break") break;
+    if (state_9 === "continue") continue;
+    switch(state_9) {
+        case "break-l7": break l7;
+        case "continue-l7": continue l7;
+    }
+} while (1 === 1);
+var _loop_10 = function(y) {
+    var x = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l8";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l8";
+    }
+};
+l8: for (var y = 0; y < 1; ++y) {
+    var state_10 = _loop_10(y);
+    if (state_10 === "break") break;
+    if (state_10 === "continue") continue;
+    switch(state_10) {
+        case "break-l8": break l8;
+        case "continue-l8": continue l8;
+    }
+}
+//===const
+var _loop_11 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l0_c";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l0_c";
+    }
+};
+l0_c: for (var _b = 0, _c = []; _b < _c.length; _b++) {
+    var x = _c[_b];
+    var state_11 = _loop_11(x);
+    if (state_11 === "break") break;
+    if (state_11 === "continue") continue;
+    switch(state_11) {
+        case "break-l0_c": break l0_c;
+        case "continue-l0_c": continue l0_c;
+    }
+}
+var _loop_12 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l00_c";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l00_c";
+    }
+};
+l00_c: for (var x in []) {
+    var state_12 = _loop_12(x);
+    if (state_12 === "break") break;
+    if (state_12 === "continue") continue;
+    switch(state_12) {
+        case "break-l00_c": break l00_c;
+        case "continue-l00_c": continue l00_c;
+    }
+}
+var _loop_13 = function(x) {
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l1_c";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l1_c";
+    }
+};
+l1_c: for (var x = 0; x < 1;) {
+    var state_13 = _loop_13(x);
+    if (state_13 === "break") break;
+    if (state_13 === "continue") continue;
+    switch(state_13) {
+        case "break-l1_c": break l1_c;
+        case "continue-l1_c": continue l1_c;
+    }
+}
+var _loop_14 = function() {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l2_c";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l2_c";
+    }
+};
+l2_c: while (1 === 1) {
+    var state_14 = _loop_14();
+    if (state_14 === "break") break;
+    if (state_14 === "continue") continue;
+    switch(state_14) {
+        case "break-l2_c": break l2_c;
+        case "continue-l2_c": continue l2_c;
+    }
+}
+var _loop_15 = function() {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l3_c";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l3_c";
+    }
+};
+l3_c: do {
+    var state_15 = _loop_15();
+    if (state_15 === "break") break;
+    if (state_15 === "continue") continue;
+    switch(state_15) {
+        case "break-l3_c": break l3_c;
+        case "continue-l3_c": continue l3_c;
+    }
+} while (1 === 1);
+var _loop_16 = function(y) {
+    var x = 1;
+    (function () { return x; });
+    (function () { return x; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l4_c";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l4_c";
+    }
+};
+l4_c: for (var y = 0; y < 1;) {
+    var state_16 = _loop_16(y);
+    if (state_16 === "break") break;
+    if (state_16 === "continue") continue;
+    switch(state_16) {
+        case "break-l4_c": break l4_c;
+        case "continue-l4_c": continue l4_c;
+    }
+}
+var _loop_17 = function(x, y) {
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l5_c";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l5_c";
+    }
+};
+l5_c: for (var x = 0, y = 1; x < 1;) {
+    var state_17 = _loop_17(x, y);
+    if (state_17 === "break") break;
+    if (state_17 === "continue") continue;
+    switch(state_17) {
+        case "break-l5_c": break l5_c;
+        case "continue-l5_c": continue l5_c;
+    }
+}
+var _loop_18 = function() {
+    var x = 1, y = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l6_c";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l6_c";
+    }
+};
+l6_c: while (1 === 1) {
+    var state_18 = _loop_18();
+    if (state_18 === "break") break;
+    if (state_18 === "continue") continue;
+    switch(state_18) {
+        case "break-l6_c": break l6_c;
+        case "continue-l6_c": continue l6_c;
+    }
+}
+var _loop_19 = function() {
+    var x = 1, y = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l7_c";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l7_c";
+    }
+};
+l7_c: do {
+    var state_19 = _loop_19();
+    if (state_19 === "break") break;
+    if (state_19 === "continue") continue;
+    switch(state_19) {
+        case "break-l7_c": break l7_c;
+        case "continue-l7_c": continue l7_c;
+    }
+} while (1 === 1);
+var _loop_20 = function(y) {
+    var x = 1;
+    (function () { return x + y; });
+    (function () { return x + y; });
+    if (x == 1) {
+        return "break";
+    }
+    if (x == 1) {
+        return "break-l8_c";
+    }
+    if (x == 2) {
+        return "continue";
+    }
+    if (x == 2) {
+        return "continue-l8_c";
+    }
+};
+l8_c: for (var y = 0; y < 1;) {
+    var state_20 = _loop_20(y);
+    if (state_20 === "break") break;
+    if (state_20 === "continue") continue;
+    switch(state_20) {
+        case "break-l8_c": break l8_c;
+        case "continue-l8_c": continue l8_c;
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop7.symbols b/tests/baselines/reference/capturedLetConstInLoop7.symbols
new file mode 100644
index 00000000000..2aa5ec2cd38
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop7.symbols
@@ -0,0 +1,698 @@
+=== tests/cases/compiler/capturedLetConstInLoop7.ts ===
+//===let
+l0:
+for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 2, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 2, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 2, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 2, 8))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 2, 8))
+
+        break l0;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 2, 8))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 2, 8))
+
+        continue l0;
+    }
+}
+
+l00:
+for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 20, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 20, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 20, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 20, 8))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 20, 8))
+
+        break l00;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 20, 8))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 20, 8))
+
+        continue l00;
+    }
+}
+
+l1:
+for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 38, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 38, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 38, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 38, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 38, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 38, 8))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 38, 8))
+
+        break l1;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 38, 8))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 38, 8))
+
+        continue l1;
+    }
+}
+
+l2:
+while (1 === 1) {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 57, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 57, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 57, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 57, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 57, 7))
+
+        break l2;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 57, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 57, 7))
+
+        continue l2;
+    }
+}
+
+l3:
+do {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 76, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 76, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 76, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 76, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 76, 7))
+
+        break l3;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 76, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 76, 7))
+
+        continue l3;
+    }
+} while (1 === 1)
+
+l4:
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 94, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 94, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 94, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 95, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 95, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 95, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 95, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 95, 7))
+
+        break l4;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 95, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 95, 7))
+
+        continue l4;
+    }
+}
+
+l5:
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 113, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 113, 15))
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 113, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 113, 8))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 113, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 113, 15))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 113, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 113, 15))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 113, 8))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 113, 8))
+
+        break l5;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 113, 8))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 113, 8))
+
+        continue l5;
+    }
+}
+
+l6:
+while (1 === 1) {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 132, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 132, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 132, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 132, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 132, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 132, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 132, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 132, 7))
+
+        break l6;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 132, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 132, 7))
+
+        continue l6;
+    }
+
+}
+
+l7:
+do {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 152, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 152, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 152, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 152, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 152, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 152, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 152, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 152, 7))
+
+        break l7;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 152, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 152, 7))
+
+        continue l7;
+    }
+} while (1 === 1)
+
+l8:
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 170, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 170, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 170, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 171, 7))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 171, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 170, 8))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 171, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 170, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 171, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 171, 7))
+
+        break l8;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 171, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 171, 7))
+
+        continue l8;
+    }
+}
+
+//===const
+l0_c:
+for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 190, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 190, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 190, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 190, 10))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 190, 10))
+
+        break l0_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 190, 10))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 190, 10))
+
+        continue l0_c;
+    }
+}
+
+l00_c:
+for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 208, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 208, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 208, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 208, 10))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 208, 10))
+
+        break l00_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 208, 10))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 208, 10))
+
+        continue l00_c;
+    }
+}
+
+l1_c:
+for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 226, 10))
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 226, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 226, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 226, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 226, 10))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 226, 10))
+
+        break l1_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 226, 10))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 226, 10))
+
+        continue l1_c;
+    }
+}
+
+l2_c:
+while (1 === 1) {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 245, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 245, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 245, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 245, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 245, 9))
+
+        break l2_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 245, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 245, 9))
+
+        continue l2_c;
+    }
+}
+
+l3_c:
+do {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 264, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 264, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 264, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 264, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 264, 9))
+
+        break l3_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 264, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 264, 9))
+
+        continue l3_c;
+    }
+} while (1 === 1)
+
+l4_c:
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 282, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 282, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 283, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 283, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 283, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 283, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 283, 9))
+
+        break l4_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 283, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 283, 9))
+
+        continue l4_c;
+    }
+}
+
+l5_c:
+for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 301, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 301, 17))
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 301, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 301, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 301, 17))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 301, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 301, 17))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 301, 10))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 301, 10))
+
+        break l5_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 301, 10))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 301, 10))
+
+        continue l5_c;
+    }
+}
+
+l6_c:
+while (1 === 1) {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 320, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 320, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 320, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 320, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 320, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 320, 16))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 320, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 320, 9))
+
+        break l6_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 320, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 320, 9))
+
+        continue l6_c;
+    }
+
+}
+
+l7_c:
+do {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 340, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 340, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 340, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 340, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 340, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 340, 16))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 340, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 340, 9))
+
+        break l7_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 340, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 340, 9))
+
+        continue l7_c;
+    }
+} while (1 === 1)
+
+l8_c:
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 358, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 358, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 359, 9))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 359, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 358, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 359, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7.ts, 358, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 359, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 359, 9))
+
+        break l8_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 359, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7.ts, 359, 9))
+
+        continue l8_c;
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop7.types b/tests/baselines/reference/capturedLetConstInLoop7.types
new file mode 100644
index 00000000000..280985eae0f
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop7.types
@@ -0,0 +1,1106 @@
+=== tests/cases/compiler/capturedLetConstInLoop7.ts ===
+//===let
+l0:
+>l0 : any
+
+for (let x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l0;
+>l0 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l0;
+>l0 : any
+    }
+}
+
+l00:
+>l00 : any
+
+for (let x in []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l00;
+>l00 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l00;
+>l00 : any
+    }
+}
+
+l1:
+>l1 : any
+
+for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l1;
+>l1 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l1;
+>l1 : any
+    }
+}
+
+l2:
+>l2 : any
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l2;
+>l2 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l2;
+>l2 : any
+    }
+}
+
+l3:
+>l3 : any
+
+do {
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l3;
+>l3 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l3;
+>l3 : any
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+l4:
+>l4 : any
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l4;
+>l4 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l4;
+>l4 : any
+    }
+}
+
+l5:
+>l5 : any
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l5;
+>l5 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l5;
+>l5 : any
+    }
+}
+
+l6:
+>l6 : any
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l6;
+>l6 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l6;
+>l6 : any
+    }
+
+}
+
+l7:
+>l7 : any
+
+do {
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l7;
+>l7 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l7;
+>l7 : any
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+l8:
+>l8 : any
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l8;
+>l8 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l8;
+>l8 : any
+    }
+}
+
+//===const
+l0_c:
+>l0_c : any
+
+for (const x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l0_c;
+>l0_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l0_c;
+>l0_c : any
+    }
+}
+
+l00_c:
+>l00_c : any
+
+for (const x in []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l00_c;
+>l00_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l00_c;
+>l00_c : any
+    }
+}
+
+l1_c:
+>l1_c : any
+
+for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l1_c;
+>l1_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l1_c;
+>l1_c : any
+    }
+}
+
+l2_c:
+>l2_c : any
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l2_c;
+>l2_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l2_c;
+>l2_c : any
+    }
+}
+
+l3_c:
+>l3_c : any
+
+do {
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l3_c;
+>l3_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l3_c;
+>l3_c : any
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+l4_c:
+>l4_c : any
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l4_c;
+>l4_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l4_c;
+>l4_c : any
+    }
+}
+
+l5_c:
+>l5_c : any
+
+for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l5_c;
+>l5_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l5_c;
+>l5_c : any
+    }
+}
+
+l6_c:
+>l6_c : any
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l6_c;
+>l6_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l6_c;
+>l6_c : any
+    }
+
+}
+
+l7_c:
+>l7_c : any
+
+do {
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l7_c;
+>l7_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l7_c;
+>l7_c : any
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+l8_c:
+>l8_c : any
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l8_c;
+>l8_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l8_c;
+>l8_c : any
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop7_ES6.js b/tests/baselines/reference/capturedLetConstInLoop7_ES6.js
new file mode 100644
index 00000000000..4a2db640081
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop7_ES6.js
@@ -0,0 +1,712 @@
+//// [capturedLetConstInLoop7_ES6.ts]
+//===let
+l0:
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l0;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l0;
+    }
+}
+
+l00:
+for (let x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l00;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l00;
+    }
+}
+
+l1:
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l1;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l1;
+    }
+}
+
+l2:
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l2;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l2;
+    }
+}
+
+l3:
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l3;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l3;
+    }
+} while (1 === 1)
+
+l4:
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l4;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l4;
+    }
+}
+
+l5:
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l5;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l5;
+    }
+}
+
+l6:
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l6;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l6;
+    }
+
+}
+
+l7:
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l7;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l7;
+    }
+} while (1 === 1)
+
+l8:
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l8;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l8;
+    }
+}
+
+//===const
+l0_c:
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l0_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l0_c;
+    }
+}
+
+l00_c:
+for (const x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l00_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l00_c;
+    }
+}
+
+l1_c:
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l1_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l1_c;
+    }
+}
+
+l2_c:
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l2_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l2_c;
+    }
+}
+
+l3_c:
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l3_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l3_c;
+    }
+} while (1 === 1)
+
+l4_c:
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l4_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l4_c;
+    }
+}
+
+l5_c:
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l5_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l5_c;
+    }
+}
+
+l6_c:
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l6_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l6_c;
+    }
+
+}
+
+l7_c:
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l7_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l7_c;
+    }
+} while (1 === 1)
+
+l8_c:
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l8_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l8_c;
+    }
+}
+
+//// [capturedLetConstInLoop7_ES6.js]
+//===let
+l0: for (let x of []) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l0;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l0;
+    }
+}
+l00: for (let x in []) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l00;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l00;
+    }
+}
+l1: for (let x = 0; x < 1; ++x) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l1;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l1;
+    }
+}
+l2: while (1 === 1) {
+    let x;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l2;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l2;
+    }
+}
+l3: do {
+    let x;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l3;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l3;
+    }
+} while (1 === 1);
+l4: for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l4;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l4;
+    }
+}
+l5: for (let x = 0, y = 1; x < 1; ++x) {
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l5;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l5;
+    }
+}
+l6: while (1 === 1) {
+    let x, y;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l6;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l6;
+    }
+}
+l7: do {
+    let x, y;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l7;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l7;
+    }
+} while (1 === 1);
+l8: for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l8;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l8;
+    }
+}
+//===const
+l0_c: for (const x of []) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l0_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l0_c;
+    }
+}
+l00_c: for (const x in []) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l00_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l00_c;
+    }
+}
+l1_c: for (const x = 0; x < 1;) {
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l1_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l1_c;
+    }
+}
+l2_c: while (1 === 1) {
+    const x = 1;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l2_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l2_c;
+    }
+}
+l3_c: do {
+    const x = 1;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l3_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l3_c;
+    }
+} while (1 === 1);
+l4_c: for (const y = 0; y < 1;) {
+    const x = 1;
+    (function () { return x; });
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l4_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l4_c;
+    }
+}
+l5_c: for (const x = 0, y = 1; x < 1;) {
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l5_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l5_c;
+    }
+}
+l6_c: while (1 === 1) {
+    const x = 1, y = 1;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l6_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l6_c;
+    }
+}
+l7_c: do {
+    const x = 1, y = 1;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l7_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l7_c;
+    }
+} while (1 === 1);
+l8_c: for (const y = 0; y < 1;) {
+    const x = 1;
+    (function () { return x + y; });
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l8_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l8_c;
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop7_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop7_ES6.symbols
new file mode 100644
index 00000000000..51131f421ba
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop7_ES6.symbols
@@ -0,0 +1,698 @@
+=== tests/cases/compiler/capturedLetConstInLoop7_ES6.ts ===
+//===let
+l0:
+for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 2, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 2, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 2, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 2, 8))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 2, 8))
+
+        break l0;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 2, 8))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 2, 8))
+
+        continue l0;
+    }
+}
+
+l00:
+for (let x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 20, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 20, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 20, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 20, 8))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 20, 8))
+
+        break l00;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 20, 8))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 20, 8))
+
+        continue l00;
+    }
+}
+
+l1:
+for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 38, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 38, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 38, 8))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 38, 8))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 38, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 38, 8))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 38, 8))
+
+        break l1;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 38, 8))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 38, 8))
+
+        continue l1;
+    }
+}
+
+l2:
+while (1 === 1) {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 57, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 57, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 57, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 57, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 57, 7))
+
+        break l2;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 57, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 57, 7))
+
+        continue l2;
+    }
+}
+
+l3:
+do {
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 76, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 76, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 76, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 76, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 76, 7))
+
+        break l3;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 76, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 76, 7))
+
+        continue l3;
+    }
+} while (1 === 1)
+
+l4:
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 94, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 94, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 94, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 95, 7))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 95, 7))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 95, 7))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 95, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 95, 7))
+
+        break l4;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 95, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 95, 7))
+
+        continue l4;
+    }
+}
+
+l5:
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 113, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 113, 15))
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 113, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 113, 8))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 113, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 113, 15))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 113, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 113, 15))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 113, 8))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 113, 8))
+
+        break l5;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 113, 8))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 113, 8))
+
+        continue l5;
+    }
+}
+
+l6:
+while (1 === 1) {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 132, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 132, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 132, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 132, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 132, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 132, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 132, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 132, 7))
+
+        break l6;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 132, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 132, 7))
+
+        continue l6;
+    }
+
+}
+
+l7:
+do {
+    let x, y;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 152, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 152, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 152, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 152, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 152, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 152, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 152, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 152, 7))
+
+        break l7;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 152, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 152, 7))
+
+        continue l7;
+    }
+} while (1 === 1)
+
+l8:
+for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 170, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 170, 8))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 170, 8))
+
+    let x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 171, 7))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 171, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 170, 8))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 171, 7))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 170, 8))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 171, 7))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 171, 7))
+
+        break l8;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 171, 7))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 171, 7))
+
+        continue l8;
+    }
+}
+
+//===const
+l0_c:
+for (const x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 190, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 190, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 190, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 190, 10))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 190, 10))
+
+        break l0_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 190, 10))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 190, 10))
+
+        continue l0_c;
+    }
+}
+
+l00_c:
+for (const x in []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 208, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 208, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 208, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 208, 10))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 208, 10))
+
+        break l00_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 208, 10))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 208, 10))
+
+        continue l00_c;
+    }
+}
+
+l1_c:
+for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 226, 10))
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 226, 10))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 226, 10))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 226, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 226, 10))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 226, 10))
+
+        break l1_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 226, 10))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 226, 10))
+
+        continue l1_c;
+    }
+}
+
+l2_c:
+while (1 === 1) {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 245, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 245, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 245, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 245, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 245, 9))
+
+        break l2_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 245, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 245, 9))
+
+        continue l2_c;
+    }
+}
+
+l3_c:
+do {
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 264, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 264, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 264, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 264, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 264, 9))
+
+        break l3_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 264, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 264, 9))
+
+        continue l3_c;
+    }
+} while (1 === 1)
+
+l4_c:
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 282, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 282, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 283, 9))
+
+    (function() { return x});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 283, 9))
+
+    (() => x);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 283, 9))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 283, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 283, 9))
+
+        break l4_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 283, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 283, 9))
+
+        continue l4_c;
+    }
+}
+
+l5_c:
+for (const x = 0, y = 1; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 301, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 301, 17))
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 301, 10))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 301, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 301, 17))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 301, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 301, 17))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 301, 10))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 301, 10))
+
+        break l5_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 301, 10))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 301, 10))
+
+        continue l5_c;
+    }
+}
+
+l6_c:
+while (1 === 1) {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 320, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 320, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 320, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 320, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 320, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 320, 16))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 320, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 320, 9))
+
+        break l6_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 320, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 320, 9))
+
+        continue l6_c;
+    }
+
+}
+
+l7_c:
+do {
+    const x = 1, y = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 340, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 340, 16))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 340, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 340, 16))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 340, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 340, 16))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 340, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 340, 9))
+
+        break l7_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 340, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 340, 9))
+
+        continue l7_c;
+    }
+} while (1 === 1)
+
+l8_c:
+for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 358, 10))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 358, 10))
+
+    const x = 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 359, 9))
+
+    (function() { return x + y});
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 359, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 358, 10))
+
+    (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 359, 9))
+>y : Symbol(y, Decl(capturedLetConstInLoop7_ES6.ts, 358, 10))
+
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 359, 9))
+
+        break;
+    }
+    if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 359, 9))
+
+        break l8_c;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 359, 9))
+
+        continue;
+    }
+    if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop7_ES6.ts, 359, 9))
+
+        continue l8_c;
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop7_ES6.types b/tests/baselines/reference/capturedLetConstInLoop7_ES6.types
new file mode 100644
index 00000000000..56573fb4927
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop7_ES6.types
@@ -0,0 +1,1106 @@
+=== tests/cases/compiler/capturedLetConstInLoop7_ES6.ts ===
+//===let
+l0:
+>l0 : any
+
+for (let x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l0;
+>l0 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l0;
+>l0 : any
+    }
+}
+
+l00:
+>l00 : any
+
+for (let x in []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l00;
+>l00 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l00;
+>l00 : any
+    }
+}
+
+l1:
+>l1 : any
+
+for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l1;
+>l1 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l1;
+>l1 : any
+    }
+}
+
+l2:
+>l2 : any
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l2;
+>l2 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l2;
+>l2 : any
+    }
+}
+
+l3:
+>l3 : any
+
+do {
+    let x;
+>x : any
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l3;
+>l3 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l3;
+>l3 : any
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+l4:
+>l4 : any
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l4;
+>l4 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l4;
+>l4 : any
+    }
+}
+
+l5:
+>l5 : any
+
+for (let x = 0, y = 1; x < 1; ++x) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l5;
+>l5 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l5;
+>l5 : any
+    }
+}
+
+l6:
+>l6 : any
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l6;
+>l6 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l6;
+>l6 : any
+    }
+
+}
+
+l7:
+>l7 : any
+
+do {
+    let x, y;
+>x : any
+>y : any
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => any
+>function() { return x + y} : () => any
+>x + y : any
+>x : any
+>y : any
+
+    (() => x + y);
+>(() => x + y) : () => any
+>() => x + y : () => any
+>x + y : any
+>x : any
+>y : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l7;
+>l7 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l7;
+>l7 : any
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+l8:
+>l8 : any
+
+for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+    let x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l8;
+>l8 : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l8;
+>l8 : any
+    }
+}
+
+//===const
+l0_c:
+>l0_c : any
+
+for (const x of []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l0_c;
+>l0_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l0_c;
+>l0_c : any
+    }
+}
+
+l00_c:
+>l00_c : any
+
+for (const x in []) {
+>x : any
+>[] : undefined[]
+
+    (function() { return x});
+>(function() { return x}) : () => any
+>function() { return x} : () => any
+>x : any
+
+    (() => x);
+>(() => x) : () => any
+>() => x : () => any
+>x : any
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : any
+>1 : number
+
+        break l00_c;
+>l00_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : any
+>2 : number
+
+        continue l00_c;
+>l00_c : any
+    }
+}
+
+l1_c:
+>l1_c : any
+
+for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l1_c;
+>l1_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l1_c;
+>l1_c : any
+    }
+}
+
+l2_c:
+>l2_c : any
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l2_c;
+>l2_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l2_c;
+>l2_c : any
+    }
+}
+
+l3_c:
+>l3_c : any
+
+do {
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l3_c;
+>l3_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l3_c;
+>l3_c : any
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+l4_c:
+>l4_c : any
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x});
+>(function() { return x}) : () => number
+>function() { return x} : () => number
+>x : number
+
+    (() => x);
+>(() => x) : () => number
+>() => x : () => number
+>x : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l4_c;
+>l4_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l4_c;
+>l4_c : any
+    }
+}
+
+l5_c:
+>l5_c : any
+
+for (const x = 0, y = 1; x < 1;) {
+>x : number
+>0 : number
+>y : number
+>1 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l5_c;
+>l5_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l5_c;
+>l5_c : any
+    }
+}
+
+l6_c:
+>l6_c : any
+
+while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l6_c;
+>l6_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l6_c;
+>l6_c : any
+    }
+
+}
+
+l7_c:
+>l7_c : any
+
+do {
+    const x = 1, y = 1;
+>x : number
+>1 : number
+>y : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l7_c;
+>l7_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l7_c;
+>l7_c : any
+    }
+} while (1 === 1)
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+l8_c:
+>l8_c : any
+
+for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+    const x = 1;
+>x : number
+>1 : number
+
+    (function() { return x + y});
+>(function() { return x + y}) : () => number
+>function() { return x + y} : () => number
+>x + y : number
+>x : number
+>y : number
+
+    (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break;
+    }
+    if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+        break l8_c;
+>l8_c : any
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue;
+    }
+    if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+        continue l8_c;
+>l8_c : any
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop8.js b/tests/baselines/reference/capturedLetConstInLoop8.js
new file mode 100644
index 00000000000..b85d0d61cb8
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8.js
@@ -0,0 +1,269 @@
+//// [capturedLetConstInLoop8.ts]
+function foo() {
+    l0:
+    for (let z = 0; z < 1; ++z) {
+        l1:
+        for (let x = 0; x < 1; ++x) {
+            ll1:
+            for (let y = 0; y < 1; ++y) {
+                (function() { return x + y });
+                (() => x + y);
+                if (y == 1) {
+                    break;
+                }
+                if (y == 1) {
+                    break l1;
+                }
+                if (y == 1) {
+                    break ll1;
+                }
+                if (y == 1) {
+                    continue l0;
+                }
+
+                if (x == 2) {
+                    continue;
+                }
+                if (x == 2) {
+                    continue l1;
+                }
+                if (x == 2) {
+                    continue ll1;
+                }
+                if (x == 2) {
+                    return "123"
+                }
+            }
+            if (x == 1) {
+                break;
+            }
+            if (x == 1) {
+                break l1;
+            }
+            if (x == 2) {
+                continue;
+            }
+            if (x == 2) {
+                continue l1;
+            }
+            if (x == 2) {
+                continue l0;
+            }
+            if (x == 2) {
+                return "456";
+            }            
+        }
+    }
+}
+
+function foo_c() {
+    l0:
+    for (const z = 0; z < 1;) {
+        l1:
+        for (const x = 0; x < 1;) {
+            ll1:
+            for (const y = 0; y < 1;) {
+                (function() { return x + y });
+                (() => x + y);
+                if (y == 1) {
+                    break;
+                }
+                if (y == 1) {
+                    break l1;
+                }
+                if (y == 1) {
+                    break ll1;
+                }
+                if (y == 1) {
+                    continue l0;
+                }
+
+                if (x == 2) {
+                    continue;
+                }
+                if (x == 2) {
+                    continue l1;
+                }
+                if (x == 2) {
+                    continue ll1;
+                }
+                if (x == 2) {
+                    return "123"
+                }
+            }
+            if (x == 1) {
+                break;
+            }
+            if (x == 1) {
+                break l1;
+            }
+            if (x == 2) {
+                continue;
+            }
+            if (x == 2) {
+                continue l1;
+            }
+            if (x == 2) {
+                continue l0;
+            }
+            if (x == 2) {
+                return "456";
+            }            
+        }
+    }
+}
+
+
+//// [capturedLetConstInLoop8.js]
+function foo() {
+    l0: for (var z = 0; z < 1; ++z) {
+        var _loop_1 = function(x) {
+            var _loop_2 = function(y) {
+                (function () { return x + y; });
+                (function () { return x + y; });
+                if (y == 1) {
+                    return "break";
+                }
+                if (y == 1) {
+                    return "break-l1";
+                }
+                if (y == 1) {
+                    return "break-ll1";
+                }
+                if (y == 1) {
+                    return "continue-l0";
+                }
+                if (x == 2) {
+                    return "continue";
+                }
+                if (x == 2) {
+                    return "continue-l1";
+                }
+                if (x == 2) {
+                    return "continue-ll1";
+                }
+                if (x == 2) {
+                    return { value: "123" };
+                }
+            };
+            ll1: for (var y = 0; y < 1; ++y) {
+                var state_1 = _loop_2(y);
+                if (typeof state_1 === "object") return state_1;
+                if (state_1 === "break") break;
+                if (state_1 === "continue") continue;
+                switch(state_1) {
+                    case "break-l1": return state_1;
+                    case "break-ll1": break ll1;
+                    case "continue-l0": return state_1;
+                    case "continue-l1": return state_1;
+                    case "continue-ll1": continue ll1;
+                }
+            }
+            if (x == 1) {
+                return "break";
+            }
+            if (x == 1) {
+                return "break-l1";
+            }
+            if (x == 2) {
+                return "continue";
+            }
+            if (x == 2) {
+                return "continue-l1";
+            }
+            if (x == 2) {
+                return "continue-l0";
+            }
+            if (x == 2) {
+                return { value: "456" };
+            }
+        };
+        l1: for (var x = 0; x < 1; ++x) {
+            var state_2 = _loop_1(x);
+            if (typeof state_2 === "object") return state_2.value
+            if (state_2 === "break") break;
+            if (state_2 === "continue") continue;
+            switch(state_2) {
+                case "break-l1": break l1;
+                case "continue-l0": continue l0;
+                case "continue-l1": continue l1;
+            }
+        }
+    }
+}
+function foo_c() {
+    l0: for (var z = 0; z < 1;) {
+        var _loop_3 = function(x) {
+            var _loop_4 = function(y) {
+                (function () { return x + y; });
+                (function () { return x + y; });
+                if (y == 1) {
+                    return "break";
+                }
+                if (y == 1) {
+                    return "break-l1";
+                }
+                if (y == 1) {
+                    return "break-ll1";
+                }
+                if (y == 1) {
+                    return "continue-l0";
+                }
+                if (x == 2) {
+                    return "continue";
+                }
+                if (x == 2) {
+                    return "continue-l1";
+                }
+                if (x == 2) {
+                    return "continue-ll1";
+                }
+                if (x == 2) {
+                    return { value: "123" };
+                }
+            };
+            ll1: for (var y = 0; y < 1;) {
+                var state_3 = _loop_4(y);
+                if (typeof state_3 === "object") return state_3;
+                if (state_3 === "break") break;
+                if (state_3 === "continue") continue;
+                switch(state_3) {
+                    case "break-l1": return state_3;
+                    case "break-ll1": break ll1;
+                    case "continue-l0": return state_3;
+                    case "continue-l1": return state_3;
+                    case "continue-ll1": continue ll1;
+                }
+            }
+            if (x == 1) {
+                return "break";
+            }
+            if (x == 1) {
+                return "break-l1";
+            }
+            if (x == 2) {
+                return "continue";
+            }
+            if (x == 2) {
+                return "continue-l1";
+            }
+            if (x == 2) {
+                return "continue-l0";
+            }
+            if (x == 2) {
+                return { value: "456" };
+            }
+        };
+        l1: for (var x = 0; x < 1;) {
+            var state_4 = _loop_3(x);
+            if (typeof state_4 === "object") return state_4.value
+            if (state_4 === "break") break;
+            if (state_4 === "continue") continue;
+            switch(state_4) {
+                case "break-l1": break l1;
+                case "continue-l0": continue l0;
+                case "continue-l1": continue l1;
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop8.symbols b/tests/baselines/reference/capturedLetConstInLoop8.symbols
new file mode 100644
index 00000000000..9412c110fe5
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8.symbols
@@ -0,0 +1,208 @@
+=== tests/cases/compiler/capturedLetConstInLoop8.ts ===
+function foo() {
+>foo : Symbol(foo, Decl(capturedLetConstInLoop8.ts, 0, 0))
+
+    l0:
+    for (let z = 0; z < 1; ++z) {
+>z : Symbol(z, Decl(capturedLetConstInLoop8.ts, 2, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop8.ts, 2, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop8.ts, 2, 12))
+
+        l1:
+        for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+            ll1:
+            for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 6, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 6, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 6, 20))
+
+                (function() { return x + y });
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 6, 20))
+
+                (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 6, 20))
+
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 6, 20))
+
+                    break;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 6, 20))
+
+                    break l1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 6, 20))
+
+                    break ll1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 6, 20))
+
+                    continue l0;
+                }
+
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                    continue;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                    continue l1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                    continue ll1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                    return "123"
+                }
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                break;
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                break l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                continue;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                continue l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                continue l0;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                return "456";
+            }            
+        }
+    }
+}
+
+function foo_c() {
+>foo_c : Symbol(foo_c, Decl(capturedLetConstInLoop8.ts, 55, 1))
+
+    l0:
+    for (const z = 0; z < 1;) {
+>z : Symbol(z, Decl(capturedLetConstInLoop8.ts, 59, 14))
+>z : Symbol(z, Decl(capturedLetConstInLoop8.ts, 59, 14))
+
+        l1:
+        for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+            ll1:
+            for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+
+                (function() { return x + y });
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+
+                (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+
+                    break;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+
+                    break l1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+
+                    break ll1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+
+                    continue l0;
+                }
+
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+                    continue;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+                    continue l1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+                    continue ll1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+                    return "123"
+                }
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+                break;
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+                break l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+                continue;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+                continue l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+                continue l0;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+
+                return "456";
+            }            
+        }
+    }
+}
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop8.types b/tests/baselines/reference/capturedLetConstInLoop8.types
new file mode 100644
index 00000000000..89b488c2393
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8.types
@@ -0,0 +1,329 @@
+=== tests/cases/compiler/capturedLetConstInLoop8.ts ===
+function foo() {
+>foo : () => string
+
+    l0:
+>l0 : any
+
+    for (let z = 0; z < 1; ++z) {
+>z : number
+>0 : number
+>z < 1 : boolean
+>z : number
+>1 : number
+>++z : number
+>z : number
+
+        l1:
+>l1 : any
+
+        for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+            ll1:
+>ll1 : any
+
+            for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+                (function() { return x + y });
+>(function() { return x + y }) : () => number
+>function() { return x + y } : () => number
+>x + y : number
+>x : number
+>y : number
+
+                (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break;
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break l1;
+>l1 : any
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break ll1;
+>ll1 : any
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    continue l0;
+>l0 : any
+                }
+
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue;
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue l1;
+>l1 : any
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue ll1;
+>ll1 : any
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    return "123"
+>"123" : string
+                }
+            }
+            if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+                break;
+            }
+            if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+                break l1;
+>l1 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue;
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue l1;
+>l1 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue l0;
+>l0 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                return "456";
+>"456" : string
+            }            
+        }
+    }
+}
+
+function foo_c() {
+>foo_c : () => string
+
+    l0:
+>l0 : any
+
+    for (const z = 0; z < 1;) {
+>z : number
+>0 : number
+>z < 1 : boolean
+>z : number
+>1 : number
+
+        l1:
+>l1 : any
+
+        for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+            ll1:
+>ll1 : any
+
+            for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+                (function() { return x + y });
+>(function() { return x + y }) : () => number
+>function() { return x + y } : () => number
+>x + y : number
+>x : number
+>y : number
+
+                (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break;
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break l1;
+>l1 : any
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break ll1;
+>ll1 : any
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    continue l0;
+>l0 : any
+                }
+
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue;
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue l1;
+>l1 : any
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue ll1;
+>ll1 : any
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    return "123"
+>"123" : string
+                }
+            }
+            if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+                break;
+            }
+            if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+                break l1;
+>l1 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue;
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue l1;
+>l1 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue l0;
+>l0 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                return "456";
+>"456" : string
+            }            
+        }
+    }
+}
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop8_ES6.js b/tests/baselines/reference/capturedLetConstInLoop8_ES6.js
new file mode 100644
index 00000000000..7763fd3a88d
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8_ES6.js
@@ -0,0 +1,222 @@
+//// [capturedLetConstInLoop8_ES6.ts]
+
+function foo() {
+    l0:
+    for (let z = 0; z < 1; ++z) {
+        l1:
+        for (let x = 0; x < 1; ++x) {
+            ll1:
+            for (let y = 0; y < 1; ++y) {
+                (function() { return x + y });
+                (() => x + y);
+                if (y == 1) {
+                    break;
+                }
+                if (y == 1) {
+                    break l1;
+                }
+                if (y == 1) {
+                    break ll1;
+                }
+                if (y == 1) {
+                    continue l0;
+                }
+
+                if (x == 2) {
+                    continue;
+                }
+                if (x == 2) {
+                    continue l1;
+                }
+                if (x == 2) {
+                    continue ll1;
+                }
+                if (x == 2) {
+                    return "123"
+                }
+            }
+            if (x == 1) {
+                break;
+            }
+            if (x == 1) {
+                break l1;
+            }
+            if (x == 2) {
+                continue;
+            }
+            if (x == 2) {
+                continue l1;
+            }
+            if (x == 2) {
+                continue l0;
+            }
+            if (x == 2) {
+                return "456";
+            }            
+        }
+    }
+}
+
+function foo_c() {
+    l0:
+    for (const z = 0; z < 1;) {
+        l1:
+        for (const x = 0; x < 1;) {
+            ll1:
+            for (const y = 0; y < 1;) {
+                (function() { return x + y });
+                (() => x + y);
+                if (y == 1) {
+                    break;
+                }
+                if (y == 1) {
+                    break l1;
+                }
+                if (y == 1) {
+                    break ll1;
+                }
+                if (y == 1) {
+                    continue l0;
+                }
+
+                if (x == 2) {
+                    continue;
+                }
+                if (x == 2) {
+                    continue l1;
+                }
+                if (x == 2) {
+                    continue ll1;
+                }
+                if (x == 2) {
+                    return "123"
+                }
+            }
+            if (x == 1) {
+                break;
+            }
+            if (x == 1) {
+                break l1;
+            }
+            if (x == 2) {
+                continue;
+            }
+            if (x == 2) {
+                continue l1;
+            }
+            if (x == 2) {
+                continue l0;
+            }
+            if (x == 2) {
+                return "456";
+            }            
+        }
+    }
+}
+
+
+//// [capturedLetConstInLoop8_ES6.js]
+function foo() {
+    l0: for (let z = 0; z < 1; ++z) {
+        l1: for (let x = 0; x < 1; ++x) {
+            ll1: for (let y = 0; y < 1; ++y) {
+                (function () { return x + y; });
+                (() => x + y);
+                if (y == 1) {
+                    break;
+                }
+                if (y == 1) {
+                    break l1;
+                }
+                if (y == 1) {
+                    break ll1;
+                }
+                if (y == 1) {
+                    continue l0;
+                }
+                if (x == 2) {
+                    continue;
+                }
+                if (x == 2) {
+                    continue l1;
+                }
+                if (x == 2) {
+                    continue ll1;
+                }
+                if (x == 2) {
+                    return "123";
+                }
+            }
+            if (x == 1) {
+                break;
+            }
+            if (x == 1) {
+                break l1;
+            }
+            if (x == 2) {
+                continue;
+            }
+            if (x == 2) {
+                continue l1;
+            }
+            if (x == 2) {
+                continue l0;
+            }
+            if (x == 2) {
+                return "456";
+            }
+        }
+    }
+}
+function foo_c() {
+    l0: for (const z = 0; z < 1;) {
+        l1: for (const x = 0; x < 1;) {
+            ll1: for (const y = 0; y < 1;) {
+                (function () { return x + y; });
+                (() => x + y);
+                if (y == 1) {
+                    break;
+                }
+                if (y == 1) {
+                    break l1;
+                }
+                if (y == 1) {
+                    break ll1;
+                }
+                if (y == 1) {
+                    continue l0;
+                }
+                if (x == 2) {
+                    continue;
+                }
+                if (x == 2) {
+                    continue l1;
+                }
+                if (x == 2) {
+                    continue ll1;
+                }
+                if (x == 2) {
+                    return "123";
+                }
+            }
+            if (x == 1) {
+                break;
+            }
+            if (x == 1) {
+                break l1;
+            }
+            if (x == 2) {
+                continue;
+            }
+            if (x == 2) {
+                continue l1;
+            }
+            if (x == 2) {
+                continue l0;
+            }
+            if (x == 2) {
+                return "456";
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols
new file mode 100644
index 00000000000..2ab5698c778
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols
@@ -0,0 +1,209 @@
+=== tests/cases/compiler/capturedLetConstInLoop8_ES6.ts ===
+
+function foo() {
+>foo : Symbol(foo, Decl(capturedLetConstInLoop8_ES6.ts, 0, 0))
+
+    l0:
+    for (let z = 0; z < 1; ++z) {
+>z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 3, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 3, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 3, 12))
+
+        l1:
+        for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+            ll1:
+            for (let y = 0; y < 1; ++y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+
+                (function() { return x + y });
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+
+                (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+
+                    break;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+
+                    break l1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+
+                    break ll1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+
+                    continue l0;
+                }
+
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+                    continue;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+                    continue l1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+                    continue ll1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+                    return "123"
+                }
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+                break;
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+                break l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+                continue;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+                continue l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+                continue l0;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+
+                return "456";
+            }            
+        }
+    }
+}
+
+function foo_c() {
+>foo_c : Symbol(foo_c, Decl(capturedLetConstInLoop8_ES6.ts, 56, 1))
+
+    l0:
+    for (const z = 0; z < 1;) {
+>z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 60, 14))
+>z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 60, 14))
+
+        l1:
+        for (const x = 0; x < 1;) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+            ll1:
+            for (const y = 0; y < 1;) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+
+                (function() { return x + y });
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+
+                (() => x + y);
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+
+                    break;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+
+                    break l1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+
+                    break ll1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+
+                    continue l0;
+                }
+
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+                    continue;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+                    continue l1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+                    continue ll1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+                    return "123"
+                }
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+                break;
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+                break l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+                continue;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+                continue l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+                continue l0;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+
+                return "456";
+            }            
+        }
+    }
+}
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop8_ES6.types b/tests/baselines/reference/capturedLetConstInLoop8_ES6.types
new file mode 100644
index 00000000000..bb6d389e75b
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8_ES6.types
@@ -0,0 +1,330 @@
+=== tests/cases/compiler/capturedLetConstInLoop8_ES6.ts ===
+
+function foo() {
+>foo : () => string
+
+    l0:
+>l0 : any
+
+    for (let z = 0; z < 1; ++z) {
+>z : number
+>0 : number
+>z < 1 : boolean
+>z : number
+>1 : number
+>++z : number
+>z : number
+
+        l1:
+>l1 : any
+
+        for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+            ll1:
+>ll1 : any
+
+            for (let y = 0; y < 1; ++y) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+>++y : number
+>y : number
+
+                (function() { return x + y });
+>(function() { return x + y }) : () => number
+>function() { return x + y } : () => number
+>x + y : number
+>x : number
+>y : number
+
+                (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break;
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break l1;
+>l1 : any
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break ll1;
+>ll1 : any
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    continue l0;
+>l0 : any
+                }
+
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue;
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue l1;
+>l1 : any
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue ll1;
+>ll1 : any
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    return "123"
+>"123" : string
+                }
+            }
+            if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+                break;
+            }
+            if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+                break l1;
+>l1 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue;
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue l1;
+>l1 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue l0;
+>l0 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                return "456";
+>"456" : string
+            }            
+        }
+    }
+}
+
+function foo_c() {
+>foo_c : () => string
+
+    l0:
+>l0 : any
+
+    for (const z = 0; z < 1;) {
+>z : number
+>0 : number
+>z < 1 : boolean
+>z : number
+>1 : number
+
+        l1:
+>l1 : any
+
+        for (const x = 0; x < 1;) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+
+            ll1:
+>ll1 : any
+
+            for (const y = 0; y < 1;) {
+>y : number
+>0 : number
+>y < 1 : boolean
+>y : number
+>1 : number
+
+                (function() { return x + y });
+>(function() { return x + y }) : () => number
+>function() { return x + y } : () => number
+>x + y : number
+>x : number
+>y : number
+
+                (() => x + y);
+>(() => x + y) : () => number
+>() => x + y : () => number
+>x + y : number
+>x : number
+>y : number
+
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break;
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break l1;
+>l1 : any
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    break ll1;
+>ll1 : any
+                }
+                if (y == 1) {
+>y == 1 : boolean
+>y : number
+>1 : number
+
+                    continue l0;
+>l0 : any
+                }
+
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue;
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue l1;
+>l1 : any
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    continue ll1;
+>ll1 : any
+                }
+                if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                    return "123"
+>"123" : string
+                }
+            }
+            if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+                break;
+            }
+            if (x == 1) {
+>x == 1 : boolean
+>x : number
+>1 : number
+
+                break l1;
+>l1 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue;
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue l1;
+>l1 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                continue l0;
+>l0 : any
+            }
+            if (x == 2) {
+>x == 2 : boolean
+>x : number
+>2 : number
+
+                return "456";
+>"456" : string
+            }            
+        }
+    }
+}
+
diff --git a/tests/baselines/reference/capturedLetConstInLoop9.js b/tests/baselines/reference/capturedLetConstInLoop9.js
new file mode 100644
index 00000000000..1a55c362574
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9.js
@@ -0,0 +1,252 @@
+//// [capturedLetConstInLoop9.ts]
+for (let x = 0; x < 1; ++x) {
+    let x;
+    (function() { return x });
+    {
+        let x;
+        (function() { return x });
+    }
+
+    try { }
+    catch (e) {
+        let x;
+        (function() { return x });
+    }
+
+    switch (x) {
+        case 1:
+            let x;
+            (function() { return x });
+           break;
+    }
+    
+    while (1 == 1) {
+        let x;
+        (function() { return x });
+    }
+    
+    class A {
+        m() {
+            return x + 1;
+        }
+    }
+}
+
+declare function use(a: any);
+
+function foo() {
+    l0:
+    for (let a of []) {
+        
+        if (a === 1) {
+            break;
+        }
+        
+        if (a === 2) {
+            break l0;
+        }
+        
+        for (let b of []) {
+            var [{x, y:z}] = [{x:1, y:2}];
+            if (b === 1) {
+                break;
+            }
+            
+            
+            if (b === 2) {
+                break l0;
+            }
+            
+            l1:
+            if (b === 3) {
+                break l1;
+            }
+            
+            return 50;
+        }
+
+        for (let b of []) {
+            var [{x1, y:z1}] = [{x1:1, y:arguments.length}];
+            if (b === 1) {
+                break;
+            }
+            
+            if (b === 2) {
+                break l0;
+            }
+            
+            return 100;
+            
+            () => b
+        }
+
+        
+        () => a;
+    }
+    
+    use(x);
+    use(z);
+    use(x1);
+    use(z1);
+}
+
+function foo2() {
+    for (let x of []) {
+        if (x === 1) {
+            break;
+        }
+        else if (x === 2) {
+            continue;
+        }
+        
+        while (1 === 1) {
+            if (x) {
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        
+        switch(x) {
+            case 1: break;
+            case 2: continue;
+        }
+        
+        for (let y of []) {
+            switch(y) {
+                case 1: break;
+                case 2: continue;
+            }
+        }
+    }
+}
+
+//// [capturedLetConstInLoop9.js]
+var _loop_1 = function(x) {
+    var x_1 = void 0;
+    (function () { return x_1; });
+    {
+        var x_2 = void 0;
+        (function () { return x_2; });
+    }
+    try { }
+    catch (e) {
+        var x_3 = void 0;
+        (function () { return x_3; });
+    }
+    switch (x_1) {
+        case 1:
+            var x_4 = void 0;
+            (function () { return x_4; });
+            break;
+    }
+    var _loop_2 = function() {
+        var x_5 = void 0;
+        (function () { return x_5; });
+    };
+    while (1 == 1) {
+        _loop_2();
+    }
+    var A = (function () {
+        function A() {
+        }
+        A.prototype.m = function () {
+            return x_1 + 1;
+        };
+        return A;
+    })();
+};
+for (var x = 0; x < 1; ++x) {
+    _loop_1(x);
+}
+function foo() {
+    var _loop_3 = function(a) {
+        if (a === 1) {
+            return "break";
+        }
+        if (a === 2) {
+            return "break-l0";
+        }
+        for (var _i = 0, _a = []; _i < _a.length; _i++) {
+            var b = _a[_i];
+            _b = [{ x: 1, y: 2 }][0], x = _b.x, z = _b.y;
+            if (b === 1) {
+                break;
+            }
+            if (b === 2) {
+                return "break-l0";
+            }
+            l1: if (b === 3) {
+                break l1;
+            }
+            return { value: 50 };
+        }
+        var _loop_4 = function(b) {
+            _c = [{ x1: 1, y: arguments_1.length }][0], x1 = _c.x1, z1 = _c.y;
+            if (b === 1) {
+                return "break";
+            }
+            if (b === 2) {
+                return "break-l0";
+            }
+            return { value: 100 };
+            (function () { return b; });
+        };
+        for (var _d = 0, _e = []; _d < _e.length; _d++) {
+            var b = _e[_d];
+            var state_3 = _loop_4(b);
+            if (typeof state_3 === "object") return state_3;
+            if (state_3 === "break") break;
+            switch(state_3) {
+                case "break-l0": return state_3;
+            }
+        }
+        (function () { return a; });
+    };
+    var arguments_1 = arguments;
+    var x, z, x1, z1;
+    l0: for (var _f = 0, _g = []; _f < _g.length; _f++) {
+        var a = _g[_f];
+        var state_4 = _loop_3(a);
+        if (typeof state_4 === "object") return state_4.value
+        if (state_4 === "break") break;
+        switch(state_4) {
+            case "break-l0": break l0;
+        }
+    }
+    use(x);
+    use(z);
+    use(x1);
+    use(z1);
+}
+function foo2() {
+    for (var _i = 0, _a = []; _i < _a.length; _i++) {
+        var x = _a[_i];
+        if (x === 1) {
+            break;
+        }
+        else if (x === 2) {
+            continue;
+        }
+        while (1 === 1) {
+            if (x) {
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        switch (x) {
+            case 1: break;
+            case 2: continue;
+        }
+        for (var _b = 0, _c = []; _b < _c.length; _b++) {
+            var y = _c[_b];
+            switch (y) {
+                case 1: break;
+                case 2: continue;
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop9.symbols b/tests/baselines/reference/capturedLetConstInLoop9.symbols
new file mode 100644
index 00000000000..2a3aa1672c6
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9.symbols
@@ -0,0 +1,219 @@
+=== tests/cases/compiler/capturedLetConstInLoop9.ts ===
+for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 0, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 0, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 0, 8))
+
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 1, 7))
+
+    (function() { return x });
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 1, 7))
+    {
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 4, 11))
+
+        (function() { return x });
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 4, 11))
+    }
+
+    try { }
+    catch (e) {
+>e : Symbol(e, Decl(capturedLetConstInLoop9.ts, 9, 11))
+
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 10, 11))
+
+        (function() { return x });
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 10, 11))
+    }
+
+    switch (x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 1, 7))
+
+        case 1:
+            let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 16, 15))
+
+            (function() { return x });
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 16, 15))
+
+           break;
+    }
+    
+    while (1 == 1) {
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 22, 11))
+
+        (function() { return x });
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 22, 11))
+    }
+    
+    class A {
+>A : Symbol(A, Decl(capturedLetConstInLoop9.ts, 24, 5))
+
+        m() {
+>m : Symbol(m, Decl(capturedLetConstInLoop9.ts, 26, 13))
+
+            return x + 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 1, 7))
+        }
+    }
+}
+
+declare function use(a: any);
+>use : Symbol(use, Decl(capturedLetConstInLoop9.ts, 31, 1))
+>a : Symbol(a, Decl(capturedLetConstInLoop9.ts, 33, 21))
+
+function foo() {
+>foo : Symbol(foo, Decl(capturedLetConstInLoop9.ts, 33, 29))
+
+    l0:
+    for (let a of []) {
+>a : Symbol(a, Decl(capturedLetConstInLoop9.ts, 37, 12))
+        
+        if (a === 1) {
+>a : Symbol(a, Decl(capturedLetConstInLoop9.ts, 37, 12))
+
+            break;
+        }
+        
+        if (a === 2) {
+>a : Symbol(a, Decl(capturedLetConstInLoop9.ts, 37, 12))
+
+            break l0;
+        }
+        
+        for (let b of []) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 47, 16))
+
+            var [{x, y:z}] = [{x:1, y:2}];
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 48, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 48, 35))
+>z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 48, 20))
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 48, 31))
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 48, 35))
+
+            if (b === 1) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 47, 16))
+
+                break;
+            }
+            
+            
+            if (b === 2) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 47, 16))
+
+                break l0;
+            }
+            
+            l1:
+            if (b === 3) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 47, 16))
+
+                break l1;
+            }
+            
+            return 50;
+        }
+
+        for (let b of []) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 66, 16))
+
+            var [{x1, y:z1}] = [{x1:1, y:arguments.length}];
+>x1 : Symbol(x1, Decl(capturedLetConstInLoop9.ts, 67, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 67, 38))
+>z1 : Symbol(z1, Decl(capturedLetConstInLoop9.ts, 67, 21))
+>x1 : Symbol(x1, Decl(capturedLetConstInLoop9.ts, 67, 33))
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 67, 38))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+            if (b === 1) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 66, 16))
+
+                break;
+            }
+            
+            if (b === 2) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 66, 16))
+
+                break l0;
+            }
+            
+            return 100;
+            
+            () => b
+>b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 66, 16))
+        }
+
+        
+        () => a;
+>a : Symbol(a, Decl(capturedLetConstInLoop9.ts, 37, 12))
+    }
+    
+    use(x);
+>use : Symbol(use, Decl(capturedLetConstInLoop9.ts, 31, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 48, 18))
+
+    use(z);
+>use : Symbol(use, Decl(capturedLetConstInLoop9.ts, 31, 1))
+>z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 48, 20))
+
+    use(x1);
+>use : Symbol(use, Decl(capturedLetConstInLoop9.ts, 31, 1))
+>x1 : Symbol(x1, Decl(capturedLetConstInLoop9.ts, 67, 18))
+
+    use(z1);
+>use : Symbol(use, Decl(capturedLetConstInLoop9.ts, 31, 1))
+>z1 : Symbol(z1, Decl(capturedLetConstInLoop9.ts, 67, 21))
+}
+
+function foo2() {
+>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9.ts, 89, 1))
+
+    for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12))
+
+        if (x === 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12))
+
+            break;
+        }
+        else if (x === 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12))
+
+            continue;
+        }
+        
+        while (1 === 1) {
+            if (x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12))
+
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        
+        switch(x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 92, 12))
+
+            case 1: break;
+            case 2: continue;
+        }
+        
+        for (let y of []) {
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 114, 16))
+
+            switch(y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 114, 16))
+
+                case 1: break;
+                case 2: continue;
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop9.types b/tests/baselines/reference/capturedLetConstInLoop9.types
new file mode 100644
index 00000000000..6146f4347b7
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9.types
@@ -0,0 +1,297 @@
+=== tests/cases/compiler/capturedLetConstInLoop9.ts ===
+for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    let x;
+>x : any
+
+    (function() { return x });
+>(function() { return x }) : () => any
+>function() { return x } : () => any
+>x : any
+    {
+        let x;
+>x : any
+
+        (function() { return x });
+>(function() { return x }) : () => any
+>function() { return x } : () => any
+>x : any
+    }
+
+    try { }
+    catch (e) {
+>e : any
+
+        let x;
+>x : any
+
+        (function() { return x });
+>(function() { return x }) : () => any
+>function() { return x } : () => any
+>x : any
+    }
+
+    switch (x) {
+>x : any
+
+        case 1:
+>1 : number
+
+            let x;
+>x : any
+
+            (function() { return x });
+>(function() { return x }) : () => any
+>function() { return x } : () => any
+>x : any
+
+           break;
+    }
+    
+    while (1 == 1) {
+>1 == 1 : boolean
+>1 : number
+>1 : number
+
+        let x;
+>x : any
+
+        (function() { return x });
+>(function() { return x }) : () => any
+>function() { return x } : () => any
+>x : any
+    }
+    
+    class A {
+>A : A
+
+        m() {
+>m : () => any
+
+            return x + 1;
+>x + 1 : any
+>x : any
+>1 : number
+        }
+    }
+}
+
+declare function use(a: any);
+>use : (a: any) => any
+>a : any
+
+function foo() {
+>foo : () => number
+
+    l0:
+>l0 : any
+
+    for (let a of []) {
+>a : any
+>[] : undefined[]
+        
+        if (a === 1) {
+>a === 1 : boolean
+>a : any
+>1 : number
+
+            break;
+        }
+        
+        if (a === 2) {
+>a === 2 : boolean
+>a : any
+>2 : number
+
+            break l0;
+>l0 : any
+        }
+        
+        for (let b of []) {
+>b : any
+>[] : undefined[]
+
+            var [{x, y:z}] = [{x:1, y:2}];
+>x : number
+>y : any
+>z : number
+>[{x:1, y:2}] : [{ x: number; y: number; }]
+>{x:1, y:2} : { x: number; y: number; }
+>x : number
+>1 : number
+>y : number
+>2 : number
+
+            if (b === 1) {
+>b === 1 : boolean
+>b : any
+>1 : number
+
+                break;
+            }
+            
+            
+            if (b === 2) {
+>b === 2 : boolean
+>b : any
+>2 : number
+
+                break l0;
+>l0 : any
+            }
+            
+            l1:
+>l1 : any
+
+            if (b === 3) {
+>b === 3 : boolean
+>b : any
+>3 : number
+
+                break l1;
+>l1 : any
+            }
+            
+            return 50;
+>50 : number
+        }
+
+        for (let b of []) {
+>b : any
+>[] : undefined[]
+
+            var [{x1, y:z1}] = [{x1:1, y:arguments.length}];
+>x1 : number
+>y : any
+>z1 : number
+>[{x1:1, y:arguments.length}] : [{ x1: number; y: number; }]
+>{x1:1, y:arguments.length} : { x1: number; y: number; }
+>x1 : number
+>1 : number
+>y : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+            if (b === 1) {
+>b === 1 : boolean
+>b : any
+>1 : number
+
+                break;
+            }
+            
+            if (b === 2) {
+>b === 2 : boolean
+>b : any
+>2 : number
+
+                break l0;
+>l0 : any
+            }
+            
+            return 100;
+>100 : number
+            
+            () => b
+>() => b : () => any
+>b : any
+        }
+
+        
+        () => a;
+>() => a : () => any
+>a : any
+    }
+    
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : number
+
+    use(z);
+>use(z) : any
+>use : (a: any) => any
+>z : number
+
+    use(x1);
+>use(x1) : any
+>use : (a: any) => any
+>x1 : number
+
+    use(z1);
+>use(z1) : any
+>use : (a: any) => any
+>z1 : number
+}
+
+function foo2() {
+>foo2 : () => void
+
+    for (let x of []) {
+>x : any
+>[] : undefined[]
+
+        if (x === 1) {
+>x === 1 : boolean
+>x : any
+>1 : number
+
+            break;
+        }
+        else if (x === 2) {
+>x === 2 : boolean
+>x : any
+>2 : number
+
+            continue;
+        }
+        
+        while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+            if (x) {
+>x : any
+
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        
+        switch(x) {
+>x : any
+
+            case 1: break;
+>1 : number
+
+            case 2: continue;
+>2 : number
+        }
+        
+        for (let y of []) {
+>y : any
+>[] : undefined[]
+
+            switch(y) {
+>y : any
+
+                case 1: break;
+>1 : number
+
+                case 2: continue;
+>2 : number
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js
new file mode 100644
index 00000000000..9df7d1e58bd
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js
@@ -0,0 +1,221 @@
+//// [capturedLetConstInLoop9_ES6.ts]
+
+for (let x = 0; x < 1; ++x) {
+    let x;
+    (function() { return x });
+    {
+        let x;
+        (function() { return x });
+    }
+
+    try { }
+    catch (e) {
+        let x;
+        (function() { return x });
+    }
+
+    switch (x) {
+        case 1:
+            let x;
+            (function() { return x });
+           break;
+    }
+    
+    while (1 == 1) {
+        let x;
+        (function() { return x });
+    }
+    
+    class A {
+        m() {
+            return x + 1;
+        }
+    }
+}
+
+declare function use(a: any);
+
+function foo() {
+    l0:
+    for (let a of []) {
+        
+        if (a === 1) {
+            break;
+        }
+        
+        if (a === 2) {
+            break l0;
+        }
+        
+        for (let b of []) {
+            var [{x, y:z}] = [{x:1, y:2}];
+            if (b === 1) {
+                break;
+            }
+            
+            
+            if (b === 2) {
+                break l0;
+            }
+            
+            l1:
+            if (b === 3) {
+                break l1;
+            }
+            
+            return 50;
+        }
+
+        for (let b of []) {
+            var [{x1, y:z1}] = [{x1:1, y:arguments.length}];
+            if (b === 1) {
+                break;
+            }
+            
+            if (b === 2) {
+                break l0;
+            }
+            
+            return 100;
+            
+            () => b
+        }
+
+        
+        () => a;
+    }
+    
+    use(x);
+    use(z);
+    use(x1);
+    use(z1);
+}
+
+function foo2() {
+    for (let x of []) {
+        if (x === 1) {
+            break;
+        }
+        else if (x === 2) {
+            continue;
+        }
+        
+        while (1 === 1) {
+            if (x) {
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        
+        switch(x) {
+            case 1: break;
+            case 2: continue;
+        }
+        
+        for (let y of []) {
+            switch(y) {
+                case 1: break;
+                case 2: continue;
+            }
+        }
+    }
+}
+
+//// [capturedLetConstInLoop9_ES6.js]
+for (let x = 0; x < 1; ++x) {
+    let x;
+    (function () { return x; });
+    {
+        let x;
+        (function () { return x; });
+    }
+    try { }
+    catch (e) {
+        let x;
+        (function () { return x; });
+    }
+    switch (x) {
+        case 1:
+            let x;
+            (function () { return x; });
+            break;
+    }
+    while (1 == 1) {
+        let x;
+        (function () { return x; });
+    }
+    class A {
+        m() {
+            return x + 1;
+        }
+    }
+}
+function foo() {
+    l0: for (let a of []) {
+        if (a === 1) {
+            break;
+        }
+        if (a === 2) {
+            break l0;
+        }
+        for (let b of []) {
+            var [{ x, y: z }] = [{ x: 1, y: 2 }];
+            if (b === 1) {
+                break;
+            }
+            if (b === 2) {
+                break l0;
+            }
+            l1: if (b === 3) {
+                break l1;
+            }
+            return 50;
+        }
+        for (let b of []) {
+            var [{ x1, y: z1 }] = [{ x1: 1, y: arguments.length }];
+            if (b === 1) {
+                break;
+            }
+            if (b === 2) {
+                break l0;
+            }
+            return 100;
+            (() => b);
+        }
+        (() => a);
+    }
+    use(x);
+    use(z);
+    use(x1);
+    use(z1);
+}
+function foo2() {
+    for (let x of []) {
+        if (x === 1) {
+            break;
+        }
+        else if (x === 2) {
+            continue;
+        }
+        while (1 === 1) {
+            if (x) {
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        switch (x) {
+            case 1: break;
+            case 2: continue;
+        }
+        for (let y of []) {
+            switch (y) {
+                case 1: break;
+                case 2: continue;
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
new file mode 100644
index 00000000000..dae7aafd89f
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
@@ -0,0 +1,220 @@
+=== tests/cases/compiler/capturedLetConstInLoop9_ES6.ts ===
+
+for (let x = 0; x < 1; ++x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 8))
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 1, 8))
+
+    let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7))
+
+    (function() { return x });
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7))
+    {
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 5, 11))
+
+        (function() { return x });
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 5, 11))
+    }
+
+    try { }
+    catch (e) {
+>e : Symbol(e, Decl(capturedLetConstInLoop9_ES6.ts, 10, 11))
+
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 11, 11))
+
+        (function() { return x });
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 11, 11))
+    }
+
+    switch (x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7))
+
+        case 1:
+            let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 17, 15))
+
+            (function() { return x });
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 17, 15))
+
+           break;
+    }
+    
+    while (1 == 1) {
+        let x;
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 23, 11))
+
+        (function() { return x });
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 23, 11))
+    }
+    
+    class A {
+>A : Symbol(A, Decl(capturedLetConstInLoop9_ES6.ts, 25, 5))
+
+        m() {
+>m : Symbol(m, Decl(capturedLetConstInLoop9_ES6.ts, 27, 13))
+
+            return x + 1;
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 2, 7))
+        }
+    }
+}
+
+declare function use(a: any);
+>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1))
+>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 34, 21))
+
+function foo() {
+>foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 34, 29))
+
+    l0:
+    for (let a of []) {
+>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12))
+        
+        if (a === 1) {
+>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12))
+
+            break;
+        }
+        
+        if (a === 2) {
+>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12))
+
+            break l0;
+        }
+        
+        for (let b of []) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16))
+
+            var [{x, y:z}] = [{x:1, y:2}];
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 49, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 49, 35))
+>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 49, 20))
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 49, 31))
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 49, 35))
+
+            if (b === 1) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16))
+
+                break;
+            }
+            
+            
+            if (b === 2) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16))
+
+                break l0;
+            }
+            
+            l1:
+            if (b === 3) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 48, 16))
+
+                break l1;
+            }
+            
+            return 50;
+        }
+
+        for (let b of []) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16))
+
+            var [{x1, y:z1}] = [{x1:1, y:arguments.length}];
+>x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 68, 38))
+>z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 21))
+>x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 33))
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 68, 38))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+            if (b === 1) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16))
+
+                break;
+            }
+            
+            if (b === 2) {
+>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16))
+
+                break l0;
+            }
+            
+            return 100;
+            
+            () => b
+>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16))
+        }
+
+        
+        () => a;
+>a : Symbol(a, Decl(capturedLetConstInLoop9_ES6.ts, 38, 12))
+    }
+    
+    use(x);
+>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1))
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 49, 18))
+
+    use(z);
+>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1))
+>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 49, 20))
+
+    use(x1);
+>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1))
+>x1 : Symbol(x1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 18))
+
+    use(z1);
+>use : Symbol(use, Decl(capturedLetConstInLoop9_ES6.ts, 32, 1))
+>z1 : Symbol(z1, Decl(capturedLetConstInLoop9_ES6.ts, 68, 21))
+}
+
+function foo2() {
+>foo2 : Symbol(foo2, Decl(capturedLetConstInLoop9_ES6.ts, 90, 1))
+
+    for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12))
+
+        if (x === 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12))
+
+            break;
+        }
+        else if (x === 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12))
+
+            continue;
+        }
+        
+        while (1 === 1) {
+            if (x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12))
+
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        
+        switch(x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 93, 12))
+
+            case 1: break;
+            case 2: continue;
+        }
+        
+        for (let y of []) {
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 115, 16))
+
+            switch(y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 115, 16))
+
+                case 1: break;
+                case 2: continue;
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types
new file mode 100644
index 00000000000..1931927a4d8
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types
@@ -0,0 +1,298 @@
+=== tests/cases/compiler/capturedLetConstInLoop9_ES6.ts ===
+
+for (let x = 0; x < 1; ++x) {
+>x : number
+>0 : number
+>x < 1 : boolean
+>x : number
+>1 : number
+>++x : number
+>x : number
+
+    let x;
+>x : any
+
+    (function() { return x });
+>(function() { return x }) : () => any
+>function() { return x } : () => any
+>x : any
+    {
+        let x;
+>x : any
+
+        (function() { return x });
+>(function() { return x }) : () => any
+>function() { return x } : () => any
+>x : any
+    }
+
+    try { }
+    catch (e) {
+>e : any
+
+        let x;
+>x : any
+
+        (function() { return x });
+>(function() { return x }) : () => any
+>function() { return x } : () => any
+>x : any
+    }
+
+    switch (x) {
+>x : any
+
+        case 1:
+>1 : number
+
+            let x;
+>x : any
+
+            (function() { return x });
+>(function() { return x }) : () => any
+>function() { return x } : () => any
+>x : any
+
+           break;
+    }
+    
+    while (1 == 1) {
+>1 == 1 : boolean
+>1 : number
+>1 : number
+
+        let x;
+>x : any
+
+        (function() { return x });
+>(function() { return x }) : () => any
+>function() { return x } : () => any
+>x : any
+    }
+    
+    class A {
+>A : A
+
+        m() {
+>m : () => any
+
+            return x + 1;
+>x + 1 : any
+>x : any
+>1 : number
+        }
+    }
+}
+
+declare function use(a: any);
+>use : (a: any) => any
+>a : any
+
+function foo() {
+>foo : () => number
+
+    l0:
+>l0 : any
+
+    for (let a of []) {
+>a : any
+>[] : undefined[]
+        
+        if (a === 1) {
+>a === 1 : boolean
+>a : any
+>1 : number
+
+            break;
+        }
+        
+        if (a === 2) {
+>a === 2 : boolean
+>a : any
+>2 : number
+
+            break l0;
+>l0 : any
+        }
+        
+        for (let b of []) {
+>b : any
+>[] : undefined[]
+
+            var [{x, y:z}] = [{x:1, y:2}];
+>x : number
+>y : any
+>z : number
+>[{x:1, y:2}] : [{ x: number; y: number; }]
+>{x:1, y:2} : { x: number; y: number; }
+>x : number
+>1 : number
+>y : number
+>2 : number
+
+            if (b === 1) {
+>b === 1 : boolean
+>b : any
+>1 : number
+
+                break;
+            }
+            
+            
+            if (b === 2) {
+>b === 2 : boolean
+>b : any
+>2 : number
+
+                break l0;
+>l0 : any
+            }
+            
+            l1:
+>l1 : any
+
+            if (b === 3) {
+>b === 3 : boolean
+>b : any
+>3 : number
+
+                break l1;
+>l1 : any
+            }
+            
+            return 50;
+>50 : number
+        }
+
+        for (let b of []) {
+>b : any
+>[] : undefined[]
+
+            var [{x1, y:z1}] = [{x1:1, y:arguments.length}];
+>x1 : number
+>y : any
+>z1 : number
+>[{x1:1, y:arguments.length}] : [{ x1: number; y: number; }]
+>{x1:1, y:arguments.length} : { x1: number; y: number; }
+>x1 : number
+>1 : number
+>y : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+            if (b === 1) {
+>b === 1 : boolean
+>b : any
+>1 : number
+
+                break;
+            }
+            
+            if (b === 2) {
+>b === 2 : boolean
+>b : any
+>2 : number
+
+                break l0;
+>l0 : any
+            }
+            
+            return 100;
+>100 : number
+            
+            () => b
+>() => b : () => any
+>b : any
+        }
+
+        
+        () => a;
+>() => a : () => any
+>a : any
+    }
+    
+    use(x);
+>use(x) : any
+>use : (a: any) => any
+>x : number
+
+    use(z);
+>use(z) : any
+>use : (a: any) => any
+>z : number
+
+    use(x1);
+>use(x1) : any
+>use : (a: any) => any
+>x1 : number
+
+    use(z1);
+>use(z1) : any
+>use : (a: any) => any
+>z1 : number
+}
+
+function foo2() {
+>foo2 : () => void
+
+    for (let x of []) {
+>x : any
+>[] : undefined[]
+
+        if (x === 1) {
+>x === 1 : boolean
+>x : any
+>1 : number
+
+            break;
+        }
+        else if (x === 2) {
+>x === 2 : boolean
+>x : any
+>2 : number
+
+            continue;
+        }
+        
+        while (1 === 1) {
+>1 === 1 : boolean
+>1 : number
+>1 : number
+
+            if (x) {
+>x : any
+
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        
+        switch(x) {
+>x : any
+
+            case 1: break;
+>1 : number
+
+            case 2: continue;
+>2 : number
+        }
+        
+        for (let y of []) {
+>y : any
+>[] : undefined[]
+
+            switch(y) {
+>y : any
+
+                case 1: break;
+>1 : number
+
+                case 2: continue;
+>2 : number
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/downlevelLetConst18.errors.txt b/tests/baselines/reference/downlevelLetConst18.errors.txt
index 8f30b0f802a..066c75abeb1 100644
--- a/tests/baselines/reference/downlevelLetConst18.errors.txt
+++ b/tests/baselines/reference/downlevelLetConst18.errors.txt
@@ -1,60 +1,39 @@
-tests/cases/compiler/downlevelLetConst18.ts(3,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
 tests/cases/compiler/downlevelLetConst18.ts(4,14): error TS2393: Duplicate function implementation.
-tests/cases/compiler/downlevelLetConst18.ts(7,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
 tests/cases/compiler/downlevelLetConst18.ts(8,14): error TS2393: Duplicate function implementation.
-tests/cases/compiler/downlevelLetConst18.ts(11,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-tests/cases/compiler/downlevelLetConst18.ts(15,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-tests/cases/compiler/downlevelLetConst18.ts(19,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-tests/cases/compiler/downlevelLetConst18.ts(23,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
-tests/cases/compiler/downlevelLetConst18.ts(27,1): error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
 
 
-==== tests/cases/compiler/downlevelLetConst18.ts (9 errors) ====
+==== tests/cases/compiler/downlevelLetConst18.ts (2 errors) ====
     'use strict'
     
     for (let x; ;) {
-    ~~~
-!!! error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
         function foo() { x };
                  ~~~
 !!! error TS2393: Duplicate function implementation.
     }
     
     for (let x; ;) {
-    ~~~
-!!! error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
         function foo() { x };
                  ~~~
 !!! error TS2393: Duplicate function implementation.
     }
     
     for (let x; ;) {
-    ~~~
-!!! error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
         (() => { x })();
     }
     
     for (const x = 1; ;) {
-    ~~~
-!!! error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
         (() => { x })();
     }
     
     for (let x; ;) {
-    ~~~
-!!! error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
         ({ foo() { x }})
     }
     
     for (let x; ;) {
-    ~~~
-!!! error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
         ({ get foo() { return x } })
     }
     
     for (let x; ;) {
-    ~~~
-!!! error TS4091: Loop contains block-scoped variable 'x' referenced by a function in the loop. This is only supported in ECMAScript 6 or higher.
         ({ set foo(v) { x } })
     }
     
\ No newline at end of file
diff --git a/tests/baselines/reference/downlevelLetConst18.js b/tests/baselines/reference/downlevelLetConst18.js
index 70b8cb9e346..59bd316f8a3 100644
--- a/tests/baselines/reference/downlevelLetConst18.js
+++ b/tests/baselines/reference/downlevelLetConst18.js
@@ -32,26 +32,47 @@ for (let x; ;) {
 
 //// [downlevelLetConst18.js]
 'use strict';
-for (var x = void 0;;) {
+var _loop_1 = function(x) {
     function foo() { x; }
     ;
-}
+};
 for (var x = void 0;;) {
+    _loop_1(x);
+}
+var _loop_2 = function(x) {
     function foo() { x; }
     ;
-}
+};
 for (var x = void 0;;) {
+    _loop_2(x);
+}
+var _loop_3 = function(x) {
     (function () { x; })();
+};
+for (var x = void 0;;) {
+    _loop_3(x);
 }
+var _loop_4 = function(x) {
+    (function () { x; })();
+};
 for (var x = 1;;) {
-    (function () { x; })();
+    _loop_4(x);
 }
-for (var x = void 0;;) {
+var _loop_5 = function(x) {
     ({ foo: function () { x; } });
-}
+};
 for (var x = void 0;;) {
+    _loop_5(x);
+}
+var _loop_6 = function(x) {
     ({ get foo() { return x; } });
-}
+};
 for (var x = void 0;;) {
-    ({ set foo(v) { x; } });
+    _loop_6(x);
+}
+var _loop_7 = function(x) {
+    ({ set foo(v) { x; } });
+};
+for (var x = void 0;;) {
+    _loop_7(x);
 }
diff --git a/tests/cases/compiler/capturedLetConstInLoop1.ts b/tests/cases/compiler/capturedLetConstInLoop1.ts
new file mode 100644
index 00000000000..bc731fdd35f
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop1.ts
@@ -0,0 +1,113 @@
+//==== let
+for (let x in {}) {
+    (function() { return x});
+    (() => x);
+}
+
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+}
+
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+}
+
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+}
+
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+//=========const
+for (const x in {}) {
+    (function() { return x});
+    (() => x);
+}
+
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+}
+
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+}
+
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop1_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop1_ES6.ts
new file mode 100644
index 00000000000..314fc4a9919
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop1_ES6.ts
@@ -0,0 +1,114 @@
+// @target: ES6
+//==== let
+for (let x in {}) {
+    (function() { return x});
+    (() => x);
+}
+
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+}
+
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+}
+
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+}
+
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+//=========const
+for (const x in {}) {
+    (function() { return x});
+    (() => x);
+}
+
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+}
+
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+}
+
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
+
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop2.ts b/tests/cases/compiler/capturedLetConstInLoop2.ts
new file mode 100644
index 00000000000..7dbd5d01f93
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop2.ts
@@ -0,0 +1,176 @@
+
+
+// ========let
+function foo0(x) {
+    for (let x of []) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo0_1(x) {
+    for (let x in []) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo3(x) {
+    do {
+        let x;
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    } while (1 === 1)
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        let a = arguments.length;
+        let x = 1;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    } while (1 === 1)
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+///=======const
+function foo0_c(x) {
+    for (const x of []) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo0_1_c(x) {
+    for (const x in []) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    } while (1 === 1)
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        const a = arguments.length;
+        const x = 1;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y =1 ;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    } while (1 === 1)
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop2_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop2_ES6.ts
new file mode 100644
index 00000000000..00aed712188
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop2_ES6.ts
@@ -0,0 +1,176 @@
+// @target: ES6
+
+// ========let
+function foo0(x) {
+    for (let x of []) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo0_1(x) {
+    for (let x in []) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo3(x) {
+    do {
+        let x;
+        let a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    } while (1 === 1)
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        let a = arguments.length;
+        let x = 1;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    } while (1 === 1)
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        let a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+///=======const
+function foo0_c(x) {
+    for (const x of []) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo0_1_c(x) {
+    for (const x in []) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        const a = arguments.length;
+        (function() { return x + a });
+        (() => x + a);
+    } while (1 === 1)
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        const a = arguments.length;
+        const x = 1;
+        (function() { return x + a });
+        (() => x + a);
+    }
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y =1 ;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    } while (1 === 1)
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        const a = arguments.length;
+        (function() { return x + y + a });
+        (() => x + y + a);
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop3.ts b/tests/cases/compiler/capturedLetConstInLoop3.ts
new file mode 100644
index 00000000000..dc5eef6dd34
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop3.ts
@@ -0,0 +1,217 @@
+///=========let
+declare function use(a: any);
+function foo0(x) {
+    for (let x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo0_1(x) {
+    for (let x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo3(x) {
+    do {
+        let x;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v)
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+//===const
+function foo0_c(x) {
+    for (const x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo0_1_c(x) {
+    for (const x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        var v = y;
+        const x = 1;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v)
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop3_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop3_ES6.ts
new file mode 100644
index 00000000000..657c5190473
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop3_ES6.ts
@@ -0,0 +1,219 @@
+// @target: ES6
+
+///=========let
+declare function use(a: any);
+function foo0(x) {
+    for (let x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo0_1(x) {
+    for (let x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo3(x) {
+    do {
+        let x;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v)
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+//===const
+function foo0_c(x) {
+    for (const x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo0_1_c(x) {
+    for (const x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+
+    use(v);
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        var v = y;
+        const x = 1;
+        (function() { return x + v });
+        (() => x + v);
+    }
+    
+    use(v);
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v)
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+    }
+    
+    use(v);
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop4.ts b/tests/cases/compiler/capturedLetConstInLoop4.ts
new file mode 100644
index 00000000000..58f05876f89
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop4.ts
@@ -0,0 +1,143 @@
+// @module: system
+
+//======let
+export function exportedFoo() {
+    return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
+}
+
+for (let x of []) {
+    var v0 = x;
+    (function() { return x + v0});
+    (() => x);    
+}
+
+for (let x in []) {
+    var v00 = x;
+    (function() { return x + v00});
+    (() => x);    
+}
+
+for (let x = 0; x < 1; ++x) {
+    var v1 = x;
+    (function() { return x + v1});
+    (() => x);
+}
+
+while (1 === 1) {
+    let x;
+    var v2 = x;
+    (function() { return x + v2});
+    (() => x);
+}
+
+do {
+    let x;
+    var v3 = x;
+    (function() { return x + v3});
+    (() => x);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    var v4 = x;
+    (function() { return x + v4});
+    (() => x);
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    var v5 = x;
+    (function() { return x + y + v5});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    let x, y;
+    var v6 = x;
+    (function() { return x + y + v6});
+    (() => x + y);
+}
+
+do {
+    let x, y;
+    var v7 = x;
+    (function() { return x + y + v7});
+    (() => x + y);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    var v8 = x;
+    (function() { return x + y + v8});
+    (() => x + y);
+}
+
+//======const
+export function exportedFoo2() {
+    return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c;
+}
+
+for (const x of []) {
+    var v0_c = x;
+    (function() { return x + v0_c});
+    (() => x);    
+}
+
+for (const x in []) {
+    var v00_c = x;
+    (function() { return x + v00});
+    (() => x);    
+}
+
+for (const x = 0; x < 1;) {
+    var v1_c = x;
+    (function() { return x + v1_c});
+    (() => x);
+}
+
+while (1 === 1) {
+    const x =1;
+    var v2_c = x;
+    (function() { return x + v2_c});
+    (() => x);
+}
+
+do {
+    const x = 1;
+    var v3_c = x;
+    (function() { return x + v3_c});
+    (() => x);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    var v4_c = x;
+    (function() { return x + v4_c});
+    (() => x);
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    var v5_c = x;
+    (function() { return x + y + v5_c});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    var v6_c = x;
+    (function() { return x + y + v6_c});
+    (() => x + y);
+}
+
+do {
+    const x = 1, y = 1;
+    var v7_c = x;
+    (function() { return x + y + v7_c});
+    (() => x + y);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    var v8_c = x;
+    (function() { return x + y + v8_c});
+    (() => x + y);
+}
diff --git a/tests/cases/compiler/capturedLetConstInLoop4_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop4_ES6.ts
new file mode 100644
index 00000000000..e65c01e90e2
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop4_ES6.ts
@@ -0,0 +1,143 @@
+// @target: ES6
+
+//======let
+export function exportedFoo() {
+    return v0 + v00 + v1 + v2 + v3 + v4 + v5 + v6 + v7 + v8;
+}
+
+for (let x of []) {
+    var v0 = x;
+    (function() { return x + v0});
+    (() => x);    
+}
+
+for (let x in []) {
+    var v00 = x;
+    (function() { return x + v00});
+    (() => x);    
+}
+
+for (let x = 0; x < 1; ++x) {
+    var v1 = x;
+    (function() { return x + v1});
+    (() => x);
+}
+
+while (1 === 1) {
+    let x;
+    var v2 = x;
+    (function() { return x + v2});
+    (() => x);
+}
+
+do {
+    let x;
+    var v3 = x;
+    (function() { return x + v3});
+    (() => x);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    var v4 = x;
+    (function() { return x + v4});
+    (() => x);
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    var v5 = x;
+    (function() { return x + y + v5});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    let x, y;
+    var v6 = x;
+    (function() { return x + y + v6});
+    (() => x + y);
+}
+
+do {
+    let x, y;
+    var v7 = x;
+    (function() { return x + y + v7});
+    (() => x + y);
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    var v8 = x;
+    (function() { return x + y + v8});
+    (() => x + y);
+}
+
+//======const
+export function exportedFoo2() {
+    return v0_c + v00_c + v1_c + v2_c + v3_c + v4_c + v5_c + v6_c + v7_c + v8_c;
+}
+
+for (const x of []) {
+    var v0_c = x;
+    (function() { return x + v0_c});
+    (() => x);    
+}
+
+for (const x in []) {
+    var v00_c = x;
+    (function() { return x + v00});
+    (() => x);    
+}
+
+for (const x = 0; x < 1;) {
+    var v1_c = x;
+    (function() { return x + v1_c});
+    (() => x);
+}
+
+while (1 === 1) {
+    const x =1;
+    var v2_c = x;
+    (function() { return x + v2_c});
+    (() => x);
+}
+
+do {
+    const x = 1;
+    var v3_c = x;
+    (function() { return x + v3_c});
+    (() => x);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    var v4_c = x;
+    (function() { return x + v4_c});
+    (() => x);
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    var v5_c = x;
+    (function() { return x + y + v5_c});
+    (() => x + y);
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    var v6_c = x;
+    (function() { return x + y + v6_c});
+    (() => x + y);
+}
+
+do {
+    const x = 1, y = 1;
+    var v7_c = x;
+    (function() { return x + y + v7_c});
+    (() => x + y);
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    var v8_c = x;
+    (function() { return x + y + v8_c});
+    (() => x + y);
+}
diff --git a/tests/cases/compiler/capturedLetConstInLoop5.ts b/tests/cases/compiler/capturedLetConstInLoop5.ts
new file mode 100644
index 00000000000..475137c14cc
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop5.ts
@@ -0,0 +1,279 @@
+declare function use(a: any);
+
+//====let
+function foo0(x) {
+    for (let x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo00(x) {
+    for (let x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo3(x) {
+    do {
+        let x;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    };
+    
+    use(v)
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+//====const
+function foo0_c(x) {
+    for (const x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo00_c(x) {
+    for (const x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v)
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop5_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop5_ES6.ts
new file mode 100644
index 00000000000..035e21b9e84
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop5_ES6.ts
@@ -0,0 +1,281 @@
+// @target: ES6
+
+declare function use(a: any);
+
+//====let
+function foo0(x) {
+    for (let x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo00(x) {
+    for (let x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo1(x) {
+    for (let x = 0; x < 1; ++x) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo2(x) {
+    while (1 === 1) {
+        let x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo3(x) {
+    do {
+        let x;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+function foo4(x) {
+    for (let y = 0; y < 1; ++y) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo5(x) {
+    for (let x = 0, y = 1; x < 1; ++x) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+
+function foo6(x) {
+    while (1 === 1) {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    };
+    
+    use(v)
+}
+
+function foo7(x) {
+    do {
+        let x, y;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1);
+    
+    use(v);
+}
+
+
+function foo8(x) {
+    for (let y = 0; y < 1; ++y) {
+        let x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+//====const
+function foo0_c(x) {
+    for (const x of []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo00_c(x) {
+    for (const x in []) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo1_c(x) {
+    for (const x = 0; x < 1;) {
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+
+    use(v);
+}
+
+function foo2_c(x) {
+    while (1 === 1) {
+        const x = 1;
+        var v = x;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo3_c(x) {
+    do {
+        const x = 1;
+        var v;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+function foo4_c(x) {
+    for (const y = 0; y < 1;) {
+        var v = y;
+        let x = 1;
+        (function() { return x + v });
+        (() => x + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+function foo5_c(x) {
+    for (const x = 0, y = 1; x < 1;) {
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
+
+
+function foo6_c(x) {
+    while (1 === 1) {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v)
+}
+
+function foo7_c(x) {
+    do {
+        const x = 1, y = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    } while (1 === 1)
+    
+    use(v);
+}
+
+
+function foo8_c(x) {
+    for (const y = 0; y < 1;) {
+        const x = 1;
+        var v = x;
+        (function() { return x + y + v });
+        (() => x + y + v);
+        if (x == 1) {
+            return;
+        }
+    }
+    
+    use(v);
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop6.ts b/tests/cases/compiler/capturedLetConstInLoop6.ts
new file mode 100644
index 00000000000..321d20e3c20
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop6.ts
@@ -0,0 +1,237 @@
+// ====let
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (let x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+// ====const
+
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (const x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
diff --git a/tests/cases/compiler/capturedLetConstInLoop6_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop6_ES6.ts
new file mode 100644
index 00000000000..f43fe5851d2
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop6_ES6.ts
@@ -0,0 +1,238 @@
+// @target: ES6
+// ====let
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (let x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+// ====const
+
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (const x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+} while (1 === 1)
+
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 2) {
+        continue;
+    }
+}
+
diff --git a/tests/cases/compiler/capturedLetConstInLoop7.ts b/tests/cases/compiler/capturedLetConstInLoop7.ts
new file mode 100644
index 00000000000..a1d35c4038b
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop7.ts
@@ -0,0 +1,375 @@
+//===let
+l0:
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l0;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l0;
+    }
+}
+
+l00:
+for (let x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l00;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l00;
+    }
+}
+
+l1:
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l1;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l1;
+    }
+}
+
+l2:
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l2;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l2;
+    }
+}
+
+l3:
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l3;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l3;
+    }
+} while (1 === 1)
+
+l4:
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l4;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l4;
+    }
+}
+
+l5:
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l5;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l5;
+    }
+}
+
+l6:
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l6;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l6;
+    }
+
+}
+
+l7:
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l7;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l7;
+    }
+} while (1 === 1)
+
+l8:
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l8;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l8;
+    }
+}
+
+//===const
+l0_c:
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l0_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l0_c;
+    }
+}
+
+l00_c:
+for (const x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l00_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l00_c;
+    }
+}
+
+l1_c:
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l1_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l1_c;
+    }
+}
+
+l2_c:
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l2_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l2_c;
+    }
+}
+
+l3_c:
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l3_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l3_c;
+    }
+} while (1 === 1)
+
+l4_c:
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l4_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l4_c;
+    }
+}
+
+l5_c:
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l5_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l5_c;
+    }
+}
+
+l6_c:
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l6_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l6_c;
+    }
+
+}
+
+l7_c:
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l7_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l7_c;
+    }
+} while (1 === 1)
+
+l8_c:
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l8_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l8_c;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop7_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop7_ES6.ts
new file mode 100644
index 00000000000..14b1d0c85af
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop7_ES6.ts
@@ -0,0 +1,376 @@
+// @target: ES6
+//===let
+l0:
+for (let x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l0;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l0;
+    }
+}
+
+l00:
+for (let x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l00;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l00;
+    }
+}
+
+l1:
+for (let x = 0; x < 1; ++x) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l1;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l1;
+    }
+}
+
+l2:
+while (1 === 1) {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l2;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l2;
+    }
+}
+
+l3:
+do {
+    let x;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l3;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l3;
+    }
+} while (1 === 1)
+
+l4:
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l4;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l4;
+    }
+}
+
+l5:
+for (let x = 0, y = 1; x < 1; ++x) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l5;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l5;
+    }
+}
+
+l6:
+while (1 === 1) {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l6;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l6;
+    }
+
+}
+
+l7:
+do {
+    let x, y;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l7;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l7;
+    }
+} while (1 === 1)
+
+l8:
+for (let y = 0; y < 1; ++y) {
+    let x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l8;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l8;
+    }
+}
+
+//===const
+l0_c:
+for (const x of []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l0_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l0_c;
+    }
+}
+
+l00_c:
+for (const x in []) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l00_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l00_c;
+    }
+}
+
+l1_c:
+for (const x = 0; x < 1;) {
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l1_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l1_c;
+    }
+}
+
+l2_c:
+while (1 === 1) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l2_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l2_c;
+    }
+}
+
+l3_c:
+do {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l3_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l3_c;
+    }
+} while (1 === 1)
+
+l4_c:
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x});
+    (() => x);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l4_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l4_c;
+    }
+}
+
+l5_c:
+for (const x = 0, y = 1; x < 1;) {
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l5_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l5_c;
+    }
+}
+
+l6_c:
+while (1 === 1) {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l6_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l6_c;
+    }
+
+}
+
+l7_c:
+do {
+    const x = 1, y = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l7_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l7_c;
+    }
+} while (1 === 1)
+
+l8_c:
+for (const y = 0; y < 1;) {
+    const x = 1;
+    (function() { return x + y});
+    (() => x + y);
+    if (x == 1) {
+        break;
+    }
+    if (x == 1) {
+        break l8_c;
+    }
+    if (x == 2) {
+        continue;
+    }
+    if (x == 2) {
+        continue l8_c;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop8.ts b/tests/cases/compiler/capturedLetConstInLoop8.ts
new file mode 100644
index 00000000000..6ae4cd5113e
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop8.ts
@@ -0,0 +1,113 @@
+function foo() {
+    l0:
+    for (let z = 0; z < 1; ++z) {
+        l1:
+        for (let x = 0; x < 1; ++x) {
+            ll1:
+            for (let y = 0; y < 1; ++y) {
+                (function() { return x + y });
+                (() => x + y);
+                if (y == 1) {
+                    break;
+                }
+                if (y == 1) {
+                    break l1;
+                }
+                if (y == 1) {
+                    break ll1;
+                }
+                if (y == 1) {
+                    continue l0;
+                }
+
+                if (x == 2) {
+                    continue;
+                }
+                if (x == 2) {
+                    continue l1;
+                }
+                if (x == 2) {
+                    continue ll1;
+                }
+                if (x == 2) {
+                    return "123"
+                }
+            }
+            if (x == 1) {
+                break;
+            }
+            if (x == 1) {
+                break l1;
+            }
+            if (x == 2) {
+                continue;
+            }
+            if (x == 2) {
+                continue l1;
+            }
+            if (x == 2) {
+                continue l0;
+            }
+            if (x == 2) {
+                return "456";
+            }            
+        }
+    }
+}
+
+function foo_c() {
+    l0:
+    for (const z = 0; z < 1;) {
+        l1:
+        for (const x = 0; x < 1;) {
+            ll1:
+            for (const y = 0; y < 1;) {
+                (function() { return x + y });
+                (() => x + y);
+                if (y == 1) {
+                    break;
+                }
+                if (y == 1) {
+                    break l1;
+                }
+                if (y == 1) {
+                    break ll1;
+                }
+                if (y == 1) {
+                    continue l0;
+                }
+
+                if (x == 2) {
+                    continue;
+                }
+                if (x == 2) {
+                    continue l1;
+                }
+                if (x == 2) {
+                    continue ll1;
+                }
+                if (x == 2) {
+                    return "123"
+                }
+            }
+            if (x == 1) {
+                break;
+            }
+            if (x == 1) {
+                break l1;
+            }
+            if (x == 2) {
+                continue;
+            }
+            if (x == 2) {
+                continue l1;
+            }
+            if (x == 2) {
+                continue l0;
+            }
+            if (x == 2) {
+                return "456";
+            }            
+        }
+    }
+}
diff --git a/tests/cases/compiler/capturedLetConstInLoop8_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop8_ES6.ts
new file mode 100644
index 00000000000..743ee50dad9
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop8_ES6.ts
@@ -0,0 +1,115 @@
+// @target: ES6
+
+function foo() {
+    l0:
+    for (let z = 0; z < 1; ++z) {
+        l1:
+        for (let x = 0; x < 1; ++x) {
+            ll1:
+            for (let y = 0; y < 1; ++y) {
+                (function() { return x + y });
+                (() => x + y);
+                if (y == 1) {
+                    break;
+                }
+                if (y == 1) {
+                    break l1;
+                }
+                if (y == 1) {
+                    break ll1;
+                }
+                if (y == 1) {
+                    continue l0;
+                }
+
+                if (x == 2) {
+                    continue;
+                }
+                if (x == 2) {
+                    continue l1;
+                }
+                if (x == 2) {
+                    continue ll1;
+                }
+                if (x == 2) {
+                    return "123"
+                }
+            }
+            if (x == 1) {
+                break;
+            }
+            if (x == 1) {
+                break l1;
+            }
+            if (x == 2) {
+                continue;
+            }
+            if (x == 2) {
+                continue l1;
+            }
+            if (x == 2) {
+                continue l0;
+            }
+            if (x == 2) {
+                return "456";
+            }            
+        }
+    }
+}
+
+function foo_c() {
+    l0:
+    for (const z = 0; z < 1;) {
+        l1:
+        for (const x = 0; x < 1;) {
+            ll1:
+            for (const y = 0; y < 1;) {
+                (function() { return x + y });
+                (() => x + y);
+                if (y == 1) {
+                    break;
+                }
+                if (y == 1) {
+                    break l1;
+                }
+                if (y == 1) {
+                    break ll1;
+                }
+                if (y == 1) {
+                    continue l0;
+                }
+
+                if (x == 2) {
+                    continue;
+                }
+                if (x == 2) {
+                    continue l1;
+                }
+                if (x == 2) {
+                    continue ll1;
+                }
+                if (x == 2) {
+                    return "123"
+                }
+            }
+            if (x == 1) {
+                break;
+            }
+            if (x == 1) {
+                break l1;
+            }
+            if (x == 2) {
+                continue;
+            }
+            if (x == 2) {
+                continue l1;
+            }
+            if (x == 2) {
+                continue l0;
+            }
+            if (x == 2) {
+                return "456";
+            }            
+        }
+    }
+}
diff --git a/tests/cases/compiler/capturedLetConstInLoop9.ts b/tests/cases/compiler/capturedLetConstInLoop9.ts
new file mode 100644
index 00000000000..1b3e7c11a57
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop9.ts
@@ -0,0 +1,122 @@
+for (let x = 0; x < 1; ++x) {
+    let x;
+    (function() { return x });
+    {
+        let x;
+        (function() { return x });
+    }
+
+    try { }
+    catch (e) {
+        let x;
+        (function() { return x });
+    }
+
+    switch (x) {
+        case 1:
+            let x;
+            (function() { return x });
+           break;
+    }
+    
+    while (1 == 1) {
+        let x;
+        (function() { return x });
+    }
+    
+    class A {
+        m() {
+            return x + 1;
+        }
+    }
+}
+
+declare function use(a: any);
+
+function foo() {
+    l0:
+    for (let a of []) {
+        
+        if (a === 1) {
+            break;
+        }
+        
+        if (a === 2) {
+            break l0;
+        }
+        
+        for (let b of []) {
+            var [{x, y:z}] = [{x:1, y:2}];
+            if (b === 1) {
+                break;
+            }
+            
+            
+            if (b === 2) {
+                break l0;
+            }
+            
+            l1:
+            if (b === 3) {
+                break l1;
+            }
+            
+            return 50;
+        }
+
+        for (let b of []) {
+            var [{x1, y:z1}] = [{x1:1, y:arguments.length}];
+            if (b === 1) {
+                break;
+            }
+            
+            if (b === 2) {
+                break l0;
+            }
+            
+            return 100;
+            
+            () => b
+        }
+
+        
+        () => a;
+    }
+    
+    use(x);
+    use(z);
+    use(x1);
+    use(z1);
+}
+
+function foo2() {
+    for (let x of []) {
+        if (x === 1) {
+            break;
+        }
+        else if (x === 2) {
+            continue;
+        }
+        
+        while (1 === 1) {
+            if (x) {
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        
+        switch(x) {
+            case 1: break;
+            case 2: continue;
+        }
+        
+        for (let y of []) {
+            switch(y) {
+                case 1: break;
+                case 2: continue;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts
new file mode 100644
index 00000000000..92653300898
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts
@@ -0,0 +1,124 @@
+// @target: ES6
+
+for (let x = 0; x < 1; ++x) {
+    let x;
+    (function() { return x });
+    {
+        let x;
+        (function() { return x });
+    }
+
+    try { }
+    catch (e) {
+        let x;
+        (function() { return x });
+    }
+
+    switch (x) {
+        case 1:
+            let x;
+            (function() { return x });
+           break;
+    }
+    
+    while (1 == 1) {
+        let x;
+        (function() { return x });
+    }
+    
+    class A {
+        m() {
+            return x + 1;
+        }
+    }
+}
+
+declare function use(a: any);
+
+function foo() {
+    l0:
+    for (let a of []) {
+        
+        if (a === 1) {
+            break;
+        }
+        
+        if (a === 2) {
+            break l0;
+        }
+        
+        for (let b of []) {
+            var [{x, y:z}] = [{x:1, y:2}];
+            if (b === 1) {
+                break;
+            }
+            
+            
+            if (b === 2) {
+                break l0;
+            }
+            
+            l1:
+            if (b === 3) {
+                break l1;
+            }
+            
+            return 50;
+        }
+
+        for (let b of []) {
+            var [{x1, y:z1}] = [{x1:1, y:arguments.length}];
+            if (b === 1) {
+                break;
+            }
+            
+            if (b === 2) {
+                break l0;
+            }
+            
+            return 100;
+            
+            () => b
+        }
+
+        
+        () => a;
+    }
+    
+    use(x);
+    use(z);
+    use(x1);
+    use(z1);
+}
+
+function foo2() {
+    for (let x of []) {
+        if (x === 1) {
+            break;
+        }
+        else if (x === 2) {
+            continue;
+        }
+        
+        while (1 === 1) {
+            if (x) {
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        
+        switch(x) {
+            case 1: break;
+            case 2: continue;
+        }
+        
+        for (let y of []) {
+            switch(y) {
+                case 1: break;
+                case 2: continue;
+            }
+        }
+    }
+}
\ No newline at end of file

From c13c8bf3160da887d734614b20d372085852bac6 Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Mon, 19 Oct 2015 14:10:27 -0700
Subject: [PATCH 2/4] addressed PR feedback

---
 src/compiler/emitter.ts                       |  90 ++++++------
 .../reference/capturedLetConstInLoop5.js      |  40 +++---
 .../reference/capturedLetConstInLoop8.js      |  28 +++-
 .../reference/capturedLetConstInLoop8.symbols |  74 ++++++----
 .../reference/capturedLetConstInLoop8.types   |  32 ++++-
 .../reference/capturedLetConstInLoop8_ES6.js  |  29 +++-
 .../capturedLetConstInLoop8_ES6.symbols       | 129 ++++++++++--------
 .../capturedLetConstInLoop8_ES6.types         |  33 ++++-
 .../reference/capturedLetConstInLoop9.js      |  44 ++++++
 .../reference/capturedLetConstInLoop9.symbols |  51 +++++++
 .../reference/capturedLetConstInLoop9.types   |  62 +++++++++
 .../reference/capturedLetConstInLoop9_ES6.js  |  34 +++++
 .../capturedLetConstInLoop9_ES6.symbols       |  51 +++++++
 .../capturedLetConstInLoop9_ES6.types         |  62 +++++++++
 .../cases/compiler/capturedLetConstInLoop8.ts |  16 ++-
 .../compiler/capturedLetConstInLoop8_ES6.ts   |  17 ++-
 .../cases/compiler/capturedLetConstInLoop9.ts |  17 +++
 .../compiler/capturedLetConstInLoop9_ES6.ts   |  17 +++
 18 files changed, 671 insertions(+), 155 deletions(-)

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index cd0967c5717..fcee2cb835d 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -386,49 +386,61 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
         }
 
         interface ConvertedLoopState {
-            // set of labels that occured inside the converted loop
-            // used to determine if labeled jump can be emitted as is or it should be dispatched to calling code
+            /*
+             * set of labels that occured inside the converted loop
+             * used to determine if labeled jump can be emitted as is or it should be dispatched to calling code
+             */
             labels?: Map<string>;
-            // collection of labeled jumps that transfer control outside the converted loop.
-            // maps store association 'label -> labelMarker' where
-            // - label - value of label as it apprear in code
-            // - label marker - return value that should be interpreted by calling code as 'jump to <label>' 
+            /*
+             * collection of labeled jumps that transfer control outside the converted loop.
+             * maps store association 'label -> labelMarker' where
+             * - label - value of label as it apprear in code
+             * - label marker - return value that should be interpreted by calling code as 'jump to <label>'
+             */ 
             labeledNonLocalBreaks?: Map<string>;
             labeledNonLocalContinues?: Map<string>;
 
-            // set of non-labeled jumps that transfer control outside the converted loop
-            // used to emit dispatching logic in the caller of converted loop
+            /*
+             * set of non-labeled jumps that transfer control outside the converted loop
+             * used to emit dispatching logic in the caller of converted loop
+             */
             nonLocalJumps?: Jump;
 
-            // set of non-labeled jumps that should be interpreted as local
-            // i.e. if converted loop contains normal loop or switch statement then inside this loop break should be treated as local jump
+            /*
+             * set of non-labeled jumps that should be interpreted as local
+             * i.e. if converted loop contains normal loop or switch statement then inside this loop break should be treated as local jump
+             */
             allowedNonLabeledJumps?: Jump;
 
-            // alias for 'arguments' object from the calling code stack frame
-            // i.e.
-            // for (let x;;) <statement that captures x in closure and uses 'arguments'>
-            // should be converted to
-            // var loop = function(x) { <code where 'arguments' is replaced witg 'arguments_1'> }
-            // var arguments_1 = arguments
-            // for (var x;;) loop(x);
-            // otherwise semantics of the code will be different since 'arguments' inside converted loop body 
-            // will refer to function that holds converted loop.
-            // This value is set on demand.
+            /*
+             * alias for 'arguments' object from the calling code stack frame
+             * i.e.
+             * for (let x;;) <statement that captures x in closure and uses 'arguments'>
+             * should be converted to
+             * var loop = function(x) { <code where 'arguments' is replaced witg 'arguments_1'> }
+             * var arguments_1 = arguments
+             * for (var x;;) loop(x);
+             * otherwise semantics of the code will be different since 'arguments' inside converted loop body 
+             * will refer to function that holds converted loop.
+             * This value is set on demand.
+             */
             argumentsName?: string;
 
-            // list of non-block scoped variable declarations that appear inside converted loop
-            // such variable declarations should be moved outside the loop body 
-            // for (let x;;) {
-            //     var y = 1;
-            //     ... 
-            // }
-            // should be converted to
-            // var loop = function(x) {
-            //    y = 1;
-            //    ...
-            // }
-            // var y;
-            // for (var x;;) loop(x);
+            /*
+             * list of non-block scoped variable declarations that appear inside converted loop
+             * such variable declarations should be moved outside the loop body 
+             * for (let x;;) {
+             *     var y = 1;
+             *     ... 
+             * }
+             * should be converted to
+             * var loop = function(x) {
+             *    y = 1;
+             *    ...
+             * }
+             * var y;
+             * for (var x;;) loop(x);
+             */
             hoistedLocalVariables?: Identifier[];
         }
 
@@ -3187,7 +3199,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 convertedLoopState = {};
 
                 if (convertedOuterLoopState) {
-                    // convertedOuterLoopState !== undefined means that this converted loop is nested in another converted loop
+                    // convertedOuterLoopState !== undefined means that this converted loop is nested in another converted loop.
                     // if outer converted loop has already accumulated some state - pass it through
                     if (convertedOuterLoopState.argumentsName) {
                         // outer loop has already used 'arguments' so we've already have some name to alias it
@@ -3219,8 +3231,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         convertedOuterLoopState.argumentsName = convertedLoopState.argumentsName;
                     }
                     else {
-                        // this is top level converted loop and 
-                        // create an alias for 'arguments' object
+                        // this is top level converted loop and we need to create an alias for 'arguments' object
                         write(`var ${convertedLoopState.argumentsName} = arguments;`);
                         writeLine();
                     }
@@ -3237,12 +3248,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         write("var ");
                         let seen: Map<string>;
                         for (const id of convertedLoopState.hoistedLocalVariables) {
+                           // Don't initialize seen unless we have at least one element.
+                           // Emit a comma to separate for all but the first element.
                            if (!seen) {
                                seen = {};
                            }
                            else {
                                write(", ");
                            }
+
                            if (!hasProperty(seen, id.text)) {
                                emit(id);
                                seen[id.text] = id.text;
@@ -3674,12 +3688,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             function emitReturnStatement(node: ReturnStatement) {
                 if (convertedLoopState) {
                     convertedLoopState.nonLocalJumps |= Jump.Return;
-                    write(`return { value: `);
+                    write("return { value: ");
                     if (node.expression) {
                         emit(node.expression);
                     }
                     else {
-                        write("undefined");
+                        write("void 0");
                     }
                     write(" };");
                     return;
diff --git a/tests/baselines/reference/capturedLetConstInLoop5.js b/tests/baselines/reference/capturedLetConstInLoop5.js
index 0ce9cf3d57c..d7d177a19b9 100644
--- a/tests/baselines/reference/capturedLetConstInLoop5.js
+++ b/tests/baselines/reference/capturedLetConstInLoop5.js
@@ -287,7 +287,7 @@ function foo0(x) {
         (function () { return x_1 + v; });
         (function () { return x_1 + v; });
         if (x_1 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -304,7 +304,7 @@ function foo00(x) {
         (function () { return x_2 + v; });
         (function () { return x_2 + v; });
         if (x_2 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -320,7 +320,7 @@ function foo1(x) {
         (function () { return x_3 + v; });
         (function () { return x_3 + v; });
         if (x_3 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -337,7 +337,7 @@ function foo2(x) {
         (function () { return x_4 + v; });
         (function () { return x_4 + v; });
         if (x_4 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -353,7 +353,7 @@ function foo3(x) {
         (function () { return x_5 + v; });
         (function () { return x_5 + v; });
         if (x_5 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -370,7 +370,7 @@ function foo4(x) {
         (function () { return x_6 + v; });
         (function () { return x_6 + v; });
         if (x_6 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -386,7 +386,7 @@ function foo5(x) {
         (function () { return x_7 + y + v; });
         (function () { return x_7 + y + v; });
         if (x_7 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -403,7 +403,7 @@ function foo6(x) {
         (function () { return x_8 + y + v; });
         (function () { return x_8 + y + v; });
         if (x_8 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -421,7 +421,7 @@ function foo7(x) {
         (function () { return x_9 + y + v; });
         (function () { return x_9 + y + v; });
         if (x_9 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -438,7 +438,7 @@ function foo8(x) {
         (function () { return x_10 + y + v; });
         (function () { return x_10 + y + v; });
         if (x_10 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -455,7 +455,7 @@ function foo0_c(x) {
         (function () { return x_11 + v; });
         (function () { return x_11 + v; });
         if (x_11 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -472,7 +472,7 @@ function foo00_c(x) {
         (function () { return x_12 + v; });
         (function () { return x_12 + v; });
         if (x_12 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -488,7 +488,7 @@ function foo1_c(x) {
         (function () { return x_13 + v; });
         (function () { return x_13 + v; });
         if (x_13 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -505,7 +505,7 @@ function foo2_c(x) {
         (function () { return x_14 + v; });
         (function () { return x_14 + v; });
         if (x_14 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -521,7 +521,7 @@ function foo3_c(x) {
         (function () { return x_15 + v; });
         (function () { return x_15 + v; });
         if (x_15 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -538,7 +538,7 @@ function foo4_c(x) {
         (function () { return x_16 + v; });
         (function () { return x_16 + v; });
         if (x_16 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -554,7 +554,7 @@ function foo5_c(x) {
         (function () { return x_17 + y + v; });
         (function () { return x_17 + y + v; });
         if (x_17 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -571,7 +571,7 @@ function foo6_c(x) {
         (function () { return x_18 + y + v; });
         (function () { return x_18 + y + v; });
         if (x_18 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -588,7 +588,7 @@ function foo7_c(x) {
         (function () { return x_19 + y + v; });
         (function () { return x_19 + y + v; });
         if (x_19 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
@@ -605,7 +605,7 @@ function foo8_c(x) {
         (function () { return x_20 + y + v; });
         (function () { return x_20 + y + v; });
         if (x_20 == 1) {
-            return { value: undefined };
+            return { value: void 0 };
         }
     };
     var v;
diff --git a/tests/baselines/reference/capturedLetConstInLoop8.js b/tests/baselines/reference/capturedLetConstInLoop8.js
index b85d0d61cb8..b10beb7b44e 100644
--- a/tests/baselines/reference/capturedLetConstInLoop8.js
+++ b/tests/baselines/reference/capturedLetConstInLoop8.js
@@ -33,6 +33,9 @@ function foo() {
                 if (x == 2) {
                     return "123"
                 }
+                if (x == 3) {
+                    return;
+                }
             }
             if (x == 1) {
                 break;
@@ -51,7 +54,10 @@ function foo() {
             }
             if (x == 2) {
                 return "456";
-            }            
+            }
+            if (x == 3) {
+                return;
+            }
         }
     }
 }
@@ -90,6 +96,9 @@ function foo_c() {
                 if (x == 2) {
                     return "123"
                 }
+                if (x == 3) {
+                    return;
+                }
             }
             if (x == 1) {
                 break;
@@ -108,7 +117,10 @@ function foo_c() {
             }
             if (x == 2) {
                 return "456";
-            }            
+            }
+            if (x == 3) {
+                return;
+            }
         }
     }
 }
@@ -145,6 +157,9 @@ function foo() {
                 if (x == 2) {
                     return { value: "123" };
                 }
+                if (x == 3) {
+                    return { value: void 0 };
+                }
             };
             ll1: for (var y = 0; y < 1; ++y) {
                 var state_1 = _loop_2(y);
@@ -177,6 +192,9 @@ function foo() {
             if (x == 2) {
                 return { value: "456" };
             }
+            if (x == 3) {
+                return { value: void 0 };
+            }
         };
         l1: for (var x = 0; x < 1; ++x) {
             var state_2 = _loop_1(x);
@@ -221,6 +239,9 @@ function foo_c() {
                 if (x == 2) {
                     return { value: "123" };
                 }
+                if (x == 3) {
+                    return { value: void 0 };
+                }
             };
             ll1: for (var y = 0; y < 1;) {
                 var state_3 = _loop_4(y);
@@ -253,6 +274,9 @@ function foo_c() {
             if (x == 2) {
                 return { value: "456" };
             }
+            if (x == 3) {
+                return { value: void 0 };
+            }
         };
         l1: for (var x = 0; x < 1;) {
             var state_4 = _loop_3(x);
diff --git a/tests/baselines/reference/capturedLetConstInLoop8.symbols b/tests/baselines/reference/capturedLetConstInLoop8.symbols
index 9412c110fe5..9622062c94b 100644
--- a/tests/baselines/reference/capturedLetConstInLoop8.symbols
+++ b/tests/baselines/reference/capturedLetConstInLoop8.symbols
@@ -69,6 +69,11 @@ function foo() {
 
                     return "123"
                 }
+                if (x == 3) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                    return;
+                }
             }
             if (x == 1) {
 >x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
@@ -99,109 +104,124 @@ function foo() {
 >x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
 
                 return "456";
-            }            
+            }
+            if (x == 3) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                return;
+            }
         }
     }
 }
 
 function foo_c() {
->foo_c : Symbol(foo_c, Decl(capturedLetConstInLoop8.ts, 55, 1))
+>foo_c : Symbol(foo_c, Decl(capturedLetConstInLoop8.ts, 61, 1))
 
     l0:
     for (const z = 0; z < 1;) {
->z : Symbol(z, Decl(capturedLetConstInLoop8.ts, 59, 14))
->z : Symbol(z, Decl(capturedLetConstInLoop8.ts, 59, 14))
+>z : Symbol(z, Decl(capturedLetConstInLoop8.ts, 65, 14))
+>z : Symbol(z, Decl(capturedLetConstInLoop8.ts, 65, 14))
 
         l1:
         for (const x = 0; x < 1;) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
             ll1:
             for (const y = 0; y < 1;) {
->y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
->y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
 
                 (function() { return x + y });
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
->y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
 
                 (() => x + y);
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
->y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
 
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
 
                     break;
                 }
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
 
                     break l1;
                 }
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
 
                     break ll1;
                 }
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 63, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
 
                     continue l0;
                 }
 
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
                     continue;
                 }
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
                     continue l1;
                 }
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
                     continue ll1;
                 }
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
                     return "123"
                 }
+                if (x == 3) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+
+                    return;
+                }
             }
             if (x == 1) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
                 break;
             }
             if (x == 1) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
                 break l1;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
                 continue;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
                 continue l1;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
                 continue l0;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 61, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
 
                 return "456";
-            }            
+            }
+            if (x == 3) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+
+                return;
+            }
         }
     }
 }
diff --git a/tests/baselines/reference/capturedLetConstInLoop8.types b/tests/baselines/reference/capturedLetConstInLoop8.types
index 89b488c2393..9c3db88535c 100644
--- a/tests/baselines/reference/capturedLetConstInLoop8.types
+++ b/tests/baselines/reference/capturedLetConstInLoop8.types
@@ -115,6 +115,13 @@ function foo() {
                     return "123"
 >"123" : string
                 }
+                if (x == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                    return;
+                }
             }
             if (x == 1) {
 >x == 1 : boolean
@@ -161,7 +168,14 @@ function foo() {
 
                 return "456";
 >"456" : string
-            }            
+            }
+            if (x == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                return;
+            }
         }
     }
 }
@@ -276,6 +290,13 @@ function foo_c() {
                     return "123"
 >"123" : string
                 }
+                if (x == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                    return;
+                }
             }
             if (x == 1) {
 >x == 1 : boolean
@@ -322,7 +343,14 @@ function foo_c() {
 
                 return "456";
 >"456" : string
-            }            
+            }
+            if (x == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                return;
+            }
         }
     }
 }
diff --git a/tests/baselines/reference/capturedLetConstInLoop8_ES6.js b/tests/baselines/reference/capturedLetConstInLoop8_ES6.js
index 7763fd3a88d..71d0ecd4c4c 100644
--- a/tests/baselines/reference/capturedLetConstInLoop8_ES6.js
+++ b/tests/baselines/reference/capturedLetConstInLoop8_ES6.js
@@ -1,5 +1,4 @@
 //// [capturedLetConstInLoop8_ES6.ts]
-
 function foo() {
     l0:
     for (let z = 0; z < 1; ++z) {
@@ -34,6 +33,9 @@ function foo() {
                 if (x == 2) {
                     return "123"
                 }
+                if (x == 3) {
+                    return;
+                }
             }
             if (x == 1) {
                 break;
@@ -52,7 +54,10 @@ function foo() {
             }
             if (x == 2) {
                 return "456";
-            }            
+            }
+            if (x == 3) {
+                return;
+            }
         }
     }
 }
@@ -91,6 +96,9 @@ function foo_c() {
                 if (x == 2) {
                     return "123"
                 }
+                if (x == 3) {
+                    return;
+                }
             }
             if (x == 1) {
                 break;
@@ -109,7 +117,10 @@ function foo_c() {
             }
             if (x == 2) {
                 return "456";
-            }            
+            }
+            if (x == 3) {
+                return;
+            }
         }
     }
 }
@@ -146,6 +157,9 @@ function foo() {
                 if (x == 2) {
                     return "123";
                 }
+                if (x == 3) {
+                    return;
+                }
             }
             if (x == 1) {
                 break;
@@ -165,6 +179,9 @@ function foo() {
             if (x == 2) {
                 return "456";
             }
+            if (x == 3) {
+                return;
+            }
         }
     }
 }
@@ -198,6 +215,9 @@ function foo_c() {
                 if (x == 2) {
                     return "123";
                 }
+                if (x == 3) {
+                    return;
+                }
             }
             if (x == 1) {
                 break;
@@ -217,6 +237,9 @@ function foo_c() {
             if (x == 2) {
                 return "456";
             }
+            if (x == 3) {
+                return;
+            }
         }
     }
 }
diff --git a/tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols
index 2ab5698c778..01ca5f227f4 100644
--- a/tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols
+++ b/tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols
@@ -1,208 +1,227 @@
 === tests/cases/compiler/capturedLetConstInLoop8_ES6.ts ===
-
 function foo() {
 >foo : Symbol(foo, Decl(capturedLetConstInLoop8_ES6.ts, 0, 0))
 
     l0:
     for (let z = 0; z < 1; ++z) {
->z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 3, 12))
->z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 3, 12))
->z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 3, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 2, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 2, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 2, 12))
 
         l1:
         for (let x = 0; x < 1; ++x) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
             ll1:
             for (let y = 0; y < 1; ++y) {
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
 
                 (function() { return x + y });
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
 
                 (() => x + y);
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
 
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
 
                     break;
                 }
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
 
                     break l1;
                 }
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
 
                     break ll1;
                 }
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 7, 20))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
 
                     continue l0;
                 }
 
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
                     continue;
                 }
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
                     continue l1;
                 }
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
                     continue ll1;
                 }
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
                     return "123"
                 }
+                if (x == 3) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+
+                    return;
+                }
             }
             if (x == 1) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
                 break;
             }
             if (x == 1) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
                 break l1;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
                 continue;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
                 continue l1;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
                 continue l0;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 5, 16))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
 
                 return "456";
-            }            
+            }
+            if (x == 3) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+
+                return;
+            }
         }
     }
 }
 
 function foo_c() {
->foo_c : Symbol(foo_c, Decl(capturedLetConstInLoop8_ES6.ts, 56, 1))
+>foo_c : Symbol(foo_c, Decl(capturedLetConstInLoop8_ES6.ts, 61, 1))
 
     l0:
     for (const z = 0; z < 1;) {
->z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 60, 14))
->z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 60, 14))
+>z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 65, 14))
+>z : Symbol(z, Decl(capturedLetConstInLoop8_ES6.ts, 65, 14))
 
         l1:
         for (const x = 0; x < 1;) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
             ll1:
             for (const y = 0; y < 1;) {
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
 
                 (function() { return x + y });
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
 
                 (() => x + y);
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
 
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
 
                     break;
                 }
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
 
                     break l1;
                 }
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
 
                     break ll1;
                 }
                 if (y == 1) {
->y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 64, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
 
                     continue l0;
                 }
 
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
                     continue;
                 }
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
                     continue l1;
                 }
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
                     continue ll1;
                 }
                 if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
                     return "123"
                 }
+                if (x == 3) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+
+                    return;
+                }
             }
             if (x == 1) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
                 break;
             }
             if (x == 1) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
                 break l1;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
                 continue;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
                 continue l1;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
                 continue l0;
             }
             if (x == 2) {
->x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 62, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
 
                 return "456";
-            }            
+            }
+            if (x == 3) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+
+                return;
+            }
         }
     }
 }
diff --git a/tests/baselines/reference/capturedLetConstInLoop8_ES6.types b/tests/baselines/reference/capturedLetConstInLoop8_ES6.types
index bb6d389e75b..7911e9b63a2 100644
--- a/tests/baselines/reference/capturedLetConstInLoop8_ES6.types
+++ b/tests/baselines/reference/capturedLetConstInLoop8_ES6.types
@@ -1,5 +1,4 @@
 === tests/cases/compiler/capturedLetConstInLoop8_ES6.ts ===
-
 function foo() {
 >foo : () => string
 
@@ -116,6 +115,13 @@ function foo() {
                     return "123"
 >"123" : string
                 }
+                if (x == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                    return;
+                }
             }
             if (x == 1) {
 >x == 1 : boolean
@@ -162,7 +168,14 @@ function foo() {
 
                 return "456";
 >"456" : string
-            }            
+            }
+            if (x == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                return;
+            }
         }
     }
 }
@@ -277,6 +290,13 @@ function foo_c() {
                     return "123"
 >"123" : string
                 }
+                if (x == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                    return;
+                }
             }
             if (x == 1) {
 >x == 1 : boolean
@@ -323,7 +343,14 @@ function foo_c() {
 
                 return "456";
 >"456" : string
-            }            
+            }
+            if (x == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                return;
+            }
         }
     }
 }
diff --git a/tests/baselines/reference/capturedLetConstInLoop9.js b/tests/baselines/reference/capturedLetConstInLoop9.js
index 1a55c362574..ecdf54d6fd1 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9.js
+++ b/tests/baselines/reference/capturedLetConstInLoop9.js
@@ -120,6 +120,23 @@ function foo2() {
             }
         }
     }
+}
+
+class C {
+    constructor(private N: number) { }
+    foo() {
+        for (let i = 0; i < 100; i++) {
+            let f = () => this.N * i;
+        }
+    }
+}
+
+function foo3 () {
+    let x = arguments.length;
+    for (let y of []) {
+        let z = arguments.length;
+        (function() { return y + z + arguments.length; });
+    }
 }
 
 //// [capturedLetConstInLoop9.js]
@@ -250,3 +267,30 @@ function foo2() {
         }
     }
 }
+var C = (function () {
+    function C(N) {
+        this.N = N;
+    }
+    C.prototype.foo = function () {
+        var _this = this;
+        var _loop_5 = function(i) {
+            var f = function () { return _this.N * i; };
+        };
+        for (var i = 0; i < 100; i++) {
+            _loop_5(i);
+        }
+    };
+    return C;
+})();
+function foo3() {
+    var x = arguments.length;
+    var _loop_6 = function(y) {
+        var z = arguments_2.length;
+        (function () { return y + z + arguments.length; });
+    };
+    var arguments_2 = arguments;
+    for (var _i = 0, _a = []; _i < _a.length; _i++) {
+        var y = _a[_i];
+        _loop_6(y);
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop9.symbols b/tests/baselines/reference/capturedLetConstInLoop9.symbols
index 2a3aa1672c6..5ccc1c399f3 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9.symbols
+++ b/tests/baselines/reference/capturedLetConstInLoop9.symbols
@@ -217,3 +217,54 @@ function foo2() {
         }
     }
 }
+
+class C {
+>C : Symbol(C, Decl(capturedLetConstInLoop9.ts, 121, 1))
+
+    constructor(private N: number) { }
+>N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 124, 16))
+
+    foo() {
+>foo : Symbol(foo, Decl(capturedLetConstInLoop9.ts, 124, 38))
+
+        for (let i = 0; i < 100; i++) {
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16))
+
+            let f = () => this.N * i;
+>f : Symbol(f, Decl(capturedLetConstInLoop9.ts, 127, 15))
+>this.N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 124, 16))
+>this : Symbol(C, Decl(capturedLetConstInLoop9.ts, 121, 1))
+>N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 124, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 126, 16))
+        }
+    }
+}
+
+function foo3 () {
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9.ts, 130, 1))
+
+    let x = arguments.length;
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 133, 7))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+    for (let y of []) {
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 134, 12))
+
+        let z = arguments.length;
+>z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 135, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return y + z + arguments.length; });
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 134, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 135, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop9.types b/tests/baselines/reference/capturedLetConstInLoop9.types
index 6146f4347b7..5a19361b02e 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9.types
+++ b/tests/baselines/reference/capturedLetConstInLoop9.types
@@ -295,3 +295,65 @@ function foo2() {
         }
     }
 }
+
+class C {
+>C : C
+
+    constructor(private N: number) { }
+>N : number
+
+    foo() {
+>foo : () => void
+
+        for (let i = 0; i < 100; i++) {
+>i : number
+>0 : number
+>i < 100 : boolean
+>i : number
+>100 : number
+>i++ : number
+>i : number
+
+            let f = () => this.N * i;
+>f : () => number
+>() => this.N * i : () => number
+>this.N * i : number
+>this.N : number
+>this : this
+>N : number
+>i : number
+        }
+    }
+}
+
+function foo3 () {
+>foo3 : () => void
+
+    let x = arguments.length;
+>x : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+    for (let y of []) {
+>y : any
+>[] : undefined[]
+
+        let z = arguments.length;
+>z : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return y + z + arguments.length; });
+>(function() { return y + z + arguments.length; }) : () => any
+>function() { return y + z + arguments.length; } : () => any
+>y + z + arguments.length : any
+>y + z : any
+>y : any
+>z : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js
index 9df7d1e58bd..4605cada8a3 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.js
+++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js
@@ -121,6 +121,23 @@ function foo2() {
             }
         }
     }
+}
+
+class C {
+    constructor(private N: number) { }
+    foo() {
+        for (let i = 0; i < 100; i++) {
+            let f = () => this.N * i;
+        }
+    }
+}
+
+function foo3 () {
+    let x = arguments.length;
+    for (let y of []) {
+        let z = arguments.length;
+        (function() { return y + z + arguments.length; });
+    }
 }
 
 //// [capturedLetConstInLoop9_ES6.js]
@@ -219,3 +236,20 @@ function foo2() {
         }
     }
 }
+class C {
+    constructor(N) {
+        this.N = N;
+    }
+    foo() {
+        for (let i = 0; i < 100; i++) {
+            let f = () => this.N * i;
+        }
+    }
+}
+function foo3() {
+    let x = arguments.length;
+    for (let y of []) {
+        let z = arguments.length;
+        (function () { return y + z + arguments.length; });
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
index dae7aafd89f..d1d124b85f7 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
+++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
@@ -218,3 +218,54 @@ function foo2() {
         }
     }
 }
+
+class C {
+>C : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 122, 1))
+
+    constructor(private N: number) { }
+>N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
+
+    foo() {
+>foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 125, 38))
+
+        for (let i = 0; i < 100; i++) {
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16))
+
+            let f = () => this.N * i;
+>f : Symbol(f, Decl(capturedLetConstInLoop9_ES6.ts, 128, 15))
+>this.N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
+>this : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 122, 1))
+>N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 127, 16))
+        }
+    }
+}
+
+function foo3 () {
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9_ES6.ts, 131, 1))
+
+    let x = arguments.length;
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 134, 7))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+    for (let y of []) {
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 135, 12))
+
+        let z = arguments.length;
+>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 136, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+
+        (function() { return y + z + arguments.length; });
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 135, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 136, 11))
+>arguments.length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+>arguments : Symbol(arguments)
+>length : Symbol(IArguments.length, Decl(lib.d.ts, --, --))
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types
index 1931927a4d8..e5afe21a29f 100644
--- a/tests/baselines/reference/capturedLetConstInLoop9_ES6.types
+++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types
@@ -296,3 +296,65 @@ function foo2() {
         }
     }
 }
+
+class C {
+>C : C
+
+    constructor(private N: number) { }
+>N : number
+
+    foo() {
+>foo : () => void
+
+        for (let i = 0; i < 100; i++) {
+>i : number
+>0 : number
+>i < 100 : boolean
+>i : number
+>100 : number
+>i++ : number
+>i : number
+
+            let f = () => this.N * i;
+>f : () => number
+>() => this.N * i : () => number
+>this.N * i : number
+>this.N : number
+>this : this
+>N : number
+>i : number
+        }
+    }
+}
+
+function foo3 () {
+>foo3 : () => void
+
+    let x = arguments.length;
+>x : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+    for (let y of []) {
+>y : any
+>[] : undefined[]
+
+        let z = arguments.length;
+>z : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+
+        (function() { return y + z + arguments.length; });
+>(function() { return y + z + arguments.length; }) : () => any
+>function() { return y + z + arguments.length; } : () => any
+>y + z + arguments.length : any
+>y + z : any
+>y : any
+>z : number
+>arguments.length : number
+>arguments : IArguments
+>length : number
+    }
+}
diff --git a/tests/cases/compiler/capturedLetConstInLoop8.ts b/tests/cases/compiler/capturedLetConstInLoop8.ts
index 6ae4cd5113e..0467267626c 100644
--- a/tests/cases/compiler/capturedLetConstInLoop8.ts
+++ b/tests/cases/compiler/capturedLetConstInLoop8.ts
@@ -32,6 +32,9 @@ function foo() {
                 if (x == 2) {
                     return "123"
                 }
+                if (x == 3) {
+                    return;
+                }
             }
             if (x == 1) {
                 break;
@@ -50,7 +53,10 @@ function foo() {
             }
             if (x == 2) {
                 return "456";
-            }            
+            }
+            if (x == 3) {
+                return;
+            }
         }
     }
 }
@@ -89,6 +95,9 @@ function foo_c() {
                 if (x == 2) {
                     return "123"
                 }
+                if (x == 3) {
+                    return;
+                }
             }
             if (x == 1) {
                 break;
@@ -107,7 +116,10 @@ function foo_c() {
             }
             if (x == 2) {
                 return "456";
-            }            
+            }
+            if (x == 3) {
+                return;
+            }
         }
     }
 }
diff --git a/tests/cases/compiler/capturedLetConstInLoop8_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop8_ES6.ts
index 743ee50dad9..0cad7bad6a7 100644
--- a/tests/cases/compiler/capturedLetConstInLoop8_ES6.ts
+++ b/tests/cases/compiler/capturedLetConstInLoop8_ES6.ts
@@ -1,5 +1,4 @@
 // @target: ES6
-
 function foo() {
     l0:
     for (let z = 0; z < 1; ++z) {
@@ -34,6 +33,9 @@ function foo() {
                 if (x == 2) {
                     return "123"
                 }
+                if (x == 3) {
+                    return;
+                }
             }
             if (x == 1) {
                 break;
@@ -52,7 +54,10 @@ function foo() {
             }
             if (x == 2) {
                 return "456";
-            }            
+            }
+            if (x == 3) {
+                return;
+            }
         }
     }
 }
@@ -91,6 +96,9 @@ function foo_c() {
                 if (x == 2) {
                     return "123"
                 }
+                if (x == 3) {
+                    return;
+                }
             }
             if (x == 1) {
                 break;
@@ -109,7 +117,10 @@ function foo_c() {
             }
             if (x == 2) {
                 return "456";
-            }            
+            }
+            if (x == 3) {
+                return;
+            }
         }
     }
 }
diff --git a/tests/cases/compiler/capturedLetConstInLoop9.ts b/tests/cases/compiler/capturedLetConstInLoop9.ts
index 1b3e7c11a57..8163a75c20b 100644
--- a/tests/cases/compiler/capturedLetConstInLoop9.ts
+++ b/tests/cases/compiler/capturedLetConstInLoop9.ts
@@ -119,4 +119,21 @@ function foo2() {
             }
         }
     }
+}
+
+class C {
+    constructor(private N: number) { }
+    foo() {
+        for (let i = 0; i < 100; i++) {
+            let f = () => this.N * i;
+        }
+    }
+}
+
+function foo3 () {
+    let x = arguments.length;
+    for (let y of []) {
+        let z = arguments.length;
+        (function() { return y + z + arguments.length; });
+    }
 }
\ No newline at end of file
diff --git a/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts
index 92653300898..e11cf6d344a 100644
--- a/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts
+++ b/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts
@@ -121,4 +121,21 @@ function foo2() {
             }
         }
     }
+}
+
+class C {
+    constructor(private N: number) { }
+    foo() {
+        for (let i = 0; i < 100; i++) {
+            let f = () => this.N * i;
+        }
+    }
+}
+
+function foo3 () {
+    let x = arguments.length;
+    for (let y of []) {
+        let z = arguments.length;
+        (function() { return y + z + arguments.length; });
+    }
 }
\ No newline at end of file

From f279c82409aa5863be876620b6b32278df279611 Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Mon, 19 Oct 2015 14:21:53 -0700
Subject: [PATCH 3/4] fix linter issues

---
 src/compiler/emitter.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index fcee2cb835d..405af1c3304 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -396,7 +396,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
              * maps store association 'label -> labelMarker' where
              * - label - value of label as it apprear in code
              * - label marker - return value that should be interpreted by calling code as 'jump to <label>'
-             */ 
+             */
             labeledNonLocalBreaks?: Map<string>;
             labeledNonLocalContinues?: Map<string>;
 

From d2045a8784ecf196b7f2d7b5dd077a0d190be842 Mon Sep 17 00:00:00 2001
From: Vladimir Matveev <vladima@microsoft.com>
Date: Mon, 19 Oct 2015 15:51:20 -0700
Subject: [PATCH 4/4] fix typo

---
 src/compiler/emitter.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 73c67cd9b49..85ccbf5d8db 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -3891,7 +3891,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 write(": ");
             }
 
-            function emitLabelledStatement(node: LabeledStatement) {
+            function emitLabeledStatement(node: LabeledStatement) {
                 if (!isIterationStatement(node.statement, /* lookInLabeledStatements */ false) || !shouldConvertLoopBody(<IterationStatement>node.statement)) {
                     emitLabelAndColon(node);
                 }
@@ -7889,7 +7889,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     case SyntaxKind.DefaultClause:
                         return emitCaseOrDefaultClause(<CaseOrDefaultClause>node);
                     case SyntaxKind.LabeledStatement:
-                        return emitLabelledStatement(<LabeledStatement>node);
+                        return emitLabeledStatement(<LabeledStatement>node);
                     case SyntaxKind.ThrowStatement:
                         return emitThrowStatement(<ThrowStatement>node);
                     case SyntaxKind.TryStatement: