Merge branch 'transforms-transformer' into transforms-transformer-ts

microsoft · rbuckton · Mar 18, 2016 · Feb 9, 2016 · Feb 9, 2016 · Feb 9, 2016
commit c4dc2ae46dce89507644f5d62e29c77719d025a8
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
@@ -78,14 +78,17 @@ namespace ts {
         return array;
     }
 
-    function setModifiers(node: Node, modifiers: Modifier[]) {
+    export function setModifiers<T extends Node>(node: T, modifiers: Modifier[]) {
         if (modifiers) {
-            node.modifiers = createSynthesizedModifiersArray(modifiers);
-            node.flags |= node.modifiers.flags;
+            const array = createModifiersArray(modifiers);
+            node.modifiers = array;
+            node.flags |= array.flags;
         }
         else {
             node.modifiers = undefined;
         }
+
+        return node;
     }
 
     export function createSynthesizedNode(kind: SyntaxKind, startsOnNewLine?: boolean): Node {
@@ -224,7 +227,7 @@ namespace ts {
         const node = <MethodDeclaration>createNode(SyntaxKind.MethodDeclaration, location);
         node.decorators = undefined;
         setModifiers(node, modifiers);
-        node.name = coercePropertyName(name);
+        node.name = typeof name === "string" ? createIdentifier(name) : name;
         node.typeParameters = undefined;
         node.parameters = createNodeArray(parameters);
         node.body = body;
@@ -246,7 +249,7 @@ namespace ts {
         const node = <GetAccessorDeclaration>createNode(SyntaxKind.GetAccessor, location);
         node.decorators = undefined;
         setModifiers(node, modifiers);
-        node.name = coercePropertyName(name);
+        node.name = typeof name === "string" ? createIdentifier(name) : name;
         node.typeParameters = undefined;
         node.parameters = createNodeArray<ParameterDeclaration>();
         node.body = body;
@@ -257,7 +260,7 @@ namespace ts {
         const node = <SetAccessorDeclaration>createNode(SyntaxKind.SetAccessor, location);
         node.decorators = undefined;
         setModifiers(node, modifiers);
-        node.name = coercePropertyName(name);
+        node.name = typeof name === "string" ? createIdentifier(name) : name;
         node.typeParameters = undefined;
         node.parameters = createNodeArray([parameter]);
         node.body = body;
@@ -269,7 +272,7 @@ namespace ts {
         node.decorators = undefined;
         node.modifiers = undefined;
         node.dotDotDotToken = undefined;
-        node.name = coerceBindingName(name);
+        node.name = typeof name === "string" ? createIdentifier(name) : name;
         node.questionToken = undefined;
         node.type = undefined;
         node.initializer = initializer;
@@ -299,7 +302,7 @@ namespace ts {
         return node;
     }
 
-    export function createElementAccess(expression: Expression, index: string | number | Expression, location?: TextRange) {
+    export function createElementAccess(expression: Expression, index: number | Expression, location?: TextRange) {
         const node = <ElementAccessExpression>createNode(SyntaxKind.ElementAccessExpression, location);
         node.expression = parenthesizeForAccess(expression);
         node.argumentExpression = typeof index === "number" ? createLiteral(index) : index;
@@ -323,7 +326,7 @@ namespace ts {
         const node = <FunctionExpression>createNode(SyntaxKind.FunctionExpression, location);
         node.modifiers = undefined;
         node.asteriskToken = asteriskToken;
-        node.name = coerceIdentifier(name);
+        node.name = typeof name === "string" ? createIdentifier(name) : name;
         node.typeParameters = undefined;
         node.parameters = createNodeArray(parameters);
         node.type = undefined;
@@ -356,9 +359,9 @@ namespace ts {
 
     export function createBinary(left: Expression, operator: SyntaxKind, right: Expression, location?: TextRange) {
         const node = <BinaryExpression>createNode(SyntaxKind.BinaryExpression, location);
-        node.left = parenthesizeForBinary(left, operator, BinaryOperand.Left);
+        node.left = parenthesizeBinaryOperand(operator, left, /*isLeftSideOfBinary*/ true);
         node.operatorToken = createSynthesizedNode(operator);
-        node.right = parenthesizeForBinary(right, operator, BinaryOperand.Right);
+        node.right = parenthesizeBinaryOperand(operator, right, /*isLeftSideOfBinary*/ false);
         return node;
     }
 
@@ -434,7 +437,7 @@ namespace ts {
 
     export function createVariableDeclaration(name: string | BindingPattern | Identifier, initializer?: Expression, location?: TextRange): VariableDeclaration {
         const node = <VariableDeclaration>createNode(SyntaxKind.VariableDeclaration, location);
-        node.name = coerceBindingName(name);
+        node.name = typeof name === "string" ? createIdentifier(name) : name;
         node.initializer = initializer;
         return node;
     }
@@ -456,7 +459,7 @@ namespace ts {
         node.decorators = undefined;
         setModifiers(node, modifiers);
         node.asteriskToken = asteriskToken;
-        node.name = coerceIdentifier(name);
+        node.name = typeof name === "string" ? createIdentifier(name) : name;
         node.typeParameters = undefined;
         node.parameters = createNodeArray(parameters);
         node.type = undefined;
@@ -497,8 +500,8 @@ namespace ts {
 
     export function createExportSpecifier(name: string | Identifier, propertyName?: string | Identifier) {
         const node = <ExportSpecifier>createNode(SyntaxKind.ExportSpecifier);
-        node.name = coerceIdentifier(name);
-        node.propertyName = coerceIdentifier(propertyName);
+        node.name = typeof name === "string" ? createIdentifier(name) : name;
+        node.propertyName = typeof propertyName === "string" ? createIdentifier(propertyName) : propertyName;
         return node;
     }
 
@@ -795,49 +798,16 @@ namespace ts {
 
 
     // Utilities
-
-    function coerceIdentifier(value: string | Identifier) {
-        if (typeof value === "string") {
-            return createIdentifier(value);
-        }
-        else {
-            return value;
-        }
-    }
-
-    function coerceBindingName(value: string | BindingName) {
-        if (typeof value === "string") {
-            return createIdentifier(value);
-        }
-        else {
-            return value;
-        }
-    }
-
-    function coercePropertyName(value: string | PropertyName) {
-        if (typeof value === "string") {
-            return createIdentifier(value);
-        }
-        else {
-            return value;
-        }
-    }
-
-    function coerceExpression(value: string | number | boolean | Expression): Expression {
-        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-            return createLiteral(value);
-        }
-        else {
-            return value;
-        }
-    }
-
-    const enum BinaryOperand {
-        Left,
-        Right
-    }
-
-    function parenthesizeForBinary(operand: Expression, operator: SyntaxKind, side: BinaryOperand) {
+    /**
+     * Wraps the operand to a BinaryExpression in parentheses if they are needed to preserve the intended
+     * order of operations.
+     *
+     * @param binaryOperator The operator for the BinaryExpression.
+     * @param operand The operand for the BinaryExpression.
+     * @param isLeftSideOfBinary A value indicating whether the operand is the left side of the
+     *                           BinaryExpression.
+     */
+    function parenthesizeBinaryOperand(binaryOperator: SyntaxKind, operand: Expression, isLeftSideOfBinary: boolean) {
         // When diagnosing whether the expression needs parentheses, the decision should be based
         // on the innermost expression in a chain of nested type assertions.
         operand = skipAssertions(operand);
@@ -847,7 +817,7 @@ namespace ts {
             return operand;
         }
 
-        return needsParenthesesForBinary(operand, operator, side)
+        return binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary)
             ? createParen(operand)
             : operand;
     }
@@ -985,6 +955,18 @@ namespace ts {
         return createParen(operand);
     }
 
+    /**
+     * Skips past any TypeAssertionExpression or AsExpression nodes to their inner expression.
+     *
+     * @param node The expression node.
+     */
+    function skipAssertions(node: Expression) {
+        while (node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression) {
+            node = (<AssertionExpression>node).expression;
+        }
+
+        return node;
+    }
 
     export function startOnNewLine<T extends Node>(node: T): T {
         (<SynthesizedNode>node).startsOnNewLine = true;
@@ -1012,17 +994,4 @@ namespace ts {
     export function getSynthesizedNode<T extends Node>(node: T): T {
         return nodeIsSynthesized(node) ? node : cloneNode(node, /*location*/ undefined, node.flags, /*parent*/ undefined, /*original*/ node);
     }
-
-    /**
-     * Skips past any TypeAssertionExpression or AsExpression nodes to their inner expression.
-     *
-     * @param node The expression node.
-     */
-    function skipAssertions(node: Expression) {
-        while (node.kind === SyntaxKind.TypeAssertionExpression || node.kind === SyntaxKind.AsExpression) {
-            node = (<AssertionExpression>node).expression;
-        }
-
-        return node;
-    }
 }
diff --git a/src/compiler/printer.ts b/src/compiler/printer.ts
@@ -85,8 +85,8 @@ const _super = (function (geti, seti) {
 })(name => super[name], (name, value) => super[name] = value);`;
 
         const compilerOptions = host.getCompilerOptions();
-        const languageVersion = getLanguageVersion(compilerOptions);
-        const moduleKind = getModuleKind(compilerOptions);
+        const languageVersion = getEmitScriptTarget(compilerOptions);
+        const moduleKind = getEmitModuleKind(compilerOptions);
         const sourceMapDataList: SourceMapData[] = compilerOptions.sourceMap || compilerOptions.inlineSourceMap ? [] : undefined;
         const emitterDiagnostics = createDiagnosticCollection();
 

diff --git a/src/compiler/transformer.ts b/src/compiler/transformer.ts
@@ -19,10 +19,16 @@ namespace ts {
         [ModuleKind.None]: transformModule
     };
 
+    const enum SyntaxKindFeatureFlags {
+        ExpressionSubstitution = 1 << 0,
+        EmitNotifications = 1 << 1,
+    }
+
+
     export function getTransformers(compilerOptions: CompilerOptions) {
         const jsx = compilerOptions.jsx;
-        const languageVersion = getLanguageVersion(compilerOptions);
-        const moduleKind = getModuleKind(compilerOptions);
+        const languageVersion = getEmitScriptTarget(compilerOptions);
+        const moduleKind = getEmitModuleKind(compilerOptions);
         const transformers: Transformer[] = [];
 
         transformers.push(transformTypeScript);
@@ -56,8 +62,7 @@ namespace ts {
         const nodeEmitFlags: NodeEmitFlags[] = [];
         const lexicalEnvironmentVariableDeclarationsStack: VariableDeclaration[][] = [];
         const lexicalEnvironmentFunctionDeclarationsStack: FunctionDeclaration[][] = [];
-        const enabledExpressionSubstitutions = new Array<boolean>(SyntaxKind.Count);
-        const enabledEmitNotifications = new Array<boolean>(SyntaxKind.Count);
+        const enabledSyntaxKindFeatures = new Array<SyntaxKindFeatureFlags>(SyntaxKind.Count);
 
         let lexicalEnvironmentStackOffset = 0;
         let hoistedVariableDeclarations: VariableDeclaration[];
@@ -108,19 +113,19 @@ namespace ts {
         }
 
         function enableExpressionSubstitution(kind: SyntaxKind) {
-            enabledExpressionSubstitutions[kind] = true;
+            enabledSyntaxKindFeatures[kind] |= SyntaxKindFeatureFlags.ExpressionSubstitution;
         }
 
         function isExpressionSubstitutionEnabled(node: Node) {
-            return enabledExpressionSubstitutions[node.kind];
+            return (enabledSyntaxKindFeatures[node.kind] & SyntaxKindFeatureFlags.ExpressionSubstitution) !== 0;
         }
 
         function enableEmitNotification(kind: SyntaxKind) {
-            enabledEmitNotifications[kind] = true;
+            enabledSyntaxKindFeatures[kind] |= SyntaxKindFeatureFlags.EmitNotifications;
         }
 
         function isEmitNotificationEnabled(node: Node) {
-            return enabledEmitNotifications[node.kind]
+            return (enabledSyntaxKindFeatures[node.kind] & SyntaxKindFeatureFlags.EmitNotifications) !== 0
                 || (getNodeEmitFlags(node) & NodeEmitFlags.AdviseOnEmitNode) !== 0;
         }
 

diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
@@ -20,7 +20,7 @@ namespace ts {
 
         const resolver = context.getEmitResolver();
         const compilerOptions = context.getCompilerOptions();
-        const languageVersion = getLanguageVersion(compilerOptions);
+        const languageVersion = getEmitScriptTarget(compilerOptions);
         const decoratedClassAliases: Map<Identifier> = {};
         const currentDecoratedClassAliases: Map<Identifier> = {};
         const previousExpressionSubstitution = context.expressionSubstitution;
@@ -755,8 +755,8 @@ namespace ts {
         function findInitialSuperCall(ctor: ConstructorDeclaration): ExpressionStatement {
             if (ctor.body) {
                 const statements = ctor.body.statements;
-                const statement = statements.length ? statements[0] : undefined;
-                if (statement.kind === SyntaxKind.ExpressionStatement) {
+                const statement = firstOrUndefined(statements);
+                if (statement && statement.kind === SyntaxKind.ExpressionStatement) {
                     const expression = (<ExpressionStatement>statement).expression;
                     if (expression.kind === SyntaxKind.CallExpression) {
                         if ((<CallExpression>expression).expression.kind === SyntaxKind.SuperKeyword) {
@@ -1853,7 +1853,7 @@ namespace ts {
             const visited = visitEachChild(body, visitor, context);
             const declarations = endLexicalEnvironment();
             currentScope = savedCurrentScope;
-            return mergeFunctionBodyLexicalEnvironment(visited, declarations, visited !== body);
+            return mergeFunctionBodyLexicalEnvironment(visited, declarations);
         }
 
         function transformConciseBody(node: ArrowFunction): ConciseBody {
@@ -1872,7 +1872,7 @@ namespace ts {
                 startLexicalEnvironment();
                 const visited: Expression | Block = visitNode(body, visitor, isConciseBody);
                 const declarations = endLexicalEnvironment();
-                const merged = mergeConciseBodyLexicalEnvironment(visited, declarations, visited !== body);
+                const merged = mergeConciseBodyLexicalEnvironment(visited, declarations);
                 if (forceBlockFunctionBody && !isBlock(merged)) {
                     return createBlock([
                         createReturn(<Expression>merged)

diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2797,7 +2797,7 @@ namespace ts {
         EmitSuperHelper = 1 << 2,           // Emit the basic _super helper for async methods.
         EmitAdvancedSuperHelper = 1 << 3,   // Emit the advanced _super helper for async methods.
         UMDDefine = 1 << 4,                 // This node should be replaced with the UMD define helper.
-        NoLexicalEnvironment = 1 << 5,      // A new LexicalEnvironment should *not* be introduced when emitting this node.
+        NoLexicalEnvironment = 1 << 5,      // A new LexicalEnvironment should *not* be introduced when emitting this node, this is primarily used when printing a SystemJS module.
         SingleLine = 1 << 6,                // The contents of this node should be emit on a single line.
         MultiLine = 1 << 7,                 // The contents of this node should be emit on multiple lines.
         AdviseOnEmitNode = 1 << 8,          // The node printer should invoke the onBeforeEmitNode and onAfterEmitNode callbacks when printing this node.
@@ -2824,8 +2824,11 @@ namespace ts {
         getGeneratedNameForNode(node: Node): Identifier;
         nodeHasGeneratedName(node: Node): boolean;
         makeUniqueName(baseName: string): Identifier;
-        enableExpressionSubstitution(kind: SyntaxKind): void;
-        isExpressionSubstitutionEnabled(node: Node): boolean;
+
+        /**
+         * Hook used by transformers to substitute non-expression identifiers
+         * just before theyare emitted by the pretty printer.
+         */
         identifierSubstitution?: (node: Identifier) => Identifier;
 
         /**
@@ -2845,9 +2848,29 @@ namespace ts {
          * are emitted by the pretty printer.
          */
         expressionSubstitution?: (node: Expression) => Expression;
+
+        /**
+         * Enables before/after emit notifications in the pretty printer for
+         * the provided SyntaxKind.
+         */
         enableEmitNotification(kind: SyntaxKind): void;
+
+        /**
+         * Determines whether before/after emit notifications should be raised
+         * in the pretty printer when it emits a node.
+         */
         isEmitNotificationEnabled(node: Node): boolean;
+
+        /**
+         * Hook used to notify transformers immediately before the pretty printer
+         * emits a node.
+         */
         onBeforeEmitNode?: (node: Node) => void;
+
+        /**
+         * Hook used to notify transformers immediately after the pretty printer
+         * emits a node.
+         */
         onAfterEmitNode?: (node: Node) => void;
     }