Merge pull request #9852 from Microsoft/transforms-visitPerf

[Transforms] Address visitor performance.

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

@@ -1441,6 +1441,7 @@ namespace ts {
             // checked is to not pass the file to getEmitResolver.
             const emitResolver = getDiagnosticsProducingTypeChecker().getEmitResolver((options.outFile || options.out) ? undefined : sourceFile);
 
+            performance.emit("beforeEmit");
             const emitStart = performance.mark();
 
             const emitResult = emitFiles(
@@ -1449,6 +1450,7 @@ namespace ts {
                 sourceFile);
 
             performance.measure("emitTime", emitStart);
+            performance.emit("afterEmit");
 
             return emitResult;
         }

src/compiler/program.ts

@@ -351,7 +351,9 @@ namespace ts {
             value = ensureIdentifier(value, /*reuseIdentifierExpressions*/ true, location, emitTempVariableAssignment);
             return createConditional(
                 createStrictEquality(value, createVoidZero()),
+                createToken(SyntaxKind.QuestionToken),
                 defaultValue,
+                createToken(SyntaxKind.ColonToken),
                 value
             );
         }

src/compiler/transformers/destructuring.ts

@@ -1196,7 +1196,7 @@ namespace ts {
          */
         function transformAccessorsToStatement(receiver: LeftHandSideExpression, accessors: AllAccessorDeclarations): Statement {
             const statement = createStatement(
-                transformAccessorsToExpression(receiver, accessors),
+                transformAccessorsToExpression(receiver, accessors, /*startsOnNewLine*/ false),
                 /*location*/ getSourceMapRange(accessors.firstAccessor)
             );
 
@@ -1213,7 +1213,7 @@ namespace ts {
          *
          * @param receiver The receiver for the member.
          */
-        function transformAccessorsToExpression(receiver: LeftHandSideExpression, { firstAccessor, getAccessor, setAccessor }: AllAccessorDeclarations): Expression {
+        function transformAccessorsToExpression(receiver: LeftHandSideExpression, { firstAccessor, getAccessor, setAccessor }: AllAccessorDeclarations, startsOnNewLine: boolean): Expression {
             // To align with source maps in the old emitter, the receiver and property name
             // arguments are both mapped contiguously to the accessor name.
             const target = getMutableClone(receiver);
@@ -1246,7 +1246,7 @@ namespace ts {
                 createPropertyAssignment("configurable", createLiteral(true))
             );
 
-            return createCall(
+            const call = createCall(
                 createPropertyAccess(createIdentifier("Object"), "defineProperty"),
                 /*typeArguments*/ undefined,
                 [
@@ -1255,6 +1255,10 @@ namespace ts {
                     createObjectLiteral(properties, /*location*/ undefined, /*multiLine*/ true)
                 ]
             );
+            if (startsOnNewLine) {
+                call.startsOnNewLine = true;
+            }
+            return call;
         }
 
         /**
@@ -1895,26 +1899,27 @@ namespace ts {
 
             // Write out the first non-computed properties, then emit the rest through indexing on the temp variable.
             const expressions: Expression[] = [];
-            addNode(expressions,
-                createAssignment(
-                    temp,
-                    setNodeEmitFlags(
-                        createObjectLiteral(
-                            visitNodes(properties, visitor, isObjectLiteralElement, 0, numInitialProperties),
-                            /*location*/ undefined,
-                            node.multiLine
-                        ),
-                        NodeEmitFlags.Indented
-                    )
-                ),
-                node.multiLine
+            const assignment = createAssignment(
+                temp,
+                setNodeEmitFlags(
+                    createObjectLiteral(
+                        visitNodes(properties, visitor, isObjectLiteralElement, 0, numInitialProperties),
+                        /*location*/ undefined,
+                        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
-            addNode(expressions, getMutableClone(temp), node.multiLine);
+            expressions.push(node.multiLine ? startOnNewLine(getMutableClone(temp)) : temp);
             return inlineExpressions(expressions);
         }
 
@@ -2313,21 +2318,21 @@ namespace ts {
                     case SyntaxKind.SetAccessor:
                         const accessors = getAllAccessorDeclarations(node.properties, <AccessorDeclaration>property);
                         if (property === accessors.firstAccessor) {
-                            addNode(expressions, transformAccessorsToExpression(receiver, accessors), node.multiLine);
+                            expressions.push(transformAccessorsToExpression(receiver, accessors, node.multiLine));
                         }
 
                         break;
 
                     case SyntaxKind.PropertyAssignment:
-                        addNode(expressions, transformPropertyAssignmentToExpression(node, <PropertyAssignment>property, receiver), node.multiLine);
+                        expressions.push(transformPropertyAssignmentToExpression(node, <PropertyAssignment>property, receiver, node.multiLine));
                         break;
 
                     case SyntaxKind.ShorthandPropertyAssignment:
-                        addNode(expressions, transformShorthandPropertyAssignmentToExpression(node, <ShorthandPropertyAssignment>property, receiver), node.multiLine);
+                        expressions.push(transformShorthandPropertyAssignmentToExpression(node, <ShorthandPropertyAssignment>property, receiver, node.multiLine));
                         break;
 
                     case SyntaxKind.MethodDeclaration:
-                        addNode(expressions, transformObjectLiteralMethodDeclarationToExpression(node, <MethodDeclaration>property, receiver), node.multiLine);
+                        expressions.push(transformObjectLiteralMethodDeclarationToExpression(node, <MethodDeclaration>property, receiver, node.multiLine));
                         break;
 
                     default:
@@ -2344,15 +2349,19 @@ namespace ts {
          * @param property The PropertyAssignment node.
          * @param receiver The receiver for the assignment.
          */
-        function transformPropertyAssignmentToExpression(node: ObjectLiteralExpression, property: PropertyAssignment, receiver: Expression) {
-            return createAssignment(
+        function transformPropertyAssignmentToExpression(node: ObjectLiteralExpression, property: PropertyAssignment, receiver: Expression, startsOnNewLine: boolean) {
+            const expression = createAssignment(
                 createMemberAccessForPropertyName(
                     receiver,
                     visitNode(property.name, visitor, isPropertyName)
                 ),
                 visitNode(property.initializer, visitor, isExpression),
                 /*location*/ property
             );
+            if (startsOnNewLine) {
+                expression.startsOnNewLine = true;
+            }
+            return expression;
         }
 
         /**
@@ -2362,15 +2371,19 @@ namespace ts {
          * @param property The ShorthandPropertyAssignment node.
          * @param receiver The receiver for the assignment.
          */
-        function transformShorthandPropertyAssignmentToExpression(node: ObjectLiteralExpression, property: ShorthandPropertyAssignment, receiver: Expression) {
-            return createAssignment(
+        function transformShorthandPropertyAssignmentToExpression(node: ObjectLiteralExpression, property: ShorthandPropertyAssignment, receiver: Expression, startsOnNewLine: boolean) {
+            const expression = createAssignment(
                 createMemberAccessForPropertyName(
                     receiver,
                     visitNode(property.name, visitor, isPropertyName)
                 ),
                 getSynthesizedClone(property.name),
                 /*location*/ property
             );
+            if (startsOnNewLine) {
+                expression.startsOnNewLine = true;
+            }
+            return expression;
         }
 
         /**
@@ -2380,15 +2393,19 @@ namespace ts {
          * @param method The MethodDeclaration node.
          * @param receiver The receiver for the assignment.
          */
-        function transformObjectLiteralMethodDeclarationToExpression(node: ObjectLiteralExpression, method: MethodDeclaration, receiver: Expression) {
-            return createAssignment(
+        function transformObjectLiteralMethodDeclarationToExpression(node: ObjectLiteralExpression, method: MethodDeclaration, receiver: Expression, startsOnNewLine: boolean) {
+            const expression = createAssignment(
                 createMemberAccessForPropertyName(
                     receiver,
                     visitNode(method.name, visitor, isPropertyName)
                 ),
                 transformFunctionLikeToExpression(method, /*location*/ method, /*name*/ undefined),
                 /*location*/ method
             );
+            if (startsOnNewLine) {
+                expression.startsOnNewLine = true;
+            }
+            return expression;
         }
 
         /**

src/compiler/transformers/es6.ts

@@ -580,8 +580,8 @@ namespace ts {
             transformAndEmitStatements(body.statements, statementOffset);
 
             const buildResult = build();
-            addNodes(statements, endLexicalEnvironment());
-            addNode(statements, createReturn(buildResult));
+            addRange(statements, endLexicalEnvironment());
+            statements.push(createReturn(buildResult));
 
             // Restore previous generator state
             inGeneratorFunctionBody = savedInGeneratorFunctionBody;
@@ -1019,7 +1019,7 @@ namespace ts {
             );
 
             const expressions = reduceLeft(properties, reduceProperty, <Expression[]>[], numInitialProperties);
-            addNode(expressions, getMutableClone(temp), multiLine);
+            expressions.push(multiLine ? startOnNewLine(getMutableClone(temp)) : temp);
             return inlineExpressions(expressions);
 
             function reduceProperty(expressions: Expression[], property: ObjectLiteralElement) {
@@ -1029,7 +1029,13 @@ namespace ts {
                 }
 
                 const expression = createExpressionForObjectLiteralElement(node, property, temp);
-                addNode(expressions, visitNode(expression, visitor, isExpression), multiLine);
+                const visited = visitNode(expression, visitor, isExpression);
+                if (visited) {
+                    if (multiLine) {
+                        visited.startsOnNewLine = true;
+                    }
+                    expressions.push(visited);
+                }
                 return expressions;
             }
         }

src/compiler/transformers/generators.ts

@@ -65,7 +65,11 @@ namespace ts {
                 return node;
             }
             return newExportClause
-                ? createExportDeclaration(newExportClause, node.moduleSpecifier)
+                ? createExportDeclaration(
+                    /*decorators*/ undefined,
+                    /*modifiers*/ undefined,
+                    newExportClause,
+                    node.moduleSpecifier)
                 : undefined;
         }
 
@@ -92,7 +96,11 @@ namespace ts {
                     return undefined;
                 }
                 else if (newImportClause !== node.importClause) {
-                    return createImportDeclaration(newImportClause, node.moduleSpecifier);
+                    return createImportDeclaration(
+                        /*decorators*/ undefined,
+                        /*modifiers*/ undefined,
+                        newImportClause,
+                        node.moduleSpecifier);
                 }
             }
             return node;

src/compiler/transformers/module/es6.ts

@@ -734,8 +734,10 @@ namespace ts {
                 statements.push(
                     setOriginalNode(
                         createClassDeclaration(
+                            /*decorators*/ undefined,
                             /*modifiers*/ undefined,
                             name,
+                            /*typeParameters*/ undefined,
                             node.heritageClauses,
                             node.members,
                             /*location*/ node
@@ -908,7 +910,7 @@ namespace ts {
                     setNodeEmitFlags(node, NodeEmitFlags.NoSubstitution);
                     let transformedUnaryExpression: BinaryExpression;
                     if (node.kind === SyntaxKind.PostfixUnaryExpression) {
-                        transformedUnaryExpression = createBinaryWithOperatorToken(
+                        transformedUnaryExpression = createBinary(
                             operand,
                             createNode(operator === SyntaxKind.PlusPlusToken ? SyntaxKind.PlusEqualsToken : SyntaxKind.MinusEqualsToken),
                             createLiteral(1),