Merge pull request #7191 from Microsoft/transforms-transformer-ts

Adds the TypeScript transformer

Author: rbuckton

Jakefile.js

@@ -42,6 +42,14 @@ var compilerSources = [
     "checker.ts",
     "factory.ts",
     "visitor.ts",
+    "transformers/destructuring.ts",
+    "transformers/ts.ts",
+    "transformers/module/es6.ts",
+    "transformers/module/system.ts",
+    "transformers/module/module.ts",
+    "transformers/jsx.ts",
+    "transformers/es7.ts",
+    "transformers/es6.ts",
     "transformer.ts",
     "sourcemap.ts",
     "comments.ts",
@@ -67,6 +75,14 @@ var servicesSources = [
     "checker.ts",
     "factory.ts",
     "visitor.ts",
+    "transformers/destructuring.ts",
+    "transformers/ts.ts",
+    "transformers/module/es6.ts",
+    "transformers/module/system.ts",
+    "transformers/module/module.ts",
+    "transformers/jsx.ts",
+    "transformers/es7.ts",
+    "transformers/es6.ts",
     "transformer.ts",
     "sourcemap.ts",
     "comments.ts",

src/compiler/binder.ts

@@ -171,23 +171,116 @@ namespace ts {
         return result;
     }
 
+    /**
+     * Flattens an array containing a mix of array or non-array elements.
+     *
+     * @param array The array to flatten.
+     */
+    export function flatten<T>(array: (T | T[])[]): T[] {
+        let result: T[];
+        if (array) {
+            result = [];
+            for (const v of array) {
+                if (v) {
+                    if (isArray(v)) {
+                        addRange(result, v);
+                    }
+                    else {
+                        result.push(v);
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
     /**
      * Maps an array. If the mapped value is an array, it is spread into the result.
+     *
+     * @param array The array to map.
+     * @param mapfn The callback used to map the result into one or more values.
      */
-    export function flatMap<T, U>(array: T[], f: (x: T, i: number) => U | U[]): U[] {
+    export function flatMap<T, U>(array: T[], mapfn: (x: T, i: number) => U | U[]): U[] {
         let result: U[];
         if (array) {
             result = [];
             for (let i = 0; i < array.length; i++) {
-                const v = array[i];
-                const ar = f(v, i);
-                if (ar) {
-                    // We cast to <U> here to leverage the behavior of Array#concat
-                    // which will append a single value here.
-                    result = result.concat(<U[]>ar);
+                const v = mapfn(array[i], i);
+                if (v) {
+                    if (isArray(v)) {
+                        addRange(result, v);
+                    }
+                    else {
+                        result.push(v);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Computes the first matching span of elements and returns a tuple of the first span
+     * and the remaining elements.
+     */
+    export function span<T>(array: T[], f: (x: T, i: number) => boolean): [T[], T[]] {
+        if (array) {
+            for (let i = 0; i < array.length; i++) {
+                if (!f(array[i], i)) {
+                    return [array.slice(0, i), array.slice(i)];
+                }
+            }
+            return [array.slice(0), []];
+        }
+
+        return undefined;
+    }
+
+    /**
+     * Maps contiguous spans of values with the same key.
+     *
+     * @param array The array to map.
+     * @param keyfn A callback used to select the key for an element.
+     * @param mapfn A callback used to map a contiguous chunk of values to a single value.
+     */
+    export function spanMap<T, K, U>(array: T[], keyfn: (x: T, i: number) => K, mapfn: (chunk: T[], key: K) => U): U[] {
+        let result: U[];
+        if (array) {
+            result = [];
+            const len = array.length;
+            let previousKey: K;
+            let key: K;
+            let start = 0;
+            let pos = 0;
+            while (start < len) {
+                while (pos < len) {
+                    const value = array[pos];
+                    key = keyfn(value, pos);
+                    if (pos === 0) {
+                        previousKey = key;
+                    }
+                    else if (key !== previousKey) {
+                        break;
+                    }
+
+                    pos++;
                 }
+
+                if (start < pos) {
+                    const v = mapfn(array.slice(start, pos), previousKey);
+                    if (v) {
+                        result.push(v);
+                    }
+
+                    start = pos;
+                }
+
+                previousKey = key;
+                pos++;
             }
         }
+
         return result;
     }
 
@@ -920,8 +1013,9 @@ namespace ts {
         this.pos = pos;
         this.end = end;
         this.flags = NodeFlags.None;
-        this.transformFlags = undefined;
-        this.excludeTransformFlags = undefined;
+        this.modifierFlagsCache = ModifierFlags.None;
+        this.transformFlags = TransformFlags.None;
+        this.excludeTransformFlags = TransformFlags.None;
         this.parent = undefined;
         this.original = undefined;
     }
@@ -942,7 +1036,12 @@ namespace ts {
     }
 
     export namespace Debug {
-        const currentAssertionLevel = AssertionLevel.None;
+        declare var process: any;
+        declare var require: any;
+
+        const currentAssertionLevel = getDevelopmentMode() === "development"
+            ? AssertionLevel.Normal
+            : AssertionLevel.None;
 
         export function shouldAssert(level: AssertionLevel): boolean {
             return currentAssertionLevel >= level;
@@ -962,6 +1061,17 @@ namespace ts {
         export function fail(message?: string): void {
             Debug.assert(/*expression*/ false, message);
         }
+
+        function getDevelopmentMode() {
+            return typeof require !== "undefined"
+                && typeof process !== "undefined"
+                && !process.browser
+                && process.nextTick
+                && process.env
+                && process.env.NODE_ENV
+                    ? String(process.env.NODE_ENV).toLowerCase()
+                    : undefined;
+        }
     }
 
     export function copyListRemovingItem<T>(item: T, list: T[]) {