Fix several test failures.

Author: rbuckton

src/compiler/core.ts

@@ -355,7 +355,9 @@ namespace ts {
     export function addRange<T>(to: T[], from: T[]): void {
         if (to && from) {
             for (const v of from) {
-                to.push(v);
+                if (v !== undefined) {
+                    to.push(v);
+                }
             }
         }
     }

src/compiler/factory.ts

@@ -2635,8 +2635,8 @@ namespace ts {
         return node;
     }
 
-    export function startOnNewLine<T extends Node>(node: T, startsOnNewLine?: boolean): T {
-        node.startsOnNewLine = startsOnNewLine !== false;
+    export function startOnNewLine<T extends Node>(node: T): T {
+        node.startsOnNewLine = true;
         return node;
     }
 

src/compiler/transformers/es6.ts

@@ -1899,28 +1899,27 @@ namespace ts {
 
             // Write out the first non-computed properties, then emit the rest through indexing on the temp variable.
             const expressions: Expression[] = [];
-            expressions.push(
-                startOnNewLine(
-                    createAssignment(
-                        temp,
-                        setNodeEmitFlags(
-                            createObjectLiteral(
-                                visitNodes(properties, visitor, isObjectLiteralElement, 0, numInitialProperties),
-                                /*location*/ undefined,
-                                node.multiLine
-                            ),
-                            NodeEmitFlags.Indented
-                        )
+            const assignment = createAssignment(
+                temp,
+                setNodeEmitFlags(
+                    createObjectLiteral(
+                        visitNodes(properties, visitor, isObjectLiteralElement, 0, numInitialProperties),
+                        /*location*/ undefined,
+                        node.multiLine
                     ),
-                    node.multiLine
+                    NodeEmitFlags.Indented
                 )
             );
+            if (node.multiLine) {
+                assignment.startsOnNewLine = true;
+            }
+            expressions.push(assignment);
 
             addObjectLiteralMembers(expressions, node, temp, numInitialProperties);
 
             // We need to clone the temporary identifier so that we can write it on a
             // new line
-            expressions.push(startOnNewLine(getMutableClone(temp), node.multiLine));
+            expressions.push(node.multiLine ? startOnNewLine(getMutableClone(temp)) : temp);
             return inlineExpressions(expressions);
         }
 

src/compiler/visitor.ts

@@ -827,19 +827,19 @@ namespace ts {
 
             case SyntaxKind.DeleteExpression:
                 return updateDelete(<DeleteExpression>node,
-                    visitNode((<DeleteExpression>node).expression, visitor, isUnaryExpression));
+                    visitNode((<DeleteExpression>node).expression, visitor, isExpression));
 
             case SyntaxKind.TypeOfExpression:
                 return updateTypeOf(<TypeOfExpression>node,
-                    visitNode((<TypeOfExpression>node).expression, visitor, isUnaryExpression));
+                    visitNode((<TypeOfExpression>node).expression, visitor, isExpression));
 
             case SyntaxKind.VoidExpression:
                 return updateVoid(<VoidExpression>node,
-                    visitNode((<VoidExpression>node).expression, visitor, isUnaryExpression));
+                    visitNode((<VoidExpression>node).expression, visitor, isExpression));
 
             case SyntaxKind.AwaitExpression:
                 return updateAwait(<AwaitExpression>node,
-                    visitNode((<AwaitExpression>node).expression, visitor, isUnaryExpression));
+                    visitNode((<AwaitExpression>node).expression, visitor, isExpression));
 
             case SyntaxKind.BinaryExpression:
                 return updateBinary(<BinaryExpression>node,