diff --git a/Jakefile.js b/Jakefile.js
index 5b93462d855..dae99085bef 100644
--- a/Jakefile.js
+++ b/Jakefile.js
@@ -626,9 +626,7 @@ function deleteTemporaryProjectOutput() {
     }
 }
 
-var testTimeout = 20000;
-desc("Runs the tests using the built run.js file. Syntax is jake runtests. Optional parameters 'host=', 'tests=[regex], reporter=[list|spec|json|<more>]', debug=true.");
-task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
+function runConsoleTests(defaultReporter, defaultSubsets, postLint) {
     cleanTestDirs();
     var debug = process.env.debug || process.env.d;
     tests = process.env.test || process.env.tests || process.env.t;
@@ -638,7 +636,7 @@ task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
         fs.unlinkSync(testConfigFile);
     }
 
-    if(tests || light) {
+    if (tests || light) {
         writeTestConfigFile(tests, light, testConfigFile);
     }
 
@@ -648,20 +646,48 @@ task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
 
     colors = process.env.colors || process.env.color
     colors = colors ? ' --no-colors ' : ' --colors ';
-    tests = tests ? ' -g ' + tests : '';
-    reporter = process.env.reporter || process.env.r || 'mocha-fivemat-progress-reporter';
+    reporter = process.env.reporter || process.env.r || defaultReporter;
+
     // timeout normally isn't necessary but Travis-CI has been timing out on compiler baselines occasionally
     // default timeout is 2sec which really should be enough, but maybe we just need a small amount longer
-    var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + ' -t ' + testTimeout + ' ' + run;
-    console.log(cmd);
-    exec(cmd, function() {
-        deleteTemporaryProjectOutput();
-        var lint = jake.Task['lint'];
-        lint.addListener('complete', function () {
-            complete();
+    var subsetRegexes;
+    if(defaultSubsets.length === 0) {
+        subsetRegexes = [tests]
+    }
+    else {
+        var subsets = tests ? tests.split("|") : defaultSubsets;
+        subsetRegexes = subsets.map(function (sub) { return "^" + sub + ".*$"; });
+        subsetRegexes.push("^(?!" + subsets.join("|") + ").*$");
+    }
+    subsetRegexes.forEach(function (subsetRegex) {
+        tests = subsetRegex ? ' -g "' + subsetRegex + '"' : '';
+        var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + ' -t ' + testTimeout + ' ' + run;
+        console.log(cmd);
+        exec(cmd, function () {
+            deleteTemporaryProjectOutput();
+            if (postLint) {
+                var lint = jake.Task['lint'];
+                lint.addListener('complete', function () {
+                    complete();
+                });
+                lint.invoke();
+            }
+            else {
+                complete();
+            }
         });
-        lint.invoke();
     });
+}
+
+var testTimeout = 20000;
+desc("Runs all the tests in parallel using the built run.js file. Optional arguments are: t[ests]=category1|category2|... d[ebug]=true.");
+task("runtests-parallel", ["build-rules", "tests", builtLocalDirectory], function() {
+    runConsoleTests('min', ['compiler', 'conformance', 'Projects', 'fourslash']);
+}, {async: true});
+
+desc("Runs the tests using the built run.js file. Optional arguments are: t[ests]=regex r[eporter]=[list|spec|json|<more>] d[ebug]=true color[s]=false.");
+task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
+    runConsoleTests('mocha-fivemat-progress-reporter', [], /*postLint*/ true);
 }, {async: true});
 
 desc("Generates code coverage data via instanbul");
@@ -820,7 +846,8 @@ var tslintRuleDir = "scripts/tslint";
 var tslintRules = ([
     "nextLineRule",
     "noNullRule",
-    "booleanTriviaRule"
+    "booleanTriviaRule",
+    "typeOperatorSpacingRule"
 ]);
 var tslintRulesFiles = tslintRules.map(function(p) {
     return path.join(tslintRuleDir, p + ".ts");
diff --git a/scripts/processDiagnosticMessages.ts b/scripts/processDiagnosticMessages.ts
index 1eead82d9fe..26632ba6bab 100644
--- a/scripts/processDiagnosticMessages.ts
+++ b/scripts/processDiagnosticMessages.ts
@@ -18,6 +18,13 @@ function main(): void {
         return;
     }
 
+    function writeFile(fileName: string, contents: string) {
+        // TODO: Fix path joining
+        var inputDirectory = inputFilePath.substr(0,inputFilePath.lastIndexOf("/"));
+        var fileOutputPath = inputDirectory + "/" + fileName;
+        sys.writeFile(fileOutputPath, contents);
+    }
+
     var inputFilePath = sys.args[0].replace(/\\/g, "/");
     var inputStr = sys.readFile(inputFilePath);
     
@@ -28,11 +35,10 @@ function main(): void {
 
     var infoFileOutput = buildInfoFileOutput(diagnosticMessages, nameMap);
     checkForUniqueCodes(names, diagnosticMessages);
+    writeFile("diagnosticInformationMap.generated.ts", infoFileOutput);
 
-    // TODO: Fix path joining
-    var inputDirectory = inputFilePath.substr(0,inputFilePath.lastIndexOf("/"));
-    var fileOutputPath = inputDirectory + "/diagnosticInformationMap.generated.ts";
-    sys.writeFile(fileOutputPath, infoFileOutput);
+    var messageOutput = buildDiagnosticMessageOutput(diagnosticMessages, nameMap);
+    writeFile("diagnosticMessages.generated.json", messageOutput);
 }
 
 function checkForUniqueCodes(messages: string[], diagnosticTable: InputDiagnosticMessageTable) {
@@ -85,12 +91,14 @@ function buildInfoFileOutput(messageTable: InputDiagnosticMessageTable, nameMap:
     for (var i = 0; i < names.length; i++) {
         var name = names[i];
         var diagnosticDetails = messageTable[name];
+        var propName = convertPropertyName(nameMap[name]);
 
         result +=
-        '        ' + convertPropertyName(nameMap[name]) +
+        '        ' + propName +
         ': { code: ' + diagnosticDetails.code +
         ', category: DiagnosticCategory.' + diagnosticDetails.category +
-        ', key: "' + name.replace(/[\"]/g, '\\"') + '"' +
+        ', key: "' + createKey(propName, diagnosticDetails.code) + '"' +
+        ', message: "' + name.replace(/[\"]/g, '\\"') + '"' +
         ' },\r\n';
     }
 
@@ -99,6 +107,30 @@ function buildInfoFileOutput(messageTable: InputDiagnosticMessageTable, nameMap:
     return result;
 }
 
+function buildDiagnosticMessageOutput(messageTable: InputDiagnosticMessageTable, nameMap: ts.Map<string>): string {
+    var result =
+        '{';
+    var names = Utilities.getObjectKeys(messageTable);
+    for (var i = 0; i < names.length; i++) {
+        var name = names[i];
+        var diagnosticDetails = messageTable[name];
+        var propName = convertPropertyName(nameMap[name]);
+
+        result += '\r\n  "' + createKey(propName, diagnosticDetails.code) + '"' + ' : "' + name.replace(/[\"]/g, '\\"') + '"';
+        if (i !== names.length - 1) {
+            result += ',';
+        }
+    }
+
+    result += '\r\n}';
+
+    return result;
+}
+
+function createKey(name: string, code: number) : string {
+    return name.slice(0, 100) + '_' + code;
+}
+
 function convertPropertyName(origName: string): string {
     var result = origName.split("").map(char => {
         if (char === '*') { return "_Asterisk"; }
diff --git a/scripts/tslint/typeOperatorSpacingRule.ts b/scripts/tslint/typeOperatorSpacingRule.ts
new file mode 100644
index 00000000000..23925493340
--- /dev/null
+++ b/scripts/tslint/typeOperatorSpacingRule.ts
@@ -0,0 +1,29 @@
+/// <reference path="../../node_modules/tslint/typings/typescriptServices.d.ts" />
+/// <reference path="../../node_modules/tslint/lib/tslint.d.ts" />
+
+
+export class Rule extends Lint.Rules.AbstractRule {
+    public static FAILURE_STRING = "The '|' and '&' operators must be surrounded by single spaces";
+
+    public apply(sourceFile: ts.SourceFile): Lint.RuleFailure[] {
+        return this.applyWithWalker(new TypeOperatorSpacingWalker(sourceFile, this.getOptions()));
+    }
+}
+
+class TypeOperatorSpacingWalker extends Lint.RuleWalker {
+    public visitNode(node: ts.Node) {
+        if (node.kind === ts.SyntaxKind.UnionType || node.kind === ts.SyntaxKind.IntersectionType) {
+            let types = (<ts.UnionOrIntersectionTypeNode>node).types;
+            let expectedStart = types[0].end + 2; // space, | or &
+            for (let i = 1; i < types.length; i++) {
+                let currentType = types[i];
+                if (expectedStart !== currentType.pos || currentType.getLeadingTriviaWidth() !== 1) {
+                    const failure = this.createFailure(currentType.pos, currentType.getWidth(), Rule.FAILURE_STRING);
+                    this.addFailure(failure);
+                }
+                expectedStart = currentType.end + 2;
+            }
+        }
+        super.visitNode(node);
+    }
+}
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 8e2fa3a89f9..51acf06e2d6 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -2847,23 +2847,29 @@ namespace ts {
             return type.resolvedBaseConstructorType;
         }
 
+        function hasClassBaseType(type: InterfaceType): boolean {
+            return !!forEach(getBaseTypes(type), t => !!(t.symbol.flags & SymbolFlags.Class));
+        }
+
         function getBaseTypes(type: InterfaceType): ObjectType[] {
+            let isClass = type.symbol.flags & SymbolFlags.Class;
+            let isInterface = type.symbol.flags & SymbolFlags.Interface;
             if (!type.resolvedBaseTypes) {
-                if (type.symbol.flags & SymbolFlags.Class) {
+                if (!isClass && !isInterface) {
+                    Debug.fail("type must be class or interface");
+                }
+                if (isClass) {
                     resolveBaseTypesOfClass(type);
                 }
-                else if (type.symbol.flags & SymbolFlags.Interface) {
+                if (isInterface) {
                     resolveBaseTypesOfInterface(type);
                 }
-                else {
-                    Debug.fail("type must be class or interface");
-                }
             }
             return type.resolvedBaseTypes;
         }
 
         function resolveBaseTypesOfClass(type: InterfaceType): void {
-            type.resolvedBaseTypes = emptyArray;
+            type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
             let baseContructorType = getBaseConstructorTypeOfClass(type);
             if (!(baseContructorType.flags & TypeFlags.ObjectType)) {
                 return;
@@ -2899,11 +2905,16 @@ namespace ts {
                     typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType));
                 return;
             }
-            type.resolvedBaseTypes = [baseType];
+            if (type.resolvedBaseTypes === emptyArray) {
+                type.resolvedBaseTypes = [baseType];
+            }
+            else {
+                type.resolvedBaseTypes.push(baseType);
+            }
         }
 
         function resolveBaseTypesOfInterface(type: InterfaceType): void {
-            type.resolvedBaseTypes = [];
+            type.resolvedBaseTypes = type.resolvedBaseTypes || emptyArray;
             for (let declaration of type.symbol.declarations) {
                 if (declaration.kind === SyntaxKind.InterfaceDeclaration && getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
                     for (let node of getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
@@ -2911,7 +2922,12 @@ namespace ts {
                         if (baseType !== unknownType) {
                             if (getTargetType(baseType).flags & (TypeFlags.Class | TypeFlags.Interface)) {
                                 if (type !== baseType && !hasBaseType(<InterfaceType>baseType, type)) {
-                                    type.resolvedBaseTypes.push(baseType);
+                                    if (type.resolvedBaseTypes === emptyArray) {
+                                        type.resolvedBaseTypes = [baseType];
+                                    }
+                                    else {
+                                        type.resolvedBaseTypes.push(baseType);
+                                    }
                                 }
                                 else {
                                     error(declaration, Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType));
@@ -3254,7 +3270,7 @@ namespace ts {
         }
 
         function getDefaultConstructSignatures(classType: InterfaceType): Signature[] {
-            if (!getBaseTypes(classType).length) {
+            if (!hasClassBaseType(classType)) {
                 return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, undefined, 0, false, false)];
             }
             let baseConstructorType = getBaseConstructorTypeOfClass(classType);
@@ -5622,11 +5638,10 @@ namespace ts {
             // M and N (the signatures) are instantiated using type Any as the type argument for all type parameters declared by M and N
             source = getErasedSignature(source);
             target = getErasedSignature(target);
-            let sourceLen = source.parameters.length;
             let targetLen = target.parameters.length;
             for (let i = 0; i < targetLen; i++) {
-                let s = source.hasRestParameter && i === sourceLen - 1 ? getRestTypeOfSignature(source) : getTypeOfSymbol(source.parameters[i]);
-                let t = target.hasRestParameter && i === targetLen - 1 ? getRestTypeOfSignature(target) : getTypeOfSymbol(target.parameters[i]);
+                let s = isRestParameterIndex(source, i) ? getRestTypeOfSignature(source) : getTypeOfSymbol(source.parameters[i]);
+                let t = isRestParameterIndex(target, i) ? getRestTypeOfSignature(target) : getTypeOfSymbol(target.parameters[i]);
                 let related = compareTypes(s, t);
                 if (!related) {
                     return Ternary.False;
@@ -5639,6 +5654,10 @@ namespace ts {
             return result;
         }
 
+        function isRestParameterIndex(signature: Signature, parameterIndex: number) {
+            return signature.hasRestParameter && parameterIndex >= signature.parameters.length - 1;
+        }
+
         function isSupertypeOfEach(candidate: Type, types: Type[]): boolean {
             for (let type of types) {
                 if (candidate !== type && !isTypeSubtypeOf(type, candidate)) return false;
@@ -6592,7 +6611,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;
@@ -6800,8 +6819,9 @@ namespace ts {
                         }
 
                         // If last parameter is contextually rest parameter get its type
-                        if (indexOfParameter === (func.parameters.length - 1) &&
-                            funcHasRestParameters && contextualSignature.hasRestParameter && func.parameters.length >= contextualSignature.parameters.length) {
+                        if (funcHasRestParameters &&
+                            indexOfParameter === (func.parameters.length - 1) &&
+                            isRestParameterIndex(contextualSignature, func.parameters.length - 1)) {
                             return getTypeOfSymbol(lastOrUndefined(contextualSignature.parameters));
                         }
                     }
@@ -7033,7 +7053,7 @@ namespace ts {
             return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional) : undefined;
         }
 
-        function getContextualTypeForJsxExpression(expr: JsxExpression|JsxSpreadAttribute): Type {
+        function getContextualTypeForJsxExpression(expr: JsxExpression | JsxSpreadAttribute): Type {
             // Contextual type only applies to JSX expressions that are in attribute assignments (not in 'Children' positions)
             if (expr.parent.kind === SyntaxKind.JsxAttribute) {
                 let attrib = <JsxAttribute>expr.parent;
@@ -7541,7 +7561,7 @@ namespace ts {
         /**
          * Returns true iff React would emit this tag name as a string rather than an identifier or qualified name
          */
-        function isJsxIntrinsicIdentifier(tagName: Identifier|QualifiedName) {
+        function isJsxIntrinsicIdentifier(tagName: Identifier | QualifiedName) {
             if (tagName.kind === SyntaxKind.QualifiedName) {
                 return false;
             }
@@ -7627,7 +7647,7 @@ namespace ts {
         /// If this is a class-based tag (otherwise returns undefined), returns the symbol of the class
         /// type or factory function.
         /// Otherwise, returns unknownSymbol.
-        function getJsxElementTagSymbol(node: JsxOpeningLikeElement|JsxClosingElement): Symbol {
+        function getJsxElementTagSymbol(node: JsxOpeningLikeElement | JsxClosingElement): Symbol {
             let flags: JsxFlags = JsxFlags.UnknownElement;
             let links = getNodeLinks(node);
             if (!links.resolvedSymbol) {
@@ -7640,7 +7660,7 @@ namespace ts {
             }
             return links.resolvedSymbol;
 
-            function lookupIntrinsicTag(node: JsxOpeningLikeElement|JsxClosingElement): Symbol {
+            function lookupIntrinsicTag(node: JsxOpeningLikeElement | JsxClosingElement): Symbol {
                 let intrinsicElementsType = getJsxIntrinsicElementsType();
                 if (intrinsicElementsType !== unknownType) {
                     // Property case
@@ -7668,7 +7688,7 @@ namespace ts {
                 }
             }
 
-            function lookupClassTag(node: JsxOpeningLikeElement|JsxClosingElement): Symbol {
+            function lookupClassTag(node: JsxOpeningLikeElement | JsxClosingElement): Symbol {
                 let valueSymbol: Symbol = resolveJsxTagName(node);
 
                 // Look up the value in the current scope
@@ -7682,7 +7702,7 @@ namespace ts {
                 return valueSymbol || unknownSymbol;
             }
 
-            function resolveJsxTagName(node: JsxOpeningLikeElement|JsxClosingElement): Symbol {
+            function resolveJsxTagName(node: JsxOpeningLikeElement | JsxClosingElement): Symbol {
                 if (node.tagName.kind === SyntaxKind.Identifier) {
                     let tag = <Identifier>node.tagName;
                     let sym = getResolvedSymbol(tag);
@@ -8391,7 +8411,7 @@ namespace ts {
             // If spread arguments are present, check that they correspond to a rest parameter. If so, no
             // further checking is necessary.
             if (spreadArgIndex >= 0) {
-                return signature.hasRestParameter && spreadArgIndex >= signature.parameters.length - 1;
+                return isRestParameterIndex(signature, spreadArgIndex);
             }
 
             // Too many arguments implies incorrect arity.
@@ -9382,7 +9402,7 @@ namespace ts {
                 let contextualParameterType = getTypeAtPosition(context, i);
                 assignTypeToParameterAndFixTypeParameters(parameter, contextualParameterType, mapper);
             }
-            if (signature.hasRestParameter && context.hasRestParameter && signature.parameters.length >= context.parameters.length) {
+            if (signature.hasRestParameter && isRestParameterIndex(context, signature.parameters.length - 1)) {
                 let parameter = lastOrUndefined(signature.parameters);
                 let contextualParameterType = getTypeOfSymbol(lastOrUndefined(context.parameters));
                 assignTypeToParameterAndFixTypeParameters(parameter, contextualParameterType, mapper);
@@ -9395,7 +9415,9 @@ namespace ts {
             if (isBindingPattern(node.name)) {
                 for (let element of (<BindingPattern>node.name).elements) {
                     if (element.kind !== SyntaxKind.OmittedExpression) {
-                        getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element);
+                        if (element.name.kind === SyntaxKind.Identifier) {
+                            getSymbolLinks(getSymbolOfNode(element)).type = getTypeForBindingElement(element);
+                        }
                         assignBindingElementTypes(element);
                     }
                 }
@@ -14552,6 +14574,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 {
@@ -14856,7 +14882,8 @@ namespace ts {
                 collectLinkedAliases,
                 getReferencedValueDeclaration,
                 getTypeReferenceSerializationKind,
-                isOptionalParameter
+                isOptionalParameter,
+                isArgumentsLocalBinding
             };
         }
 
@@ -15539,7 +15566,7 @@ namespace ts {
             }
         }
 
-        function checkGrammarJsxElement(node: JsxOpeningElement|JsxSelfClosingElement) {
+        function checkGrammarJsxElement(node: JsxOpeningLikeElement) {
             const seen: Map<boolean> = {};
             for (let attr of node.attributes) {
                 if (attr.kind === SyntaxKind.JsxSpreadAttribute) {
@@ -15683,21 +15710,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) {
@@ -15951,11 +15963,14 @@ namespace ts {
             //  DeclarationElement:
             //     ExportAssignment
             //     export_opt   InterfaceDeclaration
+            //     export_opt   TypeAliasDeclaration
             //     export_opt   ImportDeclaration
             //     export_opt   ExternalImportDeclaration
             //     export_opt   AmbientDeclaration
             //
+            // TODO: The spec needs to be amended to reflect this grammar.
             if (node.kind === SyntaxKind.InterfaceDeclaration ||
+                node.kind === SyntaxKind.TypeAliasDeclaration ||
                 node.kind === SyntaxKind.ImportDeclaration ||
                 node.kind === SyntaxKind.ImportEqualsDeclaration ||
                 node.kind === SyntaxKind.ExportDeclaration ||
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index b4f5185b6b4..7f3f9155a0e 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -79,9 +79,9 @@ namespace ts {
                 "es6": ModuleKind.ES6,
                 "es2015": ModuleKind.ES2015,
             },
-            description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es6,
+            description: Diagnostics.Specify_module_code_generation_Colon_commonjs_amd_system_umd_or_es2015,
             paramType: Diagnostics.KIND,
-            error: Diagnostics.Argument_for_module_option_must_be_commonjs_amd_system_umd_or_es6
+            error: Diagnostics.Argument_for_module_option_must_be_commonjs_amd_system_umd_or_es2015
         },
         {
             name: "newLine",
@@ -212,9 +212,9 @@ namespace ts {
                 "es6": ScriptTarget.ES6,
                 "es2015": ScriptTarget.ES2015,
             },
-            description: Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES6_experimental,
+            description: Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES2015_experimental,
             paramType: Diagnostics.VERSION,
-            error: Diagnostics.Argument_for_target_option_must_be_ES3_ES5_or_ES6
+            error: Diagnostics.Argument_for_target_option_must_be_ES3_ES5_or_ES2015
         },
         {
             name: "version",
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 8fd92818c46..78fc4c5602e 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -365,10 +365,10 @@ namespace ts {
 
     export let localizedDiagnosticMessages: Map<string> = undefined;
 
-    export function getLocaleSpecificMessage(message: string) {
-        return localizedDiagnosticMessages && localizedDiagnosticMessages[message]
-            ? localizedDiagnosticMessages[message]
-            : message;
+    export function getLocaleSpecificMessage(message: DiagnosticMessage) {
+        return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key]
+            ? localizedDiagnosticMessages[message.key]
+            : message.message;
     }
 
     export function createFileDiagnostic(file: SourceFile, start: number, length: number, message: DiagnosticMessage, ...args: any[]): Diagnostic;
@@ -383,7 +383,7 @@ namespace ts {
             Debug.assert(end <= file.text.length, `end must be the bounds of the file. ${ end } > ${ file.text.length }`);
         }
 
-        let text = getLocaleSpecificMessage(message.key);
+        let text = getLocaleSpecificMessage(message);
 
         if (arguments.length > 4) {
             text = formatStringFromArgs(text, arguments, 4);
@@ -402,7 +402,7 @@ namespace ts {
 
     export function createCompilerDiagnostic(message: DiagnosticMessage, ...args: any[]): Diagnostic;
     export function createCompilerDiagnostic(message: DiagnosticMessage): Diagnostic {
-        let text = getLocaleSpecificMessage(message.key);
+        let text = getLocaleSpecificMessage(message);
 
         if (arguments.length > 1) {
             text = formatStringFromArgs(text, arguments, 1);
@@ -421,7 +421,7 @@ namespace ts {
 
     export function chainDiagnosticMessages(details: DiagnosticMessageChain, message: DiagnosticMessage, ...args: any[]): DiagnosticMessageChain;
     export function chainDiagnosticMessages(details: DiagnosticMessageChain, message: DiagnosticMessage): DiagnosticMessageChain {
-        let text = getLocaleSpecificMessage(message.key);
+        let text = getLocaleSpecificMessage(message);
 
         if (arguments.length > 2) {
             text = formatStringFromArgs(text, arguments, 2);
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index d54d49e7511..68b479e44fe 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -627,7 +627,7 @@
         "category": "Error",
         "code": 1203
     },
-    "Cannot compile modules into 'es6' when targeting 'ES5' or lower.": {
+    "Cannot compile modules into 'es2015' when targeting 'ES5' or lower.": {
         "category": "Error",
         "code": 1204
     },
@@ -1712,10 +1712,6 @@
         "category": "Error",
         "code": 2654
     },
-    "Exported external package typings can only be in '.d.ts' files. Please contact the package author to update the package definition.": {
-        "category": "Error",
-        "code": 2655
-    },
     "Exported external package typings file '{0}' is not a module. Please contact the package author to update the package definition.": {
         "category": "Error",
         "code": 2656
@@ -2004,10 +2000,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
@@ -2044,7 +2036,7 @@
         "category": "Error",
         "code": 5042
     },
-    "Option 'isolatedModules' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher.": {
+    "Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher.": {
         "category": "Error",
         "code": 5047
     },
@@ -2105,11 +2097,11 @@
         "category": "Message",
         "code": 6010
     },
-    "Specify ECMAScript target version: 'ES3' (default), 'ES5', or 'ES6' (experimental)": {
-        "category": "Message",
-        "code": 6015
-    },
-    "Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es6'": {
+  "Specify ECMAScript target version: 'ES3' (default), 'ES5', or 'ES2015' (experimental)": {
+    "category": "Message",
+    "code": 6015
+  },
+    "Specify module code generation: 'commonjs', 'amd', 'system', 'umd' or 'es2015'": {
         "category": "Message",
         "code": 6016
     },
@@ -2193,14 +2185,14 @@
         "category": "Error",
         "code": 6045
     },
-    "Argument for '--module' option must be 'commonjs', 'amd', 'system', 'umd', or 'es6'.": {
+    "Argument for '--module' option must be 'commonjs', 'amd', 'system', 'umd', or 'es2015'.": {
         "category": "Error",
         "code": 6046
     },
-    "Argument for '--target' option must be 'ES3', 'ES5', or 'ES6'.": {
-        "category": "Error",
-        "code": 6047
-    },
+  "Argument for '--target' option must be 'ES3', 'ES5', or 'ES2015'.": {
+    "category": "Error",
+    "code": 6047
+  },
     "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'.": {
         "category": "Error",
         "code": 6048
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 70ab3606c6c..8837972a916 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -9,6 +9,12 @@ namespace ts {
 
     type DependencyGroup = Array<ImportDeclaration | ImportEqualsDeclaration | ExportDeclaration>;
 
+    const enum Jump {
+        Break       = 1 << 1,
+        Continue    = 1 << 2,
+        Return      = 1 << 3
+    }
+
     let entities: Map<number> = {
         "quot": 0x0022,
         "amp": 0x0026,
@@ -379,6 +385,99 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
             return true;
         }
 
+        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 +495,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;
@@ -1404,10 +1505,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 emit(span.literal);
             }
 
-            function jsxEmitReact(node: JsxElement|JsxSelfClosingElement) {
+            function jsxEmitReact(node: JsxElement | JsxSelfClosingElement) {
                 /// Emit a tag name, which is either '"div"' for lower-cased names, or
                 /// 'Div' for upper-cased or dotted names
-                function emitTagName(name: Identifier|QualifiedName) {
+                function emitTagName(name: Identifier | QualifiedName) {
                     if (name.kind === SyntaxKind.Identifier && isIntrinsicJsxName((<Identifier>name).text)) {
                         write("\"");
                         emit(name);
@@ -1557,7 +1658,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                 }
             }
 
-            function jsxEmitPreserve(node: JsxElement|JsxSelfClosingElement) {
+            function jsxEmitPreserve(node: JsxElement | JsxSelfClosingElement) {
                 function emitJsxAttribute(node: JsxAttribute) {
                     emit(node.name);
                     if (node.initializer) {
@@ -1572,7 +1673,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     write("}");
                 }
 
-                function emitAttributes(attribs: NodeArray<JsxAttribute|JsxSpreadAttribute>) {
+                function emitAttributes(attribs: NodeArray<JsxAttribute | JsxSpreadAttribute>) {
                     for (let i = 0, n = attribs.length; i < n; i++) {
                         if (i > 0) {
                             write(" ");
@@ -1588,7 +1689,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     }
                 }
 
-                function emitJsxOpeningOrSelfClosingElement(node: JsxOpeningElement|JsxSelfClosingElement) {
+                function emitJsxOpeningOrSelfClosingElement(node: JsxOpeningElement | JsxSelfClosingElement) {
                     write("<");
                     emit(node.tagName);
                     if (node.attributes.length > 0 || (node.kind === SyntaxKind.JsxSelfClosingElement)) {
@@ -1828,6 +1929,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);
                 }
@@ -2770,7 +2880,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
              *   we we emit variable statement 'var' should be dropped.
              */
             function isSourceFileLevelDeclarationInSystemJsModule(node: Node, isExported: boolean): boolean {
-                if (!node || languageVersion >= ScriptTarget.ES6 || !isCurrentFileSystemExternalModule()) {
+                if (!node || !isCurrentFileSystemExternalModule()) {
                     return false;
                 }
 
@@ -2996,8 +3106,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(" ");
                 }
@@ -3010,10 +3129,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);
+                }
             }
 
             /**
@@ -3027,6 +3156,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)) {
@@ -3078,7 +3216,295 @@ 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 we need to 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) {
+                           // 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;
+                           }
+                        }
+                        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);
@@ -3100,14 +3526,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);
@@ -3130,10 +3567,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) { }
@@ -3263,12 +3710,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();
@@ -3277,12 +3724,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("void 0");
+                    }
+                    write(" };");
+                    return;
+                }
+
                 emitToken(SyntaxKind.ReturnKeyword, node.pos);
                 emitOptional(" ", node.expression);
                 write(";");
@@ -3302,7 +3800,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 {
@@ -3383,10 +3891,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 emitLabeledStatement(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 {
@@ -3820,12 +4346,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();
@@ -4308,9 +4834,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;
@@ -4336,6 +4865,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                     emitExportMemberAssignment(node);
                 }
 
+                Debug.assert(convertedLoopState === undefined);
+                convertedLoopState = saveConvertedLoopState;
+
                 tempFlags = saveTempFlags;
                 tempVariables = saveTempVariables;
                 tempParameters = saveTempParameters;
@@ -4657,15 +5189,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;
@@ -5003,6 +5541,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;
@@ -5030,6 +5571,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;
@@ -5711,13 +6256,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;
                 }
@@ -7246,7 +7796,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, Promi
                         return emitTemplateSpan(<TemplateSpan>node);
                     case SyntaxKind.JsxElement:
                     case SyntaxKind.JsxSelfClosingElement:
-                        return emitJsxElement(<JsxElement|JsxSelfClosingElement>node);
+                        return emitJsxElement(<JsxElement | JsxSelfClosingElement>node);
                     case SyntaxKind.JsxText:
                         return emitJsxText(<JsxText>node);
                     case SyntaxKind.JsxExpression:
@@ -7344,7 +7894,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:
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index d2344722ed5..3e93e31340d 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -3532,7 +3532,7 @@ namespace ts {
             return result;
         }
 
-        function parseJsxOpeningOrSelfClosingElement(inExpressionContext: boolean): JsxOpeningElement|JsxSelfClosingElement {
+        function parseJsxOpeningOrSelfClosingElement(inExpressionContext: boolean): JsxOpeningElement | JsxSelfClosingElement {
             let fullStart = scanner.getStartPos();
 
             parseExpected(SyntaxKind.LessThanToken);
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index d76e7585d15..20272ce9898 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -863,10 +863,6 @@ namespace ts {
                                 let start = getTokenPosOfNode(file.imports[i], file);
                                 fileProcessingDiagnostics.add(createFileDiagnostic(file, start, file.imports[i].end - start, Diagnostics.Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_the_package_definition, importedFile.fileName));
                             }
-                            else if (!fileExtensionIs(importedFile.fileName, ".d.ts")) {
-                                let start = getTokenPosOfNode(file.imports[i], file);
-                                fileProcessingDiagnostics.add(createFileDiagnostic(file, start, file.imports[i].end - start, Diagnostics.Exported_external_package_typings_can_only_be_in_d_ts_files_Please_contact_the_package_author_to_update_the_package_definition));
-                            }
                             else if (importedFile.referencedFiles.length) {
                                 let firstRef = importedFile.referencedFiles[0];
                                 fileProcessingDiagnostics.add(createFileDiagnostic(importedFile, firstRef.pos, firstRef.end - firstRef.pos, Diagnostics.Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_package_author_to_update_the_package_definition));
@@ -1005,7 +1001,7 @@ namespace ts {
             let firstExternalModuleSourceFile = forEach(files, f => isExternalModule(f) ? f : undefined);
             if (options.isolatedModules) {
                 if (!options.module && languageVersion < ScriptTarget.ES6) {
-                    programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES6_or_higher));
+                    programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher));
                 }
 
                 let firstNonExternalModuleSourceFile = forEach(files, f => !isExternalModule(f) && !isDeclarationFile(f) ? f : undefined);
@@ -1022,7 +1018,7 @@ namespace ts {
 
             // Cannot specify module gen target of es6 when below es6
             if (options.module === ModuleKind.ES6 && languageVersion < ScriptTarget.ES6) {
-                programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_compile_modules_into_es6_when_targeting_ES5_or_lower));
+                programDiagnostics.add(createCompilerDiagnostic(Diagnostics.Cannot_compile_modules_into_es2015_when_targeting_ES5_or_lower));
             }
 
             // there has to be common source directory if user specified --outdir || --sourceRoot
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
index e51fda074c5..c493cf8f87f 100644
--- a/src/compiler/tsc.ts
+++ b/src/compiler/tsc.ts
@@ -159,6 +159,11 @@ namespace ts {
         let timerHandleForRecompilation: number;                    // Handle for 0.25s wait timer to trigger recompilation
         let timerHandleForDirectoryChanges: number;                 // Handle for 0.25s wait timer to trigger directory change handler
 
+        // This map stores and reuses results of fileExists check that happen inside 'createProgram'
+        // This allows to save time in module resolution heavy scenarios when existence of the same file might be checked multiple times.
+        let cachedExistingFiles: Map<boolean>;
+        let hostFileExists: typeof compilerHost.fileExists;
+
         if (commandLine.options.locale) {
             if (!isJSONSupported()) {
                 reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_current_host_does_not_support_the_0_option, "--locale"));
@@ -274,8 +279,14 @@ namespace ts {
                 compilerHost = createCompilerHost(compilerOptions);
                 hostGetSourceFile = compilerHost.getSourceFile;
                 compilerHost.getSourceFile = getSourceFile;
+
+                hostFileExists = compilerHost.fileExists;
+                compilerHost.fileExists = cachedFileExists;
             }
 
+            // reset the cache of existing files
+            cachedExistingFiles = {};
+
             let compileResult = compile(rootFileNames, compilerOptions, compilerHost);
 
             if (!compilerOptions.watch) {
@@ -286,6 +297,13 @@ namespace ts {
             reportWatchDiagnostic(createCompilerDiagnostic(Diagnostics.Compilation_complete_Watching_for_file_changes));
         }
 
+        function cachedFileExists(fileName: string): boolean {
+            if (hasProperty(cachedExistingFiles, fileName)) {
+                return cachedExistingFiles[fileName];
+            }
+            return cachedExistingFiles[fileName] = hostFileExists(fileName);
+        }
+
         function getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void) {
             // Return existing SourceFile object if one is available
             if (cachedProgram) {
@@ -567,7 +585,7 @@ namespace ts {
 
     function writeConfigFile(options: CompilerOptions, fileNames: string[]) {
         let currentDirectory = sys.getCurrentDirectory();
-        let file = combinePaths(currentDirectory, "tsconfig.json");
+        let file = normalizePath(combinePaths(currentDirectory, "tsconfig.json"));
         if (sys.fileExists(file)) {
             reportDiagnostic(createCompilerDiagnostic(Diagnostics.A_tsconfig_json_file_is_already_defined_at_Colon_0, file));
         }
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index ab5a9322ac2..1caac67f87d 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1615,6 +1615,7 @@ namespace ts {
         getReferencedValueDeclaration(reference: Identifier): Declaration;
         getTypeReferenceSerializationKind(typeName: EntityName): TypeReferenceSerializationKind;
         isOptionalParameter(node: ParameterDeclaration): boolean;
+        isArgumentsLocalBinding(node: Identifier): boolean;
     }
 
     export const enum SymbolFlags {
@@ -1759,7 +1760,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 */
@@ -2016,6 +2018,7 @@ namespace ts {
         key: string;
         category: DiagnosticCategory;
         code: number;
+        message: string;
     }
 
     /**
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index f506384c298..a4dc0d11a65 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -658,6 +658,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/src/lib/dom.generated.d.ts b/src/lib/dom.generated.d.ts
index fa985344412..ac039198b4b 100644
--- a/src/lib/dom.generated.d.ts
+++ b/src/lib/dom.generated.d.ts
@@ -2193,6 +2193,68 @@ interface Document extends Node, GlobalEventHandlers, NodeSelector, DocumentEven
     createElement(tagName: "x-ms-webview"): MSHTMLWebViewElement;
     createElement(tagName: "xmp"): HTMLBlockElement;
     createElement(tagName: string): HTMLElement;
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "a"): SVGAElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "circle"): SVGCircleElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "clipPath"): SVGClipPathElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "componentTransferFunction"): SVGComponentTransferFunctionElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "defs"): SVGDefsElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "desc"): SVGDescElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "ellipse"): SVGEllipseElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feBlend"): SVGFEBlendElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feColorMatrix"): SVGFEColorMatrixElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feComponentTransfer"): SVGFEComponentTransferElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feComposite"): SVGFECompositeElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feConvolveMatrix"): SVGFEConvolveMatrixElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feDiffuseLighting"): SVGFEDiffuseLightingElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feDisplacementMap"): SVGFEDisplacementMapElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feDistantLight"): SVGFEDistantLightElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feFlood"): SVGFEFloodElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feFuncA"): SVGFEFuncAElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feFuncB"): SVGFEFuncBElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feFuncG"): SVGFEFuncGElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feFuncR"): SVGFEFuncRElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feGaussianBlur"): SVGFEGaussianBlurElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feImage"): SVGFEImageElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feMerge"): SVGFEMergeElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feMergeNode"): SVGFEMergeNodeElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feMorphology"): SVGFEMorphologyElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feOffset"): SVGFEOffsetElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "fePointLight"): SVGFEPointLightElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feSpecularLighting"): SVGFESpecularLightingElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feSpotLight"): SVGFESpotLightElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feTile"): SVGFETileElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "feTurbulence"): SVGFETurbulenceElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "filter"): SVGFilterElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "foreignObject"): SVGForeignObjectElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "g"): SVGGElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "image"): SVGImageElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "gradient"): SVGGradientElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "line"): SVGLineElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "linearGradient"): SVGLinearGradientElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "marker"): SVGMarkerElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "mask"): SVGMaskElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "path"): SVGPathElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "metadata"): SVGMetadataElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "pattern"): SVGPatternElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "polygon"): SVGPolygonElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "polyline"): SVGPolylineElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "radialGradient"): SVGRadialGradientElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "rect"): SVGRectElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "svg"): SVGSVGElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "script"): SVGScriptElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "stop"): SVGStopElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "style"): SVGStyleElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "switch"): SVGSwitchElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "symbol"): SVGSymbolElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "tspan"): SVGTSpanElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "textContent"): SVGTextContentElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "text"): SVGTextElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "textPath"): SVGTextPathElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "textPositioning"): SVGTextPositioningElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "title"): SVGTitleElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "use"): SVGUseElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: "view"): SVGViewElement
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): SVGElement
     createElementNS(namespaceURI: string, qualifiedName: string): Element;
     createExpression(expression: string, resolver: XPathNSResolver): XPathExpression;
     createNSResolver(nodeResolver: Node): XPathNSResolver;
@@ -7014,14 +7076,12 @@ interface ImageData {
     width: number;
 }
 
-interface ImageDataConstructor {
+declare var ImageData: {
     prototype: ImageData;
     new(width: number, height: number): ImageData;
     new(array: Uint8ClampedArray, width: number, height: number): ImageData;
 }
 
-declare var ImageData: ImageDataConstructor; 
-
 interface KeyboardEvent extends UIEvent {
     altKey: boolean;
     char: string;
diff --git a/src/lib/webworker.generated.d.ts b/src/lib/webworker.generated.d.ts
index 7e160fffa45..a2ed9682f1b 100644
--- a/src/lib/webworker.generated.d.ts
+++ b/src/lib/webworker.generated.d.ts
@@ -465,14 +465,12 @@ interface ImageData {
     width: number;
 }
 
-interface ImageDataConstructor {
+declare var ImageData: {
     prototype: ImageData;
     new(width: number, height: number): ImageData;
     new(array: Uint8ClampedArray, width: number, height: number): ImageData;
 }
 
-declare var ImageData: ImageDataConstructor; 
-
 interface MSApp {
     clearTemporaryWebDataAsync(): MSAppAsyncOperation;
     createBlobFromRandomAccessStream(type: string, seeker: any): Blob;
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
index efcca0e37c5..e7d6aee8052 100644
--- a/src/server/editorServices.ts
+++ b/src/server/editorServices.ts
@@ -1268,11 +1268,15 @@ namespace ts.server {
                             if (info.isOpen) {
                                 if (this.openFileRoots.indexOf(info) >= 0) {
                                     this.openFileRoots = copyListRemovingItem(info, this.openFileRoots);
+                                    if (info.defaultProject && !info.defaultProject.isConfiguredProject()) {
+                                        this.removeProject(info.defaultProject);
+                                    }
                                 }
                                 if (this.openFilesReferenced.indexOf(info) >= 0) {
                                     this.openFilesReferenced = copyListRemovingItem(info, this.openFilesReferenced);
                                 }
                                 this.openFileRootsConfigured.push(info);
+                                info.defaultProject = project;
                             }
                         }
                         project.addRoot(info);
diff --git a/src/server/server.ts b/src/server/server.ts
index 39864fc8477..f48be53520e 100644
--- a/src/server/server.ts
+++ b/src/server/server.ts
@@ -11,7 +11,7 @@ namespace ts.server {
         input: process.stdin,
         output: process.stdout,
         terminal: false,
-    });  
+    });
 
     class Logger implements ts.server.Logger {
         fd = -1;
@@ -58,7 +58,7 @@ namespace ts.server {
         isVerbose() {
             return this.loggingEnabled() && (this.level == "verbose");
         }
-        
+
 
         msg(s: string, type = "Err") {
             if (this.fd < 0) {
@@ -89,18 +89,18 @@ namespace ts.server {
         }
 
         exit() {
-            this.projectService.log("Exiting...","Info");
+            this.projectService.log("Exiting...", "Info");
             this.projectService.closeLog();
             process.exit(0);
         }
 
         listen() {
-            rl.on('line',(input: string) => {
+            rl.on('line', (input: string) => {
                 var message = input.trim();
                 this.onMessage(message);
             });
 
-            rl.on('close',() => {
+            rl.on('close', () => {
                 this.exit();
             });
         }
@@ -155,6 +155,28 @@ namespace ts.server {
 
     var logger = createLoggerFromEnv();
 
+    let pending: string[] = [];
+    let canWrite = true;
+    function writeMessage(s: string) {
+        if (!canWrite) {
+            pending.push(s);
+        }
+        else {
+            canWrite = false;
+            process.stdout.write(new Buffer(s, "utf8"), setCanWriteFlagAndWriteMessageIfNecessary);
+        }
+    }
+
+    function setCanWriteFlagAndWriteMessageIfNecessary() {
+        canWrite = true;
+        if (pending.length) {
+            writeMessage(pending.shift());
+        }
+    }
+
+    // Override sys.write because fs.writeSync is not reliable on Node 4
+    ts.sys.write = (s: string) => writeMessage(s);
+
     var ioSession = new IOSession(ts.sys, logger);
     process.on('uncaughtException', function(err: Error) {
         ioSession.logError(err, "unknown");
diff --git a/src/services/services.ts b/src/services/services.ts
index c9a6d609e5b..90e4abd96d4 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -7358,7 +7358,7 @@ namespace ts {
                                 let sourceFile = current.getSourceFile();
                                 var canonicalName = getCanonicalFileName(ts.normalizePath(sourceFile.fileName));
                                 if (sourceFile && getCanonicalFileName(ts.normalizePath(sourceFile.fileName)) === getCanonicalFileName(ts.normalizePath(defaultLibFileName))) {
-                                    return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library.key));
+                                    return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library));
                                 }
                             }
                         }
@@ -7380,7 +7380,7 @@ namespace ts {
                 }
             }
 
-            return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_this_element.key));
+            return getRenameInfoError(getLocaleSpecificMessage(Diagnostics.You_cannot_rename_this_element));
 
             function getRenameInfoError(localizedErrorMessage: string): RenameInfo {
                 return {
diff --git a/tests/baselines/reference/bindingPatternInParameter01.errors.txt b/tests/baselines/reference/bindingPatternInParameter01.errors.txt
new file mode 100644
index 00000000000..bee1f47141e
--- /dev/null
+++ b/tests/baselines/reference/bindingPatternInParameter01.errors.txt
@@ -0,0 +1,12 @@
+tests/cases/compiler/bindingPatternInParameter01.ts(4,3): error TS2304: Cannot find name 'console'.
+
+
+==== tests/cases/compiler/bindingPatternInParameter01.ts (1 errors) ====
+    const nestedArray = [[[1, 2]], [[3, 4]]];
+    
+    nestedArray.forEach(([[a, b]]) => {
+      console.log(a, b);
+      ~~~~~~~
+!!! error TS2304: Cannot find name 'console'.
+    });
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/bindingPatternInParameter01.js b/tests/baselines/reference/bindingPatternInParameter01.js
new file mode 100644
index 00000000000..27b3a59e81e
--- /dev/null
+++ b/tests/baselines/reference/bindingPatternInParameter01.js
@@ -0,0 +1,14 @@
+//// [bindingPatternInParameter01.ts]
+const nestedArray = [[[1, 2]], [[3, 4]]];
+
+nestedArray.forEach(([[a, b]]) => {
+  console.log(a, b);
+});
+
+
+//// [bindingPatternInParameter01.js]
+var nestedArray = [[[1, 2]], [[3, 4]]];
+nestedArray.forEach(function (_a) {
+    var _b = _a[0], a = _b[0], b = _b[1];
+    console.log(a, b);
+});
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..d7d177a19b9
--- /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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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: void 0 };
+        }
+    };
+    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..b10beb7b44e
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8.js
@@ -0,0 +1,293 @@
+//// [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 == 3) {
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+                return;
+            }
+        }
+    }
+}
+
+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 == 3) {
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+                return;
+            }
+        }
+    }
+}
+
+
+//// [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" };
+                }
+                if (x == 3) {
+                    return { value: void 0 };
+                }
+            };
+            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" };
+            }
+            if (x == 3) {
+                return { value: void 0 };
+            }
+        };
+        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" };
+                }
+                if (x == 3) {
+                    return { value: void 0 };
+                }
+            };
+            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" };
+            }
+            if (x == 3) {
+                return { value: void 0 };
+            }
+        };
+        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..9622062c94b
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8.symbols
@@ -0,0 +1,228 @@
+=== 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 == 3) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 4, 16))
+
+                return;
+            }
+        }
+    }
+}
+
+function foo_c() {
+>foo_c : Symbol(foo_c, Decl(capturedLetConstInLoop8.ts, 61, 1))
+
+    l0:
+    for (const z = 0; z < 1;) {
+>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, 67, 18))
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+
+            ll1:
+            for (const y = 0; y < 1;) {
+>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, 67, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
+
+                (() => x + y);
+>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, 69, 22))
+
+                    break;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
+
+                    break l1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
+
+                    break ll1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8.ts, 69, 22))
+
+                    continue l0;
+                }
+
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+
+                    continue;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+
+                    continue l1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+
+                    continue ll1;
+                }
+                if (x == 2) {
+>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, 67, 18))
+
+                break;
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+
+                break l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+
+                continue;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+
+                continue l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8.ts, 67, 18))
+
+                continue l0;
+            }
+            if (x == 2) {
+>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
new file mode 100644
index 00000000000..9c3db88535c
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8.types
@@ -0,0 +1,357 @@
+=== 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 == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                    return;
+                }
+            }
+            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
+            }
+            if (x == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                return;
+            }
+        }
+    }
+}
+
+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 == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                    return;
+                }
+            }
+            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
+            }
+            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
new file mode 100644
index 00000000000..71d0ecd4c4c
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8_ES6.js
@@ -0,0 +1,245 @@
+//// [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 == 3) {
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+                return;
+            }
+        }
+    }
+}
+
+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 == 3) {
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+                return;
+            }
+        }
+    }
+}
+
+
+//// [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 == 3) {
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+                return;
+            }
+        }
+    }
+}
+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 == 3) {
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+                return;
+            }
+        }
+    }
+}
diff --git a/tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols b/tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols
new file mode 100644
index 00000000000..01ca5f227f4
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8_ES6.symbols
@@ -0,0 +1,228 @@
+=== 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, 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, 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, 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, 4, 16))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
+
+                (() => x + y);
+>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, 6, 20))
+
+                    break;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
+
+                    break l1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
+
+                    break ll1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 6, 20))
+
+                    continue l0;
+                }
+
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+
+                    continue;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+
+                    continue l1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+
+                    continue ll1;
+                }
+                if (x == 2) {
+>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, 4, 16))
+
+                break;
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+
+                break l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+
+                continue;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+
+                continue l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 4, 16))
+
+                continue l0;
+            }
+            if (x == 2) {
+>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, 61, 1))
+
+    l0:
+    for (const z = 0; z < 1;) {
+>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, 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, 69, 22))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
+
+                (function() { return x + y });
+>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, 67, 18))
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
+
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
+
+                    break;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
+
+                    break l1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
+
+                    break ll1;
+                }
+                if (y == 1) {
+>y : Symbol(y, Decl(capturedLetConstInLoop8_ES6.ts, 69, 22))
+
+                    continue l0;
+                }
+
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+
+                    continue;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+
+                    continue l1;
+                }
+                if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+
+                    continue ll1;
+                }
+                if (x == 2) {
+>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, 67, 18))
+
+                break;
+            }
+            if (x == 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+
+                break l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+
+                continue;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+
+                continue l1;
+            }
+            if (x == 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop8_ES6.ts, 67, 18))
+
+                continue l0;
+            }
+            if (x == 2) {
+>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
new file mode 100644
index 00000000000..7911e9b63a2
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop8_ES6.types
@@ -0,0 +1,357 @@
+=== 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 == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                    return;
+                }
+            }
+            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
+            }
+            if (x == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                return;
+            }
+        }
+    }
+}
+
+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 == 3) {
+>x == 3 : boolean
+>x : number
+>3 : number
+
+                    return;
+                }
+            }
+            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
+            }
+            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
new file mode 100644
index 00000000000..93aef628f8a
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9.js
@@ -0,0 +1,295 @@
+//// [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;
+            }
+            
+            () => b
+            return 100;
+        }
+
+        
+        () => 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;
+            }
+        }
+    }
+}
+
+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]
+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";
+            }
+            (function () { return b; });
+            return { value: 100 };
+        };
+        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;
+            }
+        }
+    }
+}
+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
new file mode 100644
index 00000000000..37d1764b41b
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9.symbols
@@ -0,0 +1,270 @@
+=== 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;
+            }
+            
+            () => b
+>b : Symbol(b, Decl(capturedLetConstInLoop9.ts, 66, 16))
+
+            return 100;
+        }
+
+        
+        () => 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, 88, 1))
+
+    for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12))
+
+        if (x === 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12))
+
+            break;
+        }
+        else if (x === 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12))
+
+            continue;
+        }
+        
+        while (1 === 1) {
+            if (x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12))
+
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        
+        switch(x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 91, 12))
+
+            case 1: break;
+            case 2: continue;
+        }
+        
+        for (let y of []) {
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 113, 16))
+
+            switch(y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop9.ts, 113, 16))
+
+                case 1: break;
+                case 2: continue;
+            }
+        }
+    }
+}
+
+class C {
+>C : Symbol(C, Decl(capturedLetConstInLoop9.ts, 120, 1))
+
+    constructor(private N: number) { }
+>N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 123, 16))
+
+    foo() {
+>foo : Symbol(foo, Decl(capturedLetConstInLoop9.ts, 123, 38))
+
+        for (let i = 0; i < 100; i++) {
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16))
+
+            let f = () => this.N * i;
+>f : Symbol(f, Decl(capturedLetConstInLoop9.ts, 126, 15))
+>this.N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 123, 16))
+>this : Symbol(C, Decl(capturedLetConstInLoop9.ts, 120, 1))
+>N : Symbol(N, Decl(capturedLetConstInLoop9.ts, 123, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9.ts, 125, 16))
+        }
+    }
+}
+
+function foo3 () {
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9.ts, 129, 1))
+
+    let x = arguments.length;
+>x : Symbol(x, Decl(capturedLetConstInLoop9.ts, 132, 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, 133, 12))
+
+        let z = arguments.length;
+>z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 134, 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, 133, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop9.ts, 134, 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
new file mode 100644
index 00000000000..7f793ab6601
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9.types
@@ -0,0 +1,359 @@
+=== 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
+            }
+            
+            () => b
+>() => b : () => any
+>b : any
+
+            return 100;
+>100 : number
+        }
+
+        
+        () => 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
+            }
+        }
+    }
+}
+
+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
new file mode 100644
index 00000000000..0c9d8ea6a68
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.js
@@ -0,0 +1,253 @@
+//// [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;
+            }
+            () => b
+            return 100;
+        }
+
+        
+        () => 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;
+            }
+        }
+    }
+}
+
+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]
+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;
+            }
+            (() => b);
+            return 100;
+        }
+        (() => 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;
+            }
+        }
+    }
+}
+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
new file mode 100644
index 00000000000..d71a20afe47
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.symbols
@@ -0,0 +1,270 @@
+=== 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;
+            }
+            () => b
+>b : Symbol(b, Decl(capturedLetConstInLoop9_ES6.ts, 67, 16))
+
+            return 100;
+        }
+
+        
+        () => 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, 88, 1))
+
+    for (let x of []) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12))
+
+        if (x === 1) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12))
+
+            break;
+        }
+        else if (x === 2) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12))
+
+            continue;
+        }
+        
+        while (1 === 1) {
+            if (x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12))
+
+                break;
+            }
+            else {
+                continue;
+            }
+        }
+        
+        switch(x) {
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 91, 12))
+
+            case 1: break;
+            case 2: continue;
+        }
+        
+        for (let y of []) {
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 113, 16))
+
+            switch(y) {
+>y : Symbol(y, Decl(capturedLetConstInLoop9_ES6.ts, 113, 16))
+
+                case 1: break;
+                case 2: continue;
+            }
+        }
+    }
+}
+
+class C {
+>C : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 120, 1))
+
+    constructor(private N: number) { }
+>N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16))
+
+    foo() {
+>foo : Symbol(foo, Decl(capturedLetConstInLoop9_ES6.ts, 123, 38))
+
+        for (let i = 0; i < 100; i++) {
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
+
+            let f = () => this.N * i;
+>f : Symbol(f, Decl(capturedLetConstInLoop9_ES6.ts, 126, 15))
+>this.N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16))
+>this : Symbol(C, Decl(capturedLetConstInLoop9_ES6.ts, 120, 1))
+>N : Symbol(N, Decl(capturedLetConstInLoop9_ES6.ts, 123, 16))
+>i : Symbol(i, Decl(capturedLetConstInLoop9_ES6.ts, 125, 16))
+        }
+    }
+}
+
+function foo3 () {
+>foo3 : Symbol(foo3, Decl(capturedLetConstInLoop9_ES6.ts, 129, 1))
+
+    let x = arguments.length;
+>x : Symbol(x, Decl(capturedLetConstInLoop9_ES6.ts, 132, 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, 133, 12))
+
+        let z = arguments.length;
+>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 134, 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, 133, 12))
+>z : Symbol(z, Decl(capturedLetConstInLoop9_ES6.ts, 134, 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
new file mode 100644
index 00000000000..dfbfa387ed4
--- /dev/null
+++ b/tests/baselines/reference/capturedLetConstInLoop9_ES6.types
@@ -0,0 +1,359 @@
+=== 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
+            }
+            () => b
+>() => b : () => any
+>b : any
+
+            return 100;
+>100 : number
+        }
+
+        
+        () => 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
+            }
+        }
+    }
+}
+
+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/downlevelLetConst18.errors.txt b/tests/baselines/reference/downlevelLetConst18.errors.txt
deleted file mode 100644
index 9f9700dbb7e..00000000000
--- a/tests/baselines/reference/downlevelLetConst18.errors.txt
+++ /dev/null
@@ -1,61 +0,0 @@
-tests/cases/compiler/downlevelLetConst18.ts(4,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(5,14): error TS2393: Duplicate function implementation.
-tests/cases/compiler/downlevelLetConst18.ts(8,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,14): error TS2393: Duplicate function implementation.
-tests/cases/compiler/downlevelLetConst18.ts(12,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(16,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(20,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(24,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(28,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) ====
-    
-    '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 0674929d225..cc11c1eef3a 100644
--- a/tests/baselines/reference/downlevelLetConst18.js
+++ b/tests/baselines/reference/downlevelLetConst18.js
@@ -7,7 +7,7 @@ for (let x; ;) {
 }
 
 for (let x; ;) {
-    function foo() { x };
+    function foo1() { x };
 }
 
 for (let x; ;) {
@@ -33,26 +33,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;;) {
-    function foo() { x; }
+    _loop_1(x);
+}
+var _loop_2 = function(x) {
+    function foo1() { 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/baselines/reference/downlevelLetConst18.symbols b/tests/baselines/reference/downlevelLetConst18.symbols
new file mode 100644
index 00000000000..a1df0dc6ae9
--- /dev/null
+++ b/tests/baselines/reference/downlevelLetConst18.symbols
@@ -0,0 +1,59 @@
+=== tests/cases/compiler/downlevelLetConst18.ts ===
+
+'use strict'
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 3, 8))
+
+    function foo() { x };
+>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 3, 16))
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 3, 8))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 7, 8))
+
+    function foo1() { x };
+>foo1 : Symbol(foo1, Decl(downlevelLetConst18.ts, 7, 16))
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 7, 8))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 11, 8))
+
+    (() => { x })();
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 11, 8))
+}
+
+for (const x = 1; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 15, 10))
+
+    (() => { x })();
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 15, 10))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 19, 8))
+
+    ({ foo() { x }})
+>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 20, 6))
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 19, 8))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 23, 8))
+
+    ({ get foo() { return x } })
+>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 24, 6))
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 23, 8))
+}
+
+for (let x; ;) {
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 27, 8))
+
+    ({ set foo(v) { x } })
+>foo : Symbol(foo, Decl(downlevelLetConst18.ts, 28, 6))
+>v : Symbol(v, Decl(downlevelLetConst18.ts, 28, 15))
+>x : Symbol(x, Decl(downlevelLetConst18.ts, 27, 8))
+}
+
diff --git a/tests/baselines/reference/downlevelLetConst18.types b/tests/baselines/reference/downlevelLetConst18.types
new file mode 100644
index 00000000000..42421aa80c0
--- /dev/null
+++ b/tests/baselines/reference/downlevelLetConst18.types
@@ -0,0 +1,73 @@
+=== tests/cases/compiler/downlevelLetConst18.ts ===
+
+'use strict'
+>'use strict' : string
+
+for (let x; ;) {
+>x : any
+
+    function foo() { x };
+>foo : () => void
+>x : any
+}
+
+for (let x; ;) {
+>x : any
+
+    function foo1() { x };
+>foo1 : () => void
+>x : any
+}
+
+for (let x; ;) {
+>x : any
+
+    (() => { x })();
+>(() => { x })() : void
+>(() => { x }) : () => void
+>() => { x } : () => void
+>x : any
+}
+
+for (const x = 1; ;) {
+>x : number
+>1 : number
+
+    (() => { x })();
+>(() => { x })() : void
+>(() => { x }) : () => void
+>() => { x } : () => void
+>x : number
+}
+
+for (let x; ;) {
+>x : any
+
+    ({ foo() { x }})
+>({ foo() { x }}) : { foo(): void; }
+>{ foo() { x }} : { foo(): void; }
+>foo : () => void
+>x : any
+}
+
+for (let x; ;) {
+>x : any
+
+    ({ get foo() { return x } })
+>({ get foo() { return x } }) : { foo: any; }
+>{ get foo() { return x } } : { foo: any; }
+>foo : any
+>x : any
+}
+
+for (let x; ;) {
+>x : any
+
+    ({ set foo(v) { x } })
+>({ set foo(v) { x } }) : { foo: any; }
+>{ set foo(v) { x } } : { foo: any; }
+>foo : any
+>v : any
+>x : any
+}
+
diff --git a/tests/baselines/reference/es5andes6module.errors.txt b/tests/baselines/reference/es5andes6module.errors.txt
index d5a672b9486..6908bfc8ae6 100644
--- a/tests/baselines/reference/es5andes6module.errors.txt
+++ b/tests/baselines/reference/es5andes6module.errors.txt
@@ -1,7 +1,7 @@
-error TS1204: Cannot compile modules into 'es6' when targeting 'ES5' or lower.
+error TS1204: Cannot compile modules into 'es2015' when targeting 'ES5' or lower.
 
 
-!!! error TS1204: Cannot compile modules into 'es6' when targeting 'ES5' or lower.
+!!! error TS1204: Cannot compile modules into 'es2015' when targeting 'ES5' or lower.
 ==== tests/cases/compiler/es5andes6module.ts (0 errors) ====
     
     export default class A
diff --git a/tests/baselines/reference/isolatedModulesUnspecifiedModule.errors.txt b/tests/baselines/reference/isolatedModulesUnspecifiedModule.errors.txt
index 7d290bcae44..1abc6ca47d4 100644
--- a/tests/baselines/reference/isolatedModulesUnspecifiedModule.errors.txt
+++ b/tests/baselines/reference/isolatedModulesUnspecifiedModule.errors.txt
@@ -1,6 +1,6 @@
-error TS5047: Option 'isolatedModules' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher.
+error TS5047: Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher.
 
 
-!!! error TS5047: Option 'isolatedModules' can only be used when either option'--module' is provided or option 'target' is 'ES6' or higher.
+!!! error TS5047: Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher.
 ==== tests/cases/compiler/isolatedModulesUnspecifiedModule.ts (0 errors) ====
     export var x;
\ No newline at end of file
diff --git a/tests/baselines/reference/mergedInheritedClassInterface.js b/tests/baselines/reference/mergedInheritedClassInterface.js
new file mode 100644
index 00000000000..2cc88ac9431
--- /dev/null
+++ b/tests/baselines/reference/mergedInheritedClassInterface.js
@@ -0,0 +1,96 @@
+//// [mergedInheritedClassInterface.ts]
+interface BaseInterface {
+    required: number;
+    optional?: number;
+}
+
+class BaseClass {
+    baseMethod() { }
+    baseNumber: number;
+}
+
+interface Child extends BaseInterface {
+    additional: number;
+}
+
+class Child extends BaseClass {
+    classNumber: number;
+    method() { }
+}
+
+interface ChildNoBaseClass extends BaseInterface {
+    additional2: string;
+}
+class ChildNoBaseClass {
+    classString: string;
+    method2() { }
+}
+class Grandchild extends ChildNoBaseClass {
+}
+
+// checks if properties actually were merged
+var child : Child;
+child.required;
+child.optional;
+child.additional;
+child.baseNumber;
+child.classNumber;
+child.baseMethod();
+child.method();
+
+var grandchild: Grandchild;
+grandchild.required;
+grandchild.optional;
+grandchild.additional2;
+grandchild.classString;
+grandchild.method2();
+
+
+//// [mergedInheritedClassInterface.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var BaseClass = (function () {
+    function BaseClass() {
+    }
+    BaseClass.prototype.baseMethod = function () { };
+    return BaseClass;
+})();
+var Child = (function (_super) {
+    __extends(Child, _super);
+    function Child() {
+        _super.apply(this, arguments);
+    }
+    Child.prototype.method = function () { };
+    return Child;
+})(BaseClass);
+var ChildNoBaseClass = (function () {
+    function ChildNoBaseClass() {
+    }
+    ChildNoBaseClass.prototype.method2 = function () { };
+    return ChildNoBaseClass;
+})();
+var Grandchild = (function (_super) {
+    __extends(Grandchild, _super);
+    function Grandchild() {
+        _super.apply(this, arguments);
+    }
+    return Grandchild;
+})(ChildNoBaseClass);
+// checks if properties actually were merged
+var child;
+child.required;
+child.optional;
+child.additional;
+child.baseNumber;
+child.classNumber;
+child.baseMethod();
+child.method();
+var grandchild;
+grandchild.required;
+grandchild.optional;
+grandchild.additional2;
+grandchild.classString;
+grandchild.method2();
diff --git a/tests/baselines/reference/mergedInheritedClassInterface.symbols b/tests/baselines/reference/mergedInheritedClassInterface.symbols
new file mode 100644
index 00000000000..5f4ae67df6f
--- /dev/null
+++ b/tests/baselines/reference/mergedInheritedClassInterface.symbols
@@ -0,0 +1,130 @@
+=== tests/cases/conformance/classes/classDeclarations/mergedInheritedClassInterface.ts ===
+interface BaseInterface {
+>BaseInterface : Symbol(BaseInterface, Decl(mergedInheritedClassInterface.ts, 0, 0))
+
+    required: number;
+>required : Symbol(required, Decl(mergedInheritedClassInterface.ts, 0, 25))
+
+    optional?: number;
+>optional : Symbol(optional, Decl(mergedInheritedClassInterface.ts, 1, 21))
+}
+
+class BaseClass {
+>BaseClass : Symbol(BaseClass, Decl(mergedInheritedClassInterface.ts, 3, 1))
+
+    baseMethod() { }
+>baseMethod : Symbol(baseMethod, Decl(mergedInheritedClassInterface.ts, 5, 17))
+
+    baseNumber: number;
+>baseNumber : Symbol(baseNumber, Decl(mergedInheritedClassInterface.ts, 6, 20))
+}
+
+interface Child extends BaseInterface {
+>Child : Symbol(Child, Decl(mergedInheritedClassInterface.ts, 8, 1), Decl(mergedInheritedClassInterface.ts, 12, 1))
+>BaseInterface : Symbol(BaseInterface, Decl(mergedInheritedClassInterface.ts, 0, 0))
+
+    additional: number;
+>additional : Symbol(additional, Decl(mergedInheritedClassInterface.ts, 10, 39))
+}
+
+class Child extends BaseClass {
+>Child : Symbol(Child, Decl(mergedInheritedClassInterface.ts, 8, 1), Decl(mergedInheritedClassInterface.ts, 12, 1))
+>BaseClass : Symbol(BaseClass, Decl(mergedInheritedClassInterface.ts, 3, 1))
+
+    classNumber: number;
+>classNumber : Symbol(classNumber, Decl(mergedInheritedClassInterface.ts, 14, 31))
+
+    method() { }
+>method : Symbol(method, Decl(mergedInheritedClassInterface.ts, 15, 24))
+}
+
+interface ChildNoBaseClass extends BaseInterface {
+>ChildNoBaseClass : Symbol(ChildNoBaseClass, Decl(mergedInheritedClassInterface.ts, 17, 1), Decl(mergedInheritedClassInterface.ts, 21, 1))
+>BaseInterface : Symbol(BaseInterface, Decl(mergedInheritedClassInterface.ts, 0, 0))
+
+    additional2: string;
+>additional2 : Symbol(additional2, Decl(mergedInheritedClassInterface.ts, 19, 50))
+}
+class ChildNoBaseClass {
+>ChildNoBaseClass : Symbol(ChildNoBaseClass, Decl(mergedInheritedClassInterface.ts, 17, 1), Decl(mergedInheritedClassInterface.ts, 21, 1))
+
+    classString: string;
+>classString : Symbol(classString, Decl(mergedInheritedClassInterface.ts, 22, 24))
+
+    method2() { }
+>method2 : Symbol(method2, Decl(mergedInheritedClassInterface.ts, 23, 24))
+}
+class Grandchild extends ChildNoBaseClass {
+>Grandchild : Symbol(Grandchild, Decl(mergedInheritedClassInterface.ts, 25, 1))
+>ChildNoBaseClass : Symbol(ChildNoBaseClass, Decl(mergedInheritedClassInterface.ts, 17, 1), Decl(mergedInheritedClassInterface.ts, 21, 1))
+}
+
+// checks if properties actually were merged
+var child : Child;
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>Child : Symbol(Child, Decl(mergedInheritedClassInterface.ts, 8, 1), Decl(mergedInheritedClassInterface.ts, 12, 1))
+
+child.required;
+>child.required : Symbol(BaseInterface.required, Decl(mergedInheritedClassInterface.ts, 0, 25))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>required : Symbol(BaseInterface.required, Decl(mergedInheritedClassInterface.ts, 0, 25))
+
+child.optional;
+>child.optional : Symbol(BaseInterface.optional, Decl(mergedInheritedClassInterface.ts, 1, 21))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>optional : Symbol(BaseInterface.optional, Decl(mergedInheritedClassInterface.ts, 1, 21))
+
+child.additional;
+>child.additional : Symbol(Child.additional, Decl(mergedInheritedClassInterface.ts, 10, 39))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>additional : Symbol(Child.additional, Decl(mergedInheritedClassInterface.ts, 10, 39))
+
+child.baseNumber;
+>child.baseNumber : Symbol(BaseClass.baseNumber, Decl(mergedInheritedClassInterface.ts, 6, 20))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>baseNumber : Symbol(BaseClass.baseNumber, Decl(mergedInheritedClassInterface.ts, 6, 20))
+
+child.classNumber;
+>child.classNumber : Symbol(Child.classNumber, Decl(mergedInheritedClassInterface.ts, 14, 31))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>classNumber : Symbol(Child.classNumber, Decl(mergedInheritedClassInterface.ts, 14, 31))
+
+child.baseMethod();
+>child.baseMethod : Symbol(BaseClass.baseMethod, Decl(mergedInheritedClassInterface.ts, 5, 17))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>baseMethod : Symbol(BaseClass.baseMethod, Decl(mergedInheritedClassInterface.ts, 5, 17))
+
+child.method();
+>child.method : Symbol(Child.method, Decl(mergedInheritedClassInterface.ts, 15, 24))
+>child : Symbol(child, Decl(mergedInheritedClassInterface.ts, 30, 3))
+>method : Symbol(Child.method, Decl(mergedInheritedClassInterface.ts, 15, 24))
+
+var grandchild: Grandchild;
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>Grandchild : Symbol(Grandchild, Decl(mergedInheritedClassInterface.ts, 25, 1))
+
+grandchild.required;
+>grandchild.required : Symbol(BaseInterface.required, Decl(mergedInheritedClassInterface.ts, 0, 25))
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>required : Symbol(BaseInterface.required, Decl(mergedInheritedClassInterface.ts, 0, 25))
+
+grandchild.optional;
+>grandchild.optional : Symbol(BaseInterface.optional, Decl(mergedInheritedClassInterface.ts, 1, 21))
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>optional : Symbol(BaseInterface.optional, Decl(mergedInheritedClassInterface.ts, 1, 21))
+
+grandchild.additional2;
+>grandchild.additional2 : Symbol(ChildNoBaseClass.additional2, Decl(mergedInheritedClassInterface.ts, 19, 50))
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>additional2 : Symbol(ChildNoBaseClass.additional2, Decl(mergedInheritedClassInterface.ts, 19, 50))
+
+grandchild.classString;
+>grandchild.classString : Symbol(ChildNoBaseClass.classString, Decl(mergedInheritedClassInterface.ts, 22, 24))
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>classString : Symbol(ChildNoBaseClass.classString, Decl(mergedInheritedClassInterface.ts, 22, 24))
+
+grandchild.method2();
+>grandchild.method2 : Symbol(ChildNoBaseClass.method2, Decl(mergedInheritedClassInterface.ts, 23, 24))
+>grandchild : Symbol(grandchild, Decl(mergedInheritedClassInterface.ts, 39, 3))
+>method2 : Symbol(ChildNoBaseClass.method2, Decl(mergedInheritedClassInterface.ts, 23, 24))
+
diff --git a/tests/baselines/reference/mergedInheritedClassInterface.types b/tests/baselines/reference/mergedInheritedClassInterface.types
new file mode 100644
index 00000000000..e7e645fb278
--- /dev/null
+++ b/tests/baselines/reference/mergedInheritedClassInterface.types
@@ -0,0 +1,133 @@
+=== tests/cases/conformance/classes/classDeclarations/mergedInheritedClassInterface.ts ===
+interface BaseInterface {
+>BaseInterface : BaseInterface
+
+    required: number;
+>required : number
+
+    optional?: number;
+>optional : number
+}
+
+class BaseClass {
+>BaseClass : BaseClass
+
+    baseMethod() { }
+>baseMethod : () => void
+
+    baseNumber: number;
+>baseNumber : number
+}
+
+interface Child extends BaseInterface {
+>Child : Child
+>BaseInterface : BaseInterface
+
+    additional: number;
+>additional : number
+}
+
+class Child extends BaseClass {
+>Child : Child
+>BaseClass : BaseClass
+
+    classNumber: number;
+>classNumber : number
+
+    method() { }
+>method : () => void
+}
+
+interface ChildNoBaseClass extends BaseInterface {
+>ChildNoBaseClass : ChildNoBaseClass
+>BaseInterface : BaseInterface
+
+    additional2: string;
+>additional2 : string
+}
+class ChildNoBaseClass {
+>ChildNoBaseClass : ChildNoBaseClass
+
+    classString: string;
+>classString : string
+
+    method2() { }
+>method2 : () => void
+}
+class Grandchild extends ChildNoBaseClass {
+>Grandchild : Grandchild
+>ChildNoBaseClass : ChildNoBaseClass
+}
+
+// checks if properties actually were merged
+var child : Child;
+>child : Child
+>Child : Child
+
+child.required;
+>child.required : number
+>child : Child
+>required : number
+
+child.optional;
+>child.optional : number
+>child : Child
+>optional : number
+
+child.additional;
+>child.additional : number
+>child : Child
+>additional : number
+
+child.baseNumber;
+>child.baseNumber : number
+>child : Child
+>baseNumber : number
+
+child.classNumber;
+>child.classNumber : number
+>child : Child
+>classNumber : number
+
+child.baseMethod();
+>child.baseMethod() : void
+>child.baseMethod : () => void
+>child : Child
+>baseMethod : () => void
+
+child.method();
+>child.method() : void
+>child.method : () => void
+>child : Child
+>method : () => void
+
+var grandchild: Grandchild;
+>grandchild : Grandchild
+>Grandchild : Grandchild
+
+grandchild.required;
+>grandchild.required : number
+>grandchild : Grandchild
+>required : number
+
+grandchild.optional;
+>grandchild.optional : number
+>grandchild : Grandchild
+>optional : number
+
+grandchild.additional2;
+>grandchild.additional2 : string
+>grandchild : Grandchild
+>additional2 : string
+
+grandchild.classString;
+>grandchild.classString : string
+>grandchild : Grandchild
+>classString : string
+
+grandchild.method2();
+>grandchild.method2() : void
+>grandchild.method2 : () => void
+>grandchild : Grandchild
+>method2 : () => void
+
diff --git a/tests/baselines/reference/systemModule1.js b/tests/baselines/reference/systemModule1.js
index 573a7ae04c8..8d99e84ae9f 100644
--- a/tests/baselines/reference/systemModule1.js
+++ b/tests/baselines/reference/systemModule1.js
@@ -8,7 +8,7 @@ System.register([], function(exports_1) {
     return {
         setters:[],
         execute: function() {
-            x = 1;
+            exports_1("x", x = 1);
         }
     }
 });
diff --git a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt
index 94ab5028647..e6910840d39 100644
--- a/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt
+++ b/tests/baselines/reference/templateStringsArrayTypeDefinedInES5Mode.errors.txt
@@ -1,5 +1,5 @@
-tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'.
-  Property 'raw' is missing in type '{}'.
+tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'TemplateStringsArray'.
+  Property 'raw' is missing in type '{ [x: number]: undefined; }'.
 
 
 ==== tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts (1 errors) ====
@@ -12,7 +12,7 @@ tests/cases/compiler/templateStringsArrayTypeDefinedInES5Mode.ts(8,3): error TS2
     
     f({}, 10, 10);
       ~~
-!!! error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'.
-!!! error TS2345:   Property 'raw' is missing in type '{}'.
+!!! error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'TemplateStringsArray'.
+!!! error TS2345:   Property 'raw' is missing in type '{ [x: number]: undefined; }'.
     
     f `abcdef${ 1234 }${ 5678 }ghijkl`;
\ No newline at end of file
diff --git a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt
index f410d408482..ac30556a235 100644
--- a/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt
+++ b/tests/baselines/reference/templateStringsArrayTypeRedefinedInES6Mode.errors.txt
@@ -1,5 +1,5 @@
-tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'.
-  Property 'raw' is missing in type '{}'.
+tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'TemplateStringsArray'.
+  Property 'raw' is missing in type '{ [x: number]: undefined; }'.
 
 
 ==== tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts (1 errors) ====
@@ -12,7 +12,7 @@ tests/cases/compiler/templateStringsArrayTypeRedefinedInES6Mode.ts(8,3): error T
     
     f({}, 10, 10);
       ~~
-!!! error TS2345: Argument of type '{}' is not assignable to parameter of type 'TemplateStringsArray'.
-!!! error TS2345:   Property 'raw' is missing in type '{}'.
+!!! error TS2345: Argument of type '{ [x: number]: undefined; }' is not assignable to parameter of type 'TemplateStringsArray'.
+!!! error TS2345:   Property 'raw' is missing in type '{ [x: number]: undefined; }'.
     
     f `abcdef${ 1234 }${ 5678 }ghijkl`;
\ No newline at end of file
diff --git a/tests/baselines/reference/typeAliasDeclareKeyword01.d.symbols b/tests/baselines/reference/typeAliasDeclareKeyword01.d.symbols
new file mode 100644
index 00000000000..86c1ae8f40c
--- /dev/null
+++ b/tests/baselines/reference/typeAliasDeclareKeyword01.d.symbols
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/typeAliasDeclareKeyword01.d.ts ===
+type Foo = number;
+>Foo : Symbol(Foo, Decl(typeAliasDeclareKeyword01.d.ts, 0, 0))
+
+declare type Bar = string;
+>Bar : Symbol(Bar, Decl(typeAliasDeclareKeyword01.d.ts, 0, 18))
+
diff --git a/tests/baselines/reference/typeAliasDeclareKeyword01.d.types b/tests/baselines/reference/typeAliasDeclareKeyword01.d.types
new file mode 100644
index 00000000000..588fdd9012c
--- /dev/null
+++ b/tests/baselines/reference/typeAliasDeclareKeyword01.d.types
@@ -0,0 +1,7 @@
+=== tests/cases/compiler/typeAliasDeclareKeyword01.d.ts ===
+type Foo = number;
+>Foo : number
+
+declare type Bar = string;
+>Bar : string
+
diff --git a/tests/baselines/reference/unionTypeCallSignatures.errors.txt b/tests/baselines/reference/unionTypeCallSignatures.errors.txt
index ebe38a589ee..bf1de6ff8e8 100644
--- a/tests/baselines/reference/unionTypeCallSignatures.errors.txt
+++ b/tests/baselines/reference/unionTypeCallSignatures.errors.txt
@@ -28,9 +28,10 @@ tests/cases/conformance/types/union/unionTypeCallSignatures.ts(67,12): error TS2
 tests/cases/conformance/types/union/unionTypeCallSignatures.ts(68,12): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/conformance/types/union/unionTypeCallSignatures.ts(69,12): error TS2346: Supplied parameters do not match any signature of call target.
 tests/cases/conformance/types/union/unionTypeCallSignatures.ts(70,12): error TS2346: Supplied parameters do not match any signature of call target.
+tests/cases/conformance/types/union/unionTypeCallSignatures.ts(73,12): error TS2346: Supplied parameters do not match any signature of call target.
 
 
-==== tests/cases/conformance/types/union/unionTypeCallSignatures.ts (30 errors) ====
+==== tests/cases/conformance/types/union/unionTypeCallSignatures.ts (31 errors) ====
     var numOrDate: number | Date;
     var strOrBoolean: string | boolean;
     var strOrNum: string | number;
@@ -162,4 +163,9 @@ tests/cases/conformance/types/union/unionTypeCallSignatures.ts(70,12): error TS2
                ~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! error TS2346: Supplied parameters do not match any signature of call target.
     
+    var unionWithRestParameter4: { (...a: string[]): string; } | { (a: string, b: string): number; };
+    strOrNum = unionWithRestParameter4("hello"); // error supplied parameters do not match any call signature
+               ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2346: Supplied parameters do not match any signature of call target.
+    strOrNum = unionWithRestParameter4("hello", "world");
     
\ No newline at end of file
diff --git a/tests/baselines/reference/unionTypeCallSignatures.js b/tests/baselines/reference/unionTypeCallSignatures.js
index fc3dfc8ebbc..103d92fbef3 100644
--- a/tests/baselines/reference/unionTypeCallSignatures.js
+++ b/tests/baselines/reference/unionTypeCallSignatures.js
@@ -70,6 +70,9 @@ strOrNum = unionWithRestParameter3('hello', 10, 11); // error no call signature
 strOrNum = unionWithRestParameter3('hello', "hello"); // error no call signature
 strOrNum = unionWithRestParameter3(); // error no call signature
 
+var unionWithRestParameter4: { (...a: string[]): string; } | { (a: string, b: string): number; };
+strOrNum = unionWithRestParameter4("hello"); // error supplied parameters do not match any call signature
+strOrNum = unionWithRestParameter4("hello", "world");
 
 
 //// [unionTypeCallSignatures.js]
@@ -132,3 +135,6 @@ strOrNum = unionWithRestParameter3('hello', 10); // error no call signature
 strOrNum = unionWithRestParameter3('hello', 10, 11); // error no call signature
 strOrNum = unionWithRestParameter3('hello', "hello"); // error no call signature
 strOrNum = unionWithRestParameter3(); // error no call signature
+var unionWithRestParameter4;
+strOrNum = unionWithRestParameter4("hello"); // error supplied parameters do not match any call signature
+strOrNum = unionWithRestParameter4("hello", "world");
diff --git a/tests/cases/compiler/bindingPatternInParameter01.ts b/tests/cases/compiler/bindingPatternInParameter01.ts
new file mode 100644
index 00000000000..3b3a4312f87
--- /dev/null
+++ b/tests/cases/compiler/bindingPatternInParameter01.ts
@@ -0,0 +1,5 @@
+const nestedArray = [[[1, 2]], [[3, 4]]];
+
+nestedArray.forEach(([[a, b]]) => {
+  console.log(a, b);
+});
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..0467267626c
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop8.ts
@@ -0,0 +1,125 @@
+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 == 3) {
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+                return;
+            }
+        }
+    }
+}
+
+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 == 3) {
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+                return;
+            }
+        }
+    }
+}
diff --git a/tests/cases/compiler/capturedLetConstInLoop8_ES6.ts b/tests/cases/compiler/capturedLetConstInLoop8_ES6.ts
new file mode 100644
index 00000000000..0cad7bad6a7
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop8_ES6.ts
@@ -0,0 +1,126 @@
+// @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 == 3) {
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+                return;
+            }
+        }
+    }
+}
+
+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 == 3) {
+                    return;
+                }
+            }
+            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";
+            }
+            if (x == 3) {
+                return;
+            }
+        }
+    }
+}
diff --git a/tests/cases/compiler/capturedLetConstInLoop9.ts b/tests/cases/compiler/capturedLetConstInLoop9.ts
new file mode 100644
index 00000000000..4b67349690d
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop9.ts
@@ -0,0 +1,138 @@
+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;
+            }
+            
+            () => b
+            return 100;
+        }
+
+        
+        () => 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;
+            }
+        }
+    }
+}
+
+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
new file mode 100644
index 00000000000..25c696ff7e6
--- /dev/null
+++ b/tests/cases/compiler/capturedLetConstInLoop9_ES6.ts
@@ -0,0 +1,139 @@
+// @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;
+            }
+            () => b
+            return 100;
+        }
+
+        
+        () => 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;
+            }
+        }
+    }
+}
+
+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/downlevelLetConst18.ts b/tests/cases/compiler/downlevelLetConst18.ts
index d40f23e3a37..61cb2f46cc9 100644
--- a/tests/cases/compiler/downlevelLetConst18.ts
+++ b/tests/cases/compiler/downlevelLetConst18.ts
@@ -8,7 +8,7 @@ for (let x; ;) {
 }
 
 for (let x; ;) {
-    function foo() { x };
+    function foo1() { x };
 }
 
 for (let x; ;) {
diff --git a/tests/cases/compiler/typeAliasDeclareKeyword01.d.ts b/tests/cases/compiler/typeAliasDeclareKeyword01.d.ts
new file mode 100644
index 00000000000..cf2a5061937
--- /dev/null
+++ b/tests/cases/compiler/typeAliasDeclareKeyword01.d.ts
@@ -0,0 +1,2 @@
+type Foo = number;
+declare type Bar = string;
\ No newline at end of file
diff --git a/tests/cases/conformance/classes/classDeclarations/mergedInheritedClassInterface.ts b/tests/cases/conformance/classes/classDeclarations/mergedInheritedClassInterface.ts
new file mode 100644
index 00000000000..e3bc08e3307
--- /dev/null
+++ b/tests/cases/conformance/classes/classDeclarations/mergedInheritedClassInterface.ts
@@ -0,0 +1,45 @@
+interface BaseInterface {
+    required: number;
+    optional?: number;
+}
+
+class BaseClass {
+    baseMethod() { }
+    baseNumber: number;
+}
+
+interface Child extends BaseInterface {
+    additional: number;
+}
+
+class Child extends BaseClass {
+    classNumber: number;
+    method() { }
+}
+
+interface ChildNoBaseClass extends BaseInterface {
+    additional2: string;
+}
+class ChildNoBaseClass {
+    classString: string;
+    method2() { }
+}
+class Grandchild extends ChildNoBaseClass {
+}
+
+// checks if properties actually were merged
+var child : Child;
+child.required;
+child.optional;
+child.additional;
+child.baseNumber;
+child.classNumber;
+child.baseMethod();
+child.method();
+
+var grandchild: Grandchild;
+grandchild.required;
+grandchild.optional;
+grandchild.additional2;
+grandchild.classString;
+grandchild.method2();
diff --git a/tests/cases/conformance/types/union/unionTypeCallSignatures.ts b/tests/cases/conformance/types/union/unionTypeCallSignatures.ts
index ca599329743..a25d27d9a29 100644
--- a/tests/cases/conformance/types/union/unionTypeCallSignatures.ts
+++ b/tests/cases/conformance/types/union/unionTypeCallSignatures.ts
@@ -69,3 +69,6 @@ strOrNum = unionWithRestParameter3('hello', 10, 11); // error no call signature
 strOrNum = unionWithRestParameter3('hello', "hello"); // error no call signature
 strOrNum = unionWithRestParameter3(); // error no call signature
 
+var unionWithRestParameter4: { (...a: string[]): string; } | { (a: string, b: string): number; };
+strOrNum = unionWithRestParameter4("hello"); // error supplied parameters do not match any call signature
+strOrNum = unionWithRestParameter4("hello", "world");
diff --git a/tests/cases/fourslash/parameterWithNestedDestructuring.ts b/tests/cases/fourslash/parameterWithNestedDestructuring.ts
new file mode 100644
index 00000000000..fa3c4e55294
--- /dev/null
+++ b/tests/cases/fourslash/parameterWithNestedDestructuring.ts
@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts'/>
+
+////[[{foo: 'hello', bar: [1]}]]
+////  .map(([{foo, bar: [baz]}]) => /*1*/foo + /*2*/baz);
+
+goTo.marker('1');
+verify.quickInfoIs('var foo: string');
+
+goTo.marker('2');
+verify.quickInfoIs('var baz: number');
diff --git a/tests/webTestServer.ts b/tests/webTestServer.ts
index aba6dd81982..6ddc18f1344 100644
--- a/tests/webTestServer.ts
+++ b/tests/webTestServer.ts
@@ -5,6 +5,7 @@ import fs = require("fs");
 import path = require("path");
 import url = require("url");
 import child_process = require("child_process");
+import os = require('os');
 
 /// Command line processing ///
 
@@ -262,7 +263,20 @@ http.createServer(function (req: http.ServerRequest, res: http.ServerResponse) {
 
 var browserPath: string;
 if ((browser && browser === 'chrome')) {
-    var defaultChromePath = "C:/Program Files (x86)/Google/Chrome/Application/chrome.exe";
+    let defaultChromePath = "";
+    switch (os.platform()) {
+        case "win32":
+        case "win64":
+            defaultChromePath = "C:/Program Files (x86)/Google/Chrome/Application/chrome.exe";
+            break;
+        case "linux":
+            defaultChromePath = "/opt/google/chrome/chrome"
+            break;
+        default:
+            console.log(`default Chrome location is unknown for platform '${os.platform()}'`);
+            break;
+    }
+
     if (fs.existsSync(defaultChromePath)) {
         browserPath = defaultChromePath;
     } else {
diff --git a/tslint.json b/tslint.json
index 19ccd30ca9f..db10daa3fcc 100644
--- a/tslint.json
+++ b/tslint.json
@@ -38,6 +38,7 @@
         "no-trailing-whitespace": true,
         "no-inferrable-types": true,
         "no-null": true,
-        "boolean-trivia": true
+        "boolean-trivia": true,
+        "type-operator-spacing": true
   }
 }