Support labeled statement

src/compiler/transformers/es2017.ts

@@ -95,6 +95,8 @@ namespace ts {
                     return visitForInStatementInAsyncBody(<ForInStatement>node);
                 case SyntaxKind.ForOfStatement:
                     return visitForOfStatementInAsyncBody(<ForOfStatement>node);
+                case SyntaxKind.CatchClause:
+                    return visitCatchClauseInAsyncBody(<CatchClause>node);
                 case SyntaxKind.Block:
                 case SyntaxKind.SwitchStatement:
                 case SyntaxKind.CaseBlock:
@@ -105,10 +107,10 @@ namespace ts {
                 case SyntaxKind.WhileStatement:
                 case SyntaxKind.IfStatement:
                 case SyntaxKind.WithStatement:
+                case SyntaxKind.LabeledStatement:
                     return visitEachChild(node, asyncBodyVisitor, context);
-                case SyntaxKind.CatchClause:
-                    return visitCatchClauseInAsyncBody(<CatchClause>node);
             }
+            Debug.assert(!isNodeWithPossibleVarDeclaration(node), "Unhandled node.");
             return visitor(node);
         }
 

src/compiler/utilities.ts

@@ -1761,6 +1761,35 @@ namespace ts {
         return getAssignmentTargetKind(node) !== AssignmentKind.None;
     }
 
+    /**
+     * Indicates whether a node could contain embedded statements that share the same `var`
+     * declaration scope as its parent.
+     */
+    export function isNodeWithPossibleVarDeclaration(node: Node) {
+        switch (node.kind) {
+            case SyntaxKind.SourceFile:
+            case SyntaxKind.Block:
+            case SyntaxKind.WithStatement:
+            case SyntaxKind.IfStatement:
+            case SyntaxKind.SwitchStatement:
+            case SyntaxKind.CaseBlock:
+            case SyntaxKind.CaseClause:
+            case SyntaxKind.DefaultClause:
+            case SyntaxKind.LabeledStatement:
+            case SyntaxKind.ForStatement:
+            case SyntaxKind.ForInStatement:
+            case SyntaxKind.ForOfStatement:
+            case SyntaxKind.DoStatement:
+            case SyntaxKind.WhileStatement:
+            case SyntaxKind.TryStatement:
+            case SyntaxKind.CatchClause:
+            case SyntaxKind.ModuleDeclaration:
+            case SyntaxKind.ModuleBlock:
+                return true;
+        }
+        return false;
+    }
+
     function walkUp(node: Node, kind: SyntaxKind) {
         while (node && node.kind === kind) {
             node = node.parent;

tests/baselines/reference/asyncWithVarShadowing_es6.js

@@ -203,6 +203,13 @@ async function fn38(x) {
         case y:
             var x;
     }
+}
+
+async function fn39(x) {
+    foo: {
+        var x;
+        break foo;
+    }
 }
 
 //// [asyncWithVarShadowing_es6.js]
@@ -461,3 +468,11 @@ function fn38(x) {
     });
     var x;
 }
+function fn39(x) {
+    return __awaiter(this, void 0, void 0, function* () {
+        foo: {
+            break foo;
+        }
+    });
+    var x;
+}

tests/baselines/reference/asyncWithVarShadowing_es6.symbols

@@ -404,3 +404,15 @@ async function fn38(x) {
 >x : Symbol(x, Decl(asyncWithVarShadowing_es6.ts, 199, 20), Decl(asyncWithVarShadowing_es6.ts, 202, 15))
     }
 }
+
+async function fn39(x) {
+>fn39 : Symbol(fn39, Decl(asyncWithVarShadowing_es6.ts, 204, 1))
+>x : Symbol(x, Decl(asyncWithVarShadowing_es6.ts, 206, 20), Decl(asyncWithVarShadowing_es6.ts, 208, 11))
+
+    foo: {
+        var x;
+>x : Symbol(x, Decl(asyncWithVarShadowing_es6.ts, 206, 20), Decl(asyncWithVarShadowing_es6.ts, 208, 11))
+
+        break foo;
+    }
+}

tests/baselines/reference/asyncWithVarShadowing_es6.types

@@ -408,3 +408,18 @@ async function fn38(x) {
 >x : any
     }
 }
+
+async function fn39(x) {
+>fn39 : (x: any) => Promise<void>
+>x : any
+
+    foo: {
+>foo : any
+
+        var x;
+>x : any
+
+        break foo;
+>foo : any
+    }
+}

tests/cases/conformance/async/es6/asyncWithVarShadowing_es6.ts

@@ -204,4 +204,11 @@ async function fn38(x) {
         case y:
             var x;
     }
+}
+
+async function fn39(x) {
+    foo: {
+        var x;
+        break foo;
+    }
 }