Add support for captured block scoped bindings

src/compiler/factory.ts

@@ -482,6 +482,19 @@ namespace ts {
         return node;
     }
 
+    export function createSwitch(expression: Expression, caseBlock: CaseBlock, location?: TextRange): SwitchStatement {
+        const node = <SwitchStatement>createNode(SyntaxKind.SwitchStatement, location);
+        node.expression = parenthesizeExpressionForList(expression);
+        node.caseBlock = caseBlock;
+        return node;
+    }
+
+    export function createCaseBlock(clauses: CaseClause[], location?: TextRange): CaseBlock {
+        const node = <CaseBlock>createNode(SyntaxKind.CaseBlock, location);
+        node.clauses = createNodeArray(clauses);
+        return node;
+    }
+
     export function createFor(initializer: ForInitializer, condition: Expression, incrementor: Expression, statement: Statement, location?: TextRange) {
         const node = <ForStatement>createNode(SyntaxKind.ForStatement, location);
         node.initializer = initializer;
@@ -687,6 +700,22 @@ namespace ts {
         );
     }
 
+    export function createBreak(label?: Identifier, location?: TextRange): BreakStatement {
+        const node = <BreakStatement>createNode(SyntaxKind.BreakStatement, location);
+        if (label) {
+            node.label = label;
+        }
+        return node;
+    }
+
+    export function createContinue(label?: Identifier, location?: TextRange): BreakStatement {
+        const node = <ContinueStatement>createNode(SyntaxKind.ContinueStatement, location);
+        if (label) {
+            node.label = label;
+        }
+        return node;
+    }
+
     export function createFunctionApply(func: Expression, thisArg: Expression, argumentsExpression: Expression, location?: TextRange) {
         return createCall(
             createPropertyAccess(func, "apply"),
@@ -1349,8 +1378,11 @@ namespace ts {
                 return clone;
             }
         }
-        else if (getLeftmostExpression(expression).kind === SyntaxKind.ObjectLiteralExpression) {
-            return createParen(expression, /*location*/ expression);
+        else {
+            const leftmostExpressionKind = getLeftmostExpression(expression).kind;
+            if (leftmostExpressionKind === SyntaxKind.ObjectLiteralExpression || leftmostExpressionKind === SyntaxKind.FunctionExpression) {
+                return createParen(expression, /*location*/ expression);
+            }
         }
 
         return expression;

src/compiler/printer.ts

@@ -1751,7 +1751,16 @@ const _super = (function (geti, seti) {
             }
 
             function emitCaseOrDefaultClauseStatements(parentNode: Node, statements: NodeArray<Statement>) {
-                if (statements.length === 1 && rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile)) {
+                const emitAsSingleStatement = 
+                    statements.length === 1 &&
+                    (
+                        // treat synthesized nodes as located on the same line for emit purposes
+                        nodeIsSynthesized(parentNode) ||
+                        nodeIsSynthesized(statements[0]) ||
+                        rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile)
+                    );
+
+                if (emitAsSingleStatement) {
                     write(" ");
                     emit(statements[0]);
                 }

src/compiler/transformers/destructuring.ts

@@ -165,7 +165,7 @@ namespace ts {
 
         const pendingAssignments: Expression[] = [];
 
-        flattenDestructuring(context, node, /*value*/ undefined, node, emitAssignment, emitTempVariableAssignment);
+        flattenDestructuring(context, node, /*value*/ undefined, node, emitAssignment, emitTempVariableAssignment, visitor);
 
         const expression = inlineExpressions(pendingAssignments);
         aggregateTransformFlags(expression);