Merge branch 'master' into ownJsonParsing

Author: sheetalkamat

.travis.yml

@@ -21,8 +21,8 @@ branches:
   - release-2.3
 
 install:
-  - npm uninstall typescript
-  - npm uninstall tslint
+  - npm uninstall typescript --no-save
+  - npm uninstall tslint --no-save
   - npm install
 
 cache:

jenkins.sh

@@ -2,12 +2,12 @@
 
 # Set up NVM
 export NVM_DIR="/home/dotnet-bot/.nvm"
-[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh" 
+[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"
 
 nvm install $1
 
-npm uninstall typescript
-npm uninstall tslint
+npm uninstall typescript --no-save
+npm uninstall tslint --no-save
 npm install
 npm update
 npm test

src/compiler/checker.ts

@@ -752,18 +752,34 @@ namespace ts {
         return to;
     }
 
+    /**
+     * Gets the actual offset into an array for a relative offset. Negative offsets indicate a
+     * position offset from the end of the array.
+     */
+    function toOffset(array: any[], offset: number) {
+        return offset < 0 ? array.length + offset : offset;
+    }
+
     /**
      * Appends a range of value to an array, returning the array.
      *
      * @param to The array to which `value` is to be appended. If `to` is `undefined`, a new array
      * is created if `value` was appended.
      * @param from The values to append to the array. If `from` is `undefined`, nothing is
      * appended. If an element of `from` is `undefined`, that element is not appended.
+     * @param start The offset in `from` at which to start copying values.
+     * @param end The offset in `from` at which to stop copying values (non-inclusive).
      */
-    export function addRange<T>(to: T[] | undefined, from: T[] | undefined): T[] | undefined {
+    export function addRange<T>(to: T[] | undefined, from: T[] | undefined, start?: number, end?: number): T[] | undefined {
         if (from === undefined) return to;
-        for (const v of from) {
-            to = append(to, v);
+        if (to === undefined) return from.slice(start, end);
+        start = start === undefined ? 0 : toOffset(from, start);
+        end = end === undefined ? from.length : toOffset(from, end);
+        for (let i = start; i < end && i < from.length; i++) {
+            const v = from[i];
+            if (v !== undefined) {
+                to.push(from[i]);
+            }
         }
         return to;
     }
@@ -788,28 +804,38 @@ namespace ts {
         return true;
     }
 
+    /**
+     * Returns the element at a specific offset in an array if non-empty, `undefined` otherwise.
+     * A negative offset indicates the element should be retrieved from the end of the array.
+     */
+    export function elementAt<T>(array: T[] | undefined, offset: number): T | undefined {
+        if (array) {
+            offset = toOffset(array, offset);
+            if (offset < array.length) {
+                return array[offset];
+            }
+        }
+        return undefined;
+    }
+
     /**
      * Returns the first element of an array if non-empty, `undefined` otherwise.
      */
-    export function firstOrUndefined<T>(array: T[]): T {
-        return array && array.length > 0
-            ? array[0]
-            : undefined;
+    export function firstOrUndefined<T>(array: T[]): T | undefined {
+        return elementAt(array, 0);
     }
 
     /**
      * Returns the last element of an array if non-empty, `undefined` otherwise.
      */
-    export function lastOrUndefined<T>(array: T[]): T {
-        return array && array.length > 0
-            ? array[array.length - 1]
-            : undefined;
+    export function lastOrUndefined<T>(array: T[]): T | undefined {
+        return elementAt(array, -1);
     }
 
     /**
      * Returns the only element of an array if it contains only one element, `undefined` otherwise.
      */
-    export function singleOrUndefined<T>(array: T[]): T {
+    export function singleOrUndefined<T>(array: T[]): T | undefined {
         return array && array.length === 1
             ? array[0]
             : undefined;
@@ -1137,6 +1163,15 @@ namespace ts {
         return Array.isArray ? Array.isArray(value) : value instanceof Array;
     }
 
+    export function tryCast<TOut extends TIn, TIn = any>(value: TIn | undefined, test: (value: TIn) => value is TOut): TOut | undefined {
+        return value !== undefined && test(value) ? value : undefined;
+    }
+
+    export function cast<TOut extends TIn, TIn = any>(value: TIn | undefined, test: (value: TIn) => value is TOut): TOut {
+        if (value !== undefined && test(value)) return value;
+        Debug.fail(`Invalid cast. The supplied value did not pass the test '${Debug.getFunctionName(test)}'.`);
+    }
+
     /** Does nothing. */
     export function noop(): void {}
 
@@ -2224,8 +2259,11 @@ namespace ts {
         this.declarations = undefined;
     }
 
-    function Type(this: Type, _checker: TypeChecker, flags: TypeFlags) {
+    function Type(this: Type, checker: TypeChecker, flags: TypeFlags) {
         this.flags = flags;
+        if (Debug.isDebugging) {
+            this.checker = checker;
+        }
     }
 
     function Signature() {
@@ -2262,24 +2300,42 @@ namespace ts {
 
     export namespace Debug {
         export let currentAssertionLevel = AssertionLevel.None;
+        export let isDebugging = false;
 
         export function shouldAssert(level: AssertionLevel): boolean {
             return currentAssertionLevel >= level;
         }
 
-        export function assert(expression: boolean, message?: string, verboseDebugInfo?: () => string): void {
+        export function assert(expression: boolean, message?: string, verboseDebugInfo?: () => string, stackCrawlMark?: Function): void {
             if (!expression) {
-                let verboseDebugString = "";
                 if (verboseDebugInfo) {
-                    verboseDebugString = "\r\nVerbose Debug Information: " + verboseDebugInfo();
+                    message += "\r\nVerbose Debug Information: " + verboseDebugInfo();
                 }
-                debugger;
-                throw new Error("Debug Failure. False expression: " + (message || "") + verboseDebugString);
+                fail(message ? "False expression: " + message : "False expression.", stackCrawlMark || assert);
+            }
+        }
+
+        export function fail(message?: string, stackCrawlMark?: Function): void {
+            debugger;
+            const e = new Error(message ? `Debug Failure. ` : "Debug Failure.");
+            if ((<any>Error).captureStackTrace) {
+                (<any>Error).captureStackTrace(e, stackCrawlMark || fail);
             }
+            throw e;
         }
 
-        export function fail(message?: string): void {
-            Debug.assert(/*expression*/ false, message);
+        export function getFunctionName(func: Function) {
+            if (typeof func !== "function") {
+                return "";
+            }
+            else if (func.hasOwnProperty("name")) {
+                return (<any>func).name;
+            }
+            else {
+                const text = Function.prototype.toString.call(func);
+                const match = /^function\s+([\w\$]+)\s*\(/.exec(text);
+                return match ? match[1] : "";
+            }
         }
     }
 
@@ -2445,4 +2501,4 @@ namespace ts {
     export function isCheckJsEnabledForFile(sourceFile: SourceFile, compilerOptions: CompilerOptions) {
         return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
     }
-}
+}

src/compiler/core.ts

@@ -2134,6 +2134,24 @@ namespace ts {
 
     // Compound nodes
 
+    export function createImmediatelyInvokedFunctionExpression(statements: Statement[]): CallExpression;
+    export function createImmediatelyInvokedFunctionExpression(statements: Statement[], param: ParameterDeclaration, paramValue: Expression): CallExpression;
+    export function createImmediatelyInvokedFunctionExpression(statements: Statement[], param?: ParameterDeclaration, paramValue?: Expression) {
+        return createCall(
+            createFunctionExpression(
+                /*modifiers*/ undefined,
+                /*asteriskToken*/ undefined,
+                /*name*/ undefined,
+                /*typeParameters*/ undefined,
+                /*parameters*/ param ? [param] : [],
+                /*type*/ undefined,
+                createBlock(statements, /*multiLine*/ true)
+            ),
+            /*typeArguments*/ undefined,
+            /*argumentsArray*/ paramValue ? [paramValue] : []
+        );
+    }
+
     export function createComma(left: Expression, right: Expression) {
         return <Expression>createBinary(left, SyntaxKind.CommaToken, right);
     }
@@ -3208,6 +3226,26 @@ namespace ts {
         return isBlock(node) ? node : setTextRange(createBlock([setTextRange(createReturn(node), node)], multiLine), node);
     }
 
+    export function convertFunctionDeclarationToExpression(node: FunctionDeclaration) {
+        Debug.assert(!!node.body);
+        const updated = createFunctionExpression(
+            node.modifiers,
+            node.asteriskToken,
+            node.name,
+            node.typeParameters,
+            node.parameters,
+            node.type,
+            node.body
+        );
+        setOriginalNode(updated, node);
+        setTextRange(updated, node);
+        if (node.startsOnNewLine) {
+            updated.startsOnNewLine = true;
+        }
+        aggregateTransformFlags(updated);
+        return updated;
+    }
+
     function isUseStrictPrologue(node: ExpressionStatement): boolean {
         return (node.expression as StringLiteral).text === "use strict";
     }
@@ -3606,7 +3644,7 @@ namespace ts {
             if (kind === SyntaxKind.FunctionExpression || kind === SyntaxKind.ArrowFunction) {
                 const mutableCall = getMutableClone(emittedExpression);
                 mutableCall.expression = setTextRange(createParen(callee), callee);
-                return recreatePartiallyEmittedExpressions(expression, mutableCall);
+                return recreateOuterExpressions(expression, mutableCall, OuterExpressionKinds.PartiallyEmittedExpressions);
             }
         }
         else {
@@ -3648,22 +3686,6 @@ namespace ts {
         }
     }
 
-    /**
-     * Clones a series of not-emitted expressions with a new inner expression.
-     *
-     * @param originalOuterExpression The original outer expression.
-     * @param newInnerExpression The new inner expression.
-     */
-    function recreatePartiallyEmittedExpressions(originalOuterExpression: Expression, newInnerExpression: Expression) {
-        if (isPartiallyEmittedExpression(originalOuterExpression)) {
-            const clone = getMutableClone(originalOuterExpression);
-            clone.expression = recreatePartiallyEmittedExpressions(clone.expression, newInnerExpression);
-            return clone;
-        }
-
-        return newInnerExpression;
-    }
-
     function getLeftmostExpression(node: Expression): Expression {
         while (true) {
             switch (node.kind) {
@@ -3710,6 +3732,22 @@ namespace ts {
         All = Parentheses | Assertions | PartiallyEmittedExpressions
     }
 
+    export type OuterExpression = ParenthesizedExpression | TypeAssertion | AsExpression | NonNullExpression | PartiallyEmittedExpression;
+
+    export function isOuterExpression(node: Node, kinds = OuterExpressionKinds.All): node is OuterExpression {
+        switch (node.kind) {
+            case SyntaxKind.ParenthesizedExpression:
+                return (kinds & OuterExpressionKinds.Parentheses) !== 0;
+            case SyntaxKind.TypeAssertionExpression:
+            case SyntaxKind.AsExpression:
+            case SyntaxKind.NonNullExpression:
+                return (kinds & OuterExpressionKinds.Assertions) !== 0;
+            case SyntaxKind.PartiallyEmittedExpression:
+                return (kinds & OuterExpressionKinds.PartiallyEmittedExpressions) !== 0;
+        }
+        return false;
+    }
+
     export function skipOuterExpressions(node: Expression, kinds?: OuterExpressionKinds): Expression;
     export function skipOuterExpressions(node: Node, kinds?: OuterExpressionKinds): Node;
     export function skipOuterExpressions(node: Node, kinds = OuterExpressionKinds.All) {
@@ -3746,13 +3784,33 @@ namespace ts {
     export function skipAssertions(node: Expression): Expression;
     export function skipAssertions(node: Node): Node;
     export function skipAssertions(node: Node): Node {
-        while (isAssertionExpression(node)) {
-            node = (<AssertionExpression>node).expression;
+        while (isAssertionExpression(node) || node.kind === SyntaxKind.NonNullExpression) {
+            node = (<AssertionExpression | NonNullExpression>node).expression;
         }
 
         return node;
     }
 
+    function updateOuterExpression(outerExpression: OuterExpression, expression: Expression) {
+        switch (outerExpression.kind) {
+            case SyntaxKind.ParenthesizedExpression: return updateParen(outerExpression, expression);
+            case SyntaxKind.TypeAssertionExpression: return updateTypeAssertion(outerExpression, outerExpression.type, expression);
+            case SyntaxKind.AsExpression: return updateAsExpression(outerExpression, expression, outerExpression.type);
+            case SyntaxKind.NonNullExpression: return updateNonNullExpression(outerExpression, expression);
+            case SyntaxKind.PartiallyEmittedExpression: return updatePartiallyEmittedExpression(outerExpression, expression);
+        }
+    }
+
+    export function recreateOuterExpressions(outerExpression: Expression | undefined, innerExpression: Expression, kinds = OuterExpressionKinds.All): Expression {
+        if (outerExpression && isOuterExpression(outerExpression, kinds)) {
+            return updateOuterExpression(
+                outerExpression,
+                recreateOuterExpressions(outerExpression.expression, innerExpression)
+            );
+        }
+        return innerExpression;
+    }
+
     export function startOnNewLine<T extends Node>(node: T): T {
         node.startsOnNewLine = true;
         return node;
@@ -3890,7 +3948,7 @@ namespace ts {
             return bindingElement.right;
         }
 
-        if (isSpreadExpression(bindingElement)) {
+        if (isSpreadElement(bindingElement)) {
             // Recovery consistent with existing emit.
             return getInitializerOfBindingOrAssignmentElement(<BindingOrAssignmentElement>bindingElement.expression);
         }
@@ -3958,7 +4016,7 @@ namespace ts {
             return getTargetOfBindingOrAssignmentElement(<BindingOrAssignmentElement>bindingElement.left);
         }
 
-        if (isSpreadExpression(bindingElement)) {
+        if (isSpreadElement(bindingElement)) {
             // `a` in `[...a] = ...`
             return getTargetOfBindingOrAssignmentElement(<BindingOrAssignmentElement>bindingElement.expression);
         }