Adds the visitor API foundation for tree transformations.

Jakefile.js

@@ -40,6 +40,8 @@ var compilerSources = [
     "utilities.ts",
     "binder.ts",
     "checker.ts",
+    "factory.ts",
+    "visitor.ts",
     "sourcemap.ts",
     "declarationEmitter.ts",
     "emitter.ts",
@@ -60,6 +62,8 @@ var servicesSources = [
     "utilities.ts",
     "binder.ts",
     "checker.ts",
+    "factory.ts",
+    "visitor.ts",
     "sourcemap.ts",
     "declarationEmitter.ts",
     "emitter.ts",

src/compiler/core.ts

@@ -91,6 +91,23 @@ namespace ts {
         return undefined;
     }
 
+    /**
+     * Iterates through `array` by index and performs the callback on each element of array until the callback
+     * returns a falsey value, then returns false.
+     * If no such value is found, the callback is applied to each element of array and `true` is returned.
+     */
+    export function trueForAll<T>(array: T[], callback: (element: T, index: number) => boolean): boolean {
+        if (array) {
+            for (let i = 0, len = array.length; i < len; i++) {
+                if (!callback(array[i], i)) {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
     export function contains<T>(array: T[], value: T): boolean {
         if (array) {
             for (const v of array) {
@@ -242,8 +259,14 @@ namespace ts {
             const count = array.length;
             if (count > 0) {
                 let pos = 0;
-                let result = arguments.length <= 2 ? array[pos] : initial;
-                pos++;
+                let result: T | U;
+                if (arguments.length <= 2) {
+                    result = array[pos];
+                    pos++;
+                }
+                else {
+                    result = initial;
+                }
                 while (pos < count) {
                     result = f(<U>result, array[pos]);
                     pos++;
@@ -260,8 +283,14 @@ namespace ts {
         if (array) {
             let pos = array.length - 1;
             if (pos >= 0) {
-                let result = arguments.length <= 2 ? array[pos] : initial;
-                pos--;
+                let result: T | U;
+                if (arguments.length <= 2) {
+                    result = array[pos];
+                    pos--;
+                }
+                else {
+                    result = initial;
+                }
                 while (pos >= 0) {
                     result = f(<U>result, array[pos]);
                     pos--;

src/compiler/factory.ts

@@ -0,0 +1,56 @@
+/// <reference path="types.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;
+        }
+        else if (array.pos === undefined || array.end === undefined) {
+            array.pos = -1;
+            array.end = -1;
+        }
+
+        return array;
+    }
+
+    export function createNodeArrayNode<T extends Node>(elements?: (T | NodeArrayNode<T>)[]): NodeArrayNode<T> {
+        const array = <NodeArrayNode<T>>createNodeArray(elements);
+        array.kind = SyntaxKind.NodeArrayNode;
+        return array;
+    }
+
+    export function createReturn(expression?: Expression): ReturnStatement {
+        const node = <ReturnStatement>createSynthesizedNode(SyntaxKind.ReturnStatement);
+        node.expression = expression;
+        return node;
+    }
+
+    export function createStatement(expression: Expression): ExpressionStatement {
+        const node = <ExpressionStatement>createSynthesizedNode(SyntaxKind.ExpressionStatement);
+        node.expression = expression;
+        return node;
+    }
+
+    export function createVariableStatement(declarationList: VariableDeclarationList): VariableStatement {
+        const node = <VariableStatement>createSynthesizedNode(SyntaxKind.VariableStatement);
+        node.declarationList = declarationList;
+        return node;
+    }
+
+    export function createVariableDeclarationList(declarations: VariableDeclaration[]): VariableDeclarationList {
+        const node = <VariableDeclarationList>createSynthesizedNode(SyntaxKind.VariableDeclarationList);
+        node.declarations = createNodeArray(declarations);
+        return node;
+    }
+
+    export function createBlock(statements: Statement[]): Block {
+        const block = <Block>createSynthesizedNode(SyntaxKind.Block);
+        block.statements = createNodeArray(statements);
+        return block;
+    }
+}

src/compiler/tsconfig.json

@@ -17,6 +17,8 @@
         "utilities.ts",
         "binder.ts",
         "checker.ts",
+        "factory.ts",
+        "visitor.ts",
         "emitter.ts",
         "program.ts",
         "commandLineParser.ts",

src/compiler/types.ts

@@ -341,6 +341,7 @@ namespace ts {
 
         // Synthesized list
         SyntaxList,
+        NodeArrayNode,
         // Enum value count
         Count,
         // Markers
@@ -444,7 +445,8 @@ namespace ts {
         decorators?: NodeArray<Decorator>;              // Array of decorators (in document order)
         modifiers?: ModifiersArray;                     // Array of modifiers
         /* @internal */ id?: number;                    // Unique id (used to look up NodeLinks)
-        parent?: Node;                                  // Parent node (initialized by binding
+        parent?: Node;                                  // Parent node (initialized by binding)
+        /* @internal */ original?: Node;                // The original node if this is an updated node.
         /* @internal */ jsDocComment?: JSDocComment;    // JSDoc for the node, if it has any.  Only for .js files.
         /* @internal */ symbol?: Symbol;                // Symbol declared by node (initialized by binding)
         /* @internal */ locals?: SymbolTable;           // Locals associated with node (initialized by binding)
@@ -456,6 +458,10 @@ namespace ts {
         hasTrailingComma?: boolean;
     }
 
+    // @kind(SyntaxKind.NodeArrayNode)
+    export interface NodeArrayNode<T> extends Node, NodeArray<T | NodeArrayNode<T>> {
+    }
+
     export interface ModifiersArray extends NodeArray<Modifier> {
         flags: number;
     }
@@ -1287,13 +1293,15 @@ namespace ts {
         statements: NodeArray<Statement>;
     }
 
+    export type ModuleReference = EntityName | ExternalModuleReference;
+
     // @kind(SyntaxKind.ImportEqualsDeclaration)
     export interface ImportEqualsDeclaration extends DeclarationStatement {
         name: Identifier;
 
         // 'EntityName' for an internal module reference, 'ExternalModuleReference' for an external
         // module reference.
-        moduleReference: EntityName | ExternalModuleReference;
+        moduleReference: ModuleReference;
     }
 
     // @kind(SyntaxKind.ExternalModuleReference)