microsoft · rbuckton · Mar 18, 2016 · Feb 4, 2016 · Feb 4, 2016 · Feb 4, 2016
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -1734,7 +1734,9 @@ namespace ts {
                 case Reachability.Unreachable:
                     const reportError =
                         // report error on all statements except empty ones
-                        (isStatement(node) && node.kind !== SyntaxKind.EmptyStatement) ||
+                        (isStatementButNotDeclaration(node) && node.kind !== SyntaxKind.EmptyStatement) ||
+                        // report error on ExportAssignment
+                        node.kind === SyntaxKind.ExportAssignment ||
                         // report error on class declarations
                         node.kind === SyntaxKind.ClassDeclaration ||
                         // report error on instantiated modules or const-enums only modules if preserveConstEnums is set

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -4934,7 +4934,7 @@ namespace ts {
                 case SyntaxKind.JSDocRecordType:
                     return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node);
                 // This function assumes that an identifier or qualified name is a type expression
-                // Callers should first ensure this by calling isTypeNode
+                // Callers should first ensure this by calling isPartOfTypeNode
                 case SyntaxKind.Identifier:
                 case SyntaxKind.QualifiedName:
                     const symbol = getSymbolAtLocation(node);
@@ -15385,7 +15385,7 @@ namespace ts {
                 (entityName.parent.kind === SyntaxKind.JsxClosingElement)) {
                 return getJsxElementTagSymbol(<JsxOpeningLikeElement>entityName.parent);
             }
-            else if (isExpression(entityName)) {
+            else if (isPartOfExpression(entityName)) {
                 if (nodeIsMissing(entityName)) {
                     // Missing entity name.
                     return undefined;
@@ -15468,7 +15468,7 @@ namespace ts {
 
                 case SyntaxKind.ThisKeyword:
                 case SyntaxKind.SuperKeyword:
-                    const type = isExpression(node) ? checkExpression(<Expression>node) : getTypeFromTypeNode(<TypeNode>node);
+                    const type = isPartOfExpression(node) ? checkExpression(<Expression>node) : getTypeFromTypeNode(<TypeNode>node);
                     return type.symbol;
 
                 case SyntaxKind.ThisType:
@@ -15529,11 +15529,11 @@ namespace ts {
                 return unknownType;
             }
 
-            if (isTypeNode(node)) {
+            if (isPartOfTypeNode(node)) {
                 return getTypeFromTypeNode(<TypeNode>node);
             }
 
-            if (isExpression(node)) {
+            if (isPartOfExpression(node)) {
                 return getTypeOfExpression(<Expression>node);
             }
 

diff --git a/src/compiler/core.ts b/src/compiler/core.ts
@@ -868,6 +868,7 @@ namespace ts {
         this.transformFlags = undefined;
         this.excludeTransformFlags = undefined;
         this.parent = undefined;
+        this.original = undefined;
     }
 
     export let objectAllocator: ObjectAllocator = {

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -1020,7 +1020,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
                     return;
                 }
 
-                const emitOuterParens = isExpression(node.parent)
+                const emitOuterParens = isPartOfExpression(node.parent)
                     && templateNeedsParens(node, <Expression>node.parent);
 
                 if (emitOuterParens) {
@@ -5788,7 +5788,7 @@ const _super = (function (geti, seti) {
             /** Serializes a TypeReferenceNode to an appropriate JS constructor value. Used by the __metadata decorator. */
             function emitSerializedTypeReferenceNode(node: TypeReferenceNode) {
                 let location: Node = node.parent;
-                while (isDeclaration(location) || isTypeNode(location)) {
+                while (isDeclaration(location) || isPartOfTypeNode(location)) {
                     location = location.parent;
                 }
 
@@ -7156,7 +7156,7 @@ const _super = (function (geti, seti) {
                     }
 
                     // text should be quoted string
-                    // for deduplication purposes in key remove leading and trailing quotes so 'a' and "a" will be considered the same                     
+                    // for deduplication purposes in key remove leading and trailing quotes so 'a' and "a" will be considered the same
                     const key = text.substr(1, text.length - 2);
 
                     if (hasProperty(groupIndices, key)) {

diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
@@ -1,56 +1,138 @@
-/// <reference path="types.ts"/>
+/// <reference path="core.ts"/>
 /// <reference path="utilities.ts"/>
-/* @internal */
+
 namespace ts {
-    export function createNodeArray<T extends Node>(elements?: T[], location?: TextRange): NodeArray<T>;
-    export function createNodeArray<T extends Node, TArray extends NodeArray<T>>(elements: TArray, location?: TextRange): TArray;
-    export function createNodeArray<T extends Node, TArray extends NodeArray<T>>(elements?: T[], location?: TextRange): TArray {
-        const array = <TArray>(elements || []);
-        if (location) {
-            array.pos = location.pos;
-            array.end = location.end;
+    let NodeConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;
+    let SourceFileConstructor: new (kind: SyntaxKind, pos: number, end: number) => Node;
+
+    export function createNode(kind: SyntaxKind, pos?: number, end?: number): Node {
+        if (kind === SyntaxKind.SourceFile) {
+            return new (SourceFileConstructor || (SourceFileConstructor = objectAllocator.getSourceFileConstructor()))(kind, pos, end);
         }
-        else if (array.pos === undefined || array.end === undefined) {
-            array.pos = -1;
-            array.end = -1;
+        else {
+            return new (NodeConstructor || (NodeConstructor = objectAllocator.getNodeConstructor()))(kind, pos, end);
         }
+    }
 
+    /* @internal */
+    export function createNodeArray<T extends Node>(elements?: T[], pos?: number, end?: number): NodeArray<T> {
+        const array = <NodeArray<T>>(elements || []);
+        array.pos = pos;
+        array.end = end;
+        array.arrayKind = ArrayKind.NodeArray;
         return array;
     }
 
-    export function createNodeArrayNode<T extends Node>(elements?: (T | NodeArrayNode<T>)[]): NodeArrayNode<T> {
-        const array = <NodeArrayNode<T>>createNodeArray(elements);
-        array.kind = SyntaxKind.NodeArrayNode;
+    /* @internal */
+    export function createModifiersArray(elements?: Modifier[], pos?: number, end?: number): ModifiersArray {
+        const array = <ModifiersArray>(elements || []);
+        array.pos = pos;
+        array.end = end;
+        array.arrayKind = ArrayKind.ModifiersArray;
+        array.flags = 0;
         return array;
     }
 
+    /* @internal */
+    export function createSynthesizedNode(kind: SyntaxKind, startsOnNewLine?: boolean): Node {
+        const node = <SynthesizedNode>createNode(kind, /*pos*/ -1, /*end*/ -1);
+        node.startsOnNewLine = startsOnNewLine;
+        return node;
+    }
+
+    /* @internal */
+    export function createSynthesizedNodeArray<T extends Node>(elements?: T[]): NodeArray<T> {
+        return createNodeArray(elements, /*pos*/ -1, /*end*/ -1);
+    }
+
+    /* @internal */
+    export function createSynthesizedModifiersArray(elements?: Modifier[]): ModifiersArray {
+        return createModifiersArray(elements, /*pos*/ -1, /*end*/ -1);
+    }
+
+    /**
+     * Creates a shallow, memberwise clone of a node. The "kind", "pos", "end", "flags", and "parent"
+     * properties are excluded by default, and can be provided via the "location", "flags", and
+     * "parent" parameters.
+     *
+     * @param node The node to clone.
+     * @param location An optional TextRange to use to supply the new position.
+     * @param flags The NodeFlags to use for the cloned node.
+     * @param parent The parent for the new node.
+     * @param original An optional pointer to the original source tree node.
+     */
+    /* @internal */
+    export function cloneNode<T extends Node>(node: T, location?: TextRange, flags?: NodeFlags, parent?: Node, original?: Node): T {
+        // We don't use "clone" from core.ts here, as we need to preserve the prototype chain of
+        // the original node. We also need to exclude specific properties and only include own-
+        // properties (to skip members already defined on the shared prototype).
+        const clone = location !== undefined
+            ? <T>createNode(node.kind, location.pos, location.end)
+            : <T>createSynthesizedNode(node.kind);
+
+        for (const key in node) {
+            if (clone.hasOwnProperty(key) || !node.hasOwnProperty(key)) {
+                continue;
+            }
+
+            (<any>clone)[key] = (<any>node)[key];
+        }
+
+        if (flags !== undefined) {
+            clone.flags = flags;
+        }
+
+        if (parent !== undefined) {
+            clone.parent = parent;
+        }
+
+        if (original !== undefined) {
+            clone.original = original;
+        }
+
+        return clone;
+    }
+
+    /* @internal */
+    export function createNodeArrayNode<T extends Node>(elements: T[]): NodeArrayNode<T> {
+        const node = <NodeArrayNode<T>>createSynthesizedNode(SyntaxKind.NodeArrayNode);
+        node.nodes = createNodeArray(elements);
+        return node;
+    }
+
+    /* @internal */
     export function createReturn(expression?: Expression): ReturnStatement {
         const node = <ReturnStatement>createSynthesizedNode(SyntaxKind.ReturnStatement);
         node.expression = expression;
         return node;
     }
 
+    /* @internal */
     export function createStatement(expression: Expression): ExpressionStatement {
         const node = <ExpressionStatement>createSynthesizedNode(SyntaxKind.ExpressionStatement);
         node.expression = expression;
         return node;
     }
 
+    /* @internal */
     export function createVariableStatement(declarationList: VariableDeclarationList): VariableStatement {
         const node = <VariableStatement>createSynthesizedNode(SyntaxKind.VariableStatement);
         node.declarationList = declarationList;
         return node;
     }
 
+    /* @internal */
     export function createVariableDeclarationList(declarations: VariableDeclaration[]): VariableDeclarationList {
         const node = <VariableDeclarationList>createSynthesizedNode(SyntaxKind.VariableDeclarationList);
         node.declarations = createNodeArray(declarations);
         return node;
     }
 
+    /* @internal */
     export function createBlock(statements: Statement[]): Block {
         const block = <Block>createSynthesizedNode(SyntaxKind.Block);
         block.statements = createNodeArray(statements);
         return block;
     }
+
 }