Merge branch 'master' into master-dynamicImport

Author: Yui T

.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:

Jakefile.js

@@ -129,6 +129,7 @@ var harnessSources = harnessCoreSources.concat([
     "initializeTSConfig.ts",
     "printer.ts",
     "textChanges.ts",
+    "telemetry.ts",
     "transform.ts",
     "customTransforms.ts",
 ].map(function (f) {
@@ -1079,7 +1080,7 @@ var loggedIOJsPath = builtLocalDirectory + 'loggedIO.js';
 file(loggedIOJsPath, [builtLocalDirectory, loggedIOpath], function () {
     var temp = builtLocalDirectory + 'temp';
     jake.mkdirP(temp);
-    var options = "--types --outdir " + temp + ' ' + loggedIOpath;
+    var options = "--target es5 --lib es6 --types --outdir " + temp + ' ' + loggedIOpath;
     var cmd = host + " " + LKGDirectory + compilerFilename + " " + options + " ";
     console.log(cmd + "\n");
     var ex = jake.createExec([cmd]);
@@ -1093,7 +1094,7 @@ file(loggedIOJsPath, [builtLocalDirectory, loggedIOpath], function () {
 
 var instrumenterPath = harnessDirectory + 'instrumenter.ts';
 var instrumenterJsPath = builtLocalDirectory + 'instrumenter.js';
-compileFile(instrumenterJsPath, [instrumenterPath], [tscFile, instrumenterPath].concat(libraryTargets), [], /*useBuiltCompiler*/ true);
+compileFile(instrumenterJsPath, [instrumenterPath], [tscFile, instrumenterPath].concat(libraryTargets), [], /*useBuiltCompiler*/ true, { lib: "es6", types: ["node"] });
 
 desc("Builds an instrumented tsc.js");
 task('tsc-instrumented', [loggedIOJsPath, instrumenterJsPath, tscFile], function () {

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

package.json

@@ -59,7 +59,7 @@
         "gulp-insert": "latest",
         "gulp-newer": "latest",
         "gulp-sourcemaps": "latest",
-        "gulp-typescript": "3.1.5",
+        "gulp-typescript": "latest",
         "into-stream": "latest",
         "istanbul": "latest",
         "jake": "latest",
@@ -74,7 +74,7 @@
         "through2": "latest",
         "travis-fold": "latest",
         "ts-node": "latest",
-        "tslint": "next",
+        "tslint": "latest",
         "typescript": "next"
     },
     "scripts": {

src/compiler/binder.ts

@@ -2178,7 +2178,10 @@ namespace ts {
                 case SyntaxKind.JSDocRecordMember:
                     return bindPropertyWorker(node as JSDocRecordMember);
                 case SyntaxKind.JSDocPropertyTag:
-                    return declareSymbolAndAddToSymbolTable(node as JSDocPropertyTag, SymbolFlags.Property, SymbolFlags.PropertyExcludes);
+                    return declareSymbolAndAddToSymbolTable(node as JSDocPropertyTag,
+                        (node as JSDocPropertyTag).isBracketed || ((node as JSDocPropertyTag).typeExpression && (node as JSDocPropertyTag).typeExpression.type.kind === SyntaxKind.JSDocOptionalType) ?
+                            SymbolFlags.Property | SymbolFlags.Optional : SymbolFlags.Property,
+                        SymbolFlags.PropertyExcludes);
                 case SyntaxKind.JSDocFunctionType:
                     return bindFunctionOrConstructorType(<SignatureDeclaration>node);
                 case SyntaxKind.JSDocTypeLiteral:
@@ -3597,4 +3600,4 @@ namespace ts {
                 return TransformFlags.NodeExcludes;
         }
     }
-}
+}

src/compiler/checker.ts

@@ -693,8 +693,7 @@ namespace ts {
         return typeAcquisition;
     }
 
-    /* @internal */
-    export function getOptionNameMap(): OptionNameMap {
+    function getOptionNameMap(): OptionNameMap {
         if (optionNameMapCache) {
             return optionNameMapCache;
         }
@@ -747,7 +746,6 @@ namespace ts {
         const options: CompilerOptions = {};
         const fileNames: string[] = [];
         const errors: Diagnostic[] = [];
-        const { optionNameMap, shortOptionNames } = getOptionNameMap();
 
         parseStrings(commandLine);
         return {
@@ -759,21 +757,13 @@ namespace ts {
         function parseStrings(args: string[]) {
             let i = 0;
             while (i < args.length) {
-                let s = args[i];
+                const s = args[i];
                 i++;
                 if (s.charCodeAt(0) === CharacterCodes.at) {
                     parseResponseFile(s.slice(1));
                 }
                 else if (s.charCodeAt(0) === CharacterCodes.minus) {
-                    s = s.slice(s.charCodeAt(1) === CharacterCodes.minus ? 2 : 1).toLowerCase();
-
-                    // Try to translate short option names to their full equivalents.
-                    const short = shortOptionNames.get(s);
-                    if (short !== undefined) {
-                        s = short;
-                    }
-
-                    const opt = optionNameMap.get(s);
+                    const opt = getOptionFromName(s.slice(s.charCodeAt(1) === CharacterCodes.minus ? 2 : 1), /*allowShort*/ true);
                     if (opt) {
                         if (opt.isTSConfigOnly) {
                             errors.push(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file, opt.name));
@@ -861,6 +851,19 @@ namespace ts {
         }
     }
 
+    function getOptionFromName(optionName: string, allowShort = false): CommandLineOption | undefined {
+        optionName = optionName.toLowerCase();
+        const { optionNameMap, shortOptionNames } = getOptionNameMap();
+        // Try to translate short option names to their full equivalents.
+        if (allowShort) {
+            const short = shortOptionNames.get(optionName);
+            if (short !== undefined) {
+                optionName = short;
+            }
+        }
+        return optionNameMap.get(optionName);
+    }
+
     /**
      * Read tsconfig.json file
      * @param fileName The path to the config file
@@ -1040,7 +1043,7 @@ namespace ts {
             for (let i = 0; i < nameColumn.length; i++) {
                 const optionName = nameColumn[i];
                 const description = descriptionColumn[i];
-                result.push(tab + tab + optionName + makePadding(marginLength - optionName.length + 2) + description);
+                result.push(optionName && `${tab}${tab}${optionName}${ description && (makePadding(marginLength - optionName.length + 2) + description)}`);
             }
             if (configurations.files && configurations.files.length) {
                 result.push(`${tab}},`);
@@ -1706,4 +1709,42 @@ namespace ts {
     function caseInsensitiveKeyMapper(key: string) {
         return key.toLowerCase();
     }
+
+    /**
+     * Produces a cleaned version of compiler options with personally identifiying info (aka, paths) removed.
+     * Also converts enum values back to strings.
+     */
+    /* @internal */
+    export function convertCompilerOptionsForTelemetry(opts: ts.CompilerOptions): ts.CompilerOptions {
+        const out: ts.CompilerOptions = {};
+        for (const key in opts) if (opts.hasOwnProperty(key)) {
+            const type = getOptionFromName(key);
+            if (type !== undefined) { // Ignore unknown options
+                out[key] = getOptionValueWithEmptyStrings(opts[key], type);
+            }
+        }
+        return out;
+    }
+
+    function getOptionValueWithEmptyStrings(value: any, option: CommandLineOption): {} {
+        switch (option.type) {
+            case "object": // "paths". Can't get any useful information from the value since we blank out strings, so just return "".
+                return "";
+            case "string": // Could be any arbitrary string -- use empty string instead.
+                return "";
+            case "number": // Allow numbers, but be sure to check it's actually a number.
+                return typeof value === "number" ? value : "";
+            case "boolean":
+                return typeof value === "boolean" ? value : "";
+            case "list":
+                const elementType = (option as CommandLineOptionOfListType).element;
+                return ts.isArray(value) ? value.map(v => getOptionValueWithEmptyStrings(v, elementType)) : "";
+            default:
+                return ts.forEachEntry(option.type, (optionEnumValue, optionStringValue) => {
+                    if (optionEnumValue === value) {
+                        return optionStringValue;
+                    }
+                });
+        }
+    }
 }

src/compiler/commandLineParser.ts

@@ -521,6 +521,18 @@ namespace ts {
         return result || array;
     }
 
+    export function mapDefined<T>(array: ReadonlyArray<T>, mapFn: (x: T, i: number) => T | undefined): ReadonlyArray<T> {
+        const result: T[] = [];
+        for (let i = 0; i < array.length; i++) {
+            const item = array[i];
+            const mapped = mapFn(item, i);
+            if (mapped !== undefined) {
+                result.push(mapped);
+            }
+        }
+        return result;
+    }
+
     /**
      * Computes the first matching span of elements and returns a tuple of the first span
      * and the remaining elements.
@@ -740,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;
     }
@@ -776,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;
@@ -1125,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 {}
 
@@ -2210,8 +2257,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() {
@@ -2248,24 +2298,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): void {
-            Debug.assert(/*expression*/ false, message);
+        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 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] : "";
+            }
         }
     }
 
@@ -2431,4 +2499,4 @@ namespace ts {
     export function isCheckJsEnabledForFile(sourceFile: SourceFile, compilerOptions: CompilerOptions) {
         return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs;
     }
-}
+}