microsoft
diff --git a/Diff for: ‎Jakefile.js
+3-2 b/Diff for: ‎Jakefile.js
+3-2
diff --git a/Diff for: ‎scripts/mocha-parallel.js
+2-3 b/Diff for: ‎scripts/mocha-parallel.js
+2-3
diff --git a/Diff for: ‎src/compiler/binder.ts
+1-1 b/Diff for: ‎src/compiler/binder.ts
+1-1
diff --git a/Diff for: ‎src/compiler/checker.ts
+6-2 b/Diff for: ‎src/compiler/checker.ts
+6-2
diff --git a/Diff for: ‎src/compiler/commandLineParser.ts
+23-8 b/Diff for: ‎src/compiler/commandLineParser.ts
+23-8
diff --git a/Diff for: ‎src/compiler/diagnosticMessages.json
+4 b/Diff for: ‎src/compiler/diagnosticMessages.json
+4
diff --git a/Diff for: ‎src/compiler/program.ts
+50-54 b/Diff for: ‎src/compiler/program.ts
+50-54
diff --git a/Diff for: ‎src/compiler/types.ts
+3-2 b/Diff for: ‎src/compiler/types.ts
+3-2
diff --git a/Diff for: ‎src/compiler/utilities.ts
+12 b/Diff for: ‎src/compiler/utilities.ts
+12
@@ -794,13 +794,14 @@ function runConsoleTests(defaultReporter, runInParallel) {
     colors = process.env.colors || process.env.color;
     colors = colors ? ' --no-colors ' : ' --colors ';
     reporter = process.env.reporter || process.env.r || defaultReporter;
+    var bail = (process.env.bail || process.env.b) ? "--bail" : "";
     var lintFlag = process.env.lint !== 'false';
 
     // timeout normally isn't necessary but Travis-CI has been timing out on compiler baselines occasionally
     // default timeout is 2sec which really should be enough, but maybe we just need a small amount longer
     if(!runInParallel) {
         tests = tests ? ' -g "' + tests + '"' : '';
-        var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + ' -t ' + testTimeout + ' ' + run;
+        var cmd = "mocha" + (debug ? " --debug-brk" : "") + " -R " + reporter + tests + colors + bail + ' -t ' + testTimeout + ' ' + run;
         console.log(cmd);
 
         var savedNodeEnv = process.env.NODE_ENV;
@@ -865,7 +866,7 @@ task("runtests-parallel", ["build-rules", "tests", builtLocalDirectory], functio
     runConsoleTests('min', /*runInParallel*/ true);
 }, {async: true});
 
-desc("Runs the tests using the built run.js file. Optional arguments are: t[ests]=regex r[eporter]=[list|spec|json|<more>] d[ebug]=true color[s]=false lint=true dirty=false.");
+desc("Runs the tests using the built run.js file. Optional arguments are: t[ests]=regex r[eporter]=[list|spec|json|<more>] d[ebug]=true color[s]=false lint=true bail=false dirty=false.");
 task("runtests", ["build-rules", "tests", builtLocalDirectory], function() {
     runConsoleTests('mocha-fivemat-progress-reporter', /*runInParallel*/ false);
 }, {async: true});
 
@@ -193,7 +193,6 @@ function runTests(taskConfigsFolder, run, options, cb) {
         counter--;
 
         if (counter <= 0) {
-            var failed = 0;
             var reporter = new Base(),
                 stats = reporter.stats,
                 failures = reporter.failures;
@@ -224,8 +223,8 @@ function runTests(taskConfigsFolder, run, options, cb) {
                 reporter.epilogue();
             }
 
-            if (failed) {
-                return cb(new Error("Test failures reported: " + failed));
+            if (stats.failures) {
+                return cb(new Error("Test failures reported: " + stats.failures));
             }
             else {
                 return cb();
 
@@ -1985,7 +1985,7 @@ namespace ts {
             classPrototype.parent = leftSideOfAssignment;
 
             const funcSymbol = container.locals[constructorFunction.text];
-            if (!funcSymbol || !(funcSymbol.flags & SymbolFlags.Function)) {
+            if (!funcSymbol || !(funcSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(funcSymbol))) {
                 return;
             }
 
 
@@ -11497,8 +11497,12 @@ namespace ts {
                     // When resolved signature is a call signature (and not a construct signature) the result type is any, unless
                     // the declaring function had members created through 'x.prototype.y = expr' or 'this.y = expr' psuedodeclarations
                     // in a JS file
-                    const funcSymbol = checkExpression(node.expression).symbol;
-                    if (funcSymbol && funcSymbol.members && (funcSymbol.flags & SymbolFlags.Function)) {
+                    // Note:JS inferred classes might come from a variable declaration instead of a function declaration.
+                    // In this case, using getResolvedSymbol directly is required to avoid losing the members from the declaration.
+                    const funcSymbol = node.expression.kind === SyntaxKind.Identifier ?
+                        getResolvedSymbol(node.expression as Identifier) :
+                        checkExpression(node.expression).symbol;
+                    if (funcSymbol && funcSymbol.members && (funcSymbol.flags & SymbolFlags.Function || isDeclarationOfFunctionExpression(funcSymbol))) {
                         return getInferredClassType(funcSymbol);
                     }
                     else if (compilerOptions.noImplicitAny) {
 
@@ -342,8 +342,13 @@ namespace ts {
             }
         },
         {
-            name: "typesRoot",
-            type: "string"
+            name: "typeRoots",
+            type: "list",
+            element: {
+                name: "typeRoots",
+                type: "string",
+                isFilePath: true
+            }
         },
         {
             name: "types",
@@ -493,13 +498,20 @@ namespace ts {
     }
 
     /* @internal */
-    export function parseListTypeOption(opt: CommandLineOptionOfListType, value: string, errors: Diagnostic[]): (string | number)[] {
-        const values = trimString((value || "")).split(",");
+    export function parseListTypeOption(opt: CommandLineOptionOfListType, value = "", errors: Diagnostic[]): (string | number)[] | undefined {
+        value = trimString(value);
+        if (startsWith(value, "-")) {
+            return undefined;
+        }
+        if (value === "") {
+            return [];
+        }
+        const values = value.split(",");
         switch (opt.element.type) {
             case "number":
-                return ts.map(values, parseInt);
+                return map(values, parseInt);
             case "string":
-                return ts.map(values, v => v || "");
+                return map(values, v => v || "");
             default:
                 return filter(map(values, v => parseCustomTypeOption(<CommandLineOptionOfCustomType>opt.element, v, errors)), v => !!v);
         }
@@ -560,8 +572,11 @@ namespace ts {
                                     i++;
                                     break;
                                 case "list":
-                                    options[opt.name] = parseListTypeOption(<CommandLineOptionOfListType>opt, args[i], errors);
-                                    i++;
+                                    const result = parseListTypeOption(<CommandLineOptionOfListType>opt, args[i], errors);
+                                    options[opt.name] = result || [];
+                                    if (result) {
+                                        i++;
+                                    }
                                     break;
                                 // If not a primitive, the possible types are specified in what is effectively a map of options.
                                 default:
 
@@ -1931,6 +1931,10 @@
         "category": "Error",
         "code": 2687
     },
+    "Cannot find type definition file for '{0}'.": {
+        "category": "Error",
+        "code": 2688
+    },
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
 
@@ -4,16 +4,11 @@
 
 namespace ts {
     /** The version of the TypeScript compiler release */
+    export const version = "1.9.0";
 
     const emptyArray: any[] = [];
 
-    const defaultLibrarySearchPaths = [
-        "types/",
-        "node_modules/",
-        "node_modules/@types/",
-    ];
-
-    export const version = "1.9.0";
+    const defaultTypeRoots = ["node_modules/@types"];
 
     export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean): string {
         while (true) {
@@ -178,6 +173,11 @@ namespace ts {
 
     const typeReferenceExtensions = [".d.ts"];
 
+    function getEffectiveTypeRoots(options: CompilerOptions, host: ModuleResolutionHost) {
+        return options.typeRoots ||
+            defaultTypeRoots.map(d => combinePaths(options.configFilePath ? getDirectoryPath(options.configFilePath) : host.getCurrentDirectory(), d));
+    }
+
     /**
      * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.
      * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
@@ -192,39 +192,36 @@ namespace ts {
             traceEnabled
         };
 
-        // use typesRoot and fallback to directory that contains tsconfig or current directory if typesRoot is not set
-        const rootDir = options.typesRoot || (options.configFilePath ? getDirectoryPath(options.configFilePath) : (host.getCurrentDirectory && host.getCurrentDirectory()));
-
+        const typeRoots = getEffectiveTypeRoots(options, host);
         if (traceEnabled) {
             if (containingFile === undefined) {
-                if (rootDir === undefined) {
+                if (typeRoots === undefined) {
                     trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName);
                 }
                 else {
-                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, rootDir);
+                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots);
                 }
             }
             else {
-                if (rootDir === undefined) {
+                if (typeRoots === undefined) {
                     trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile);
                 }
                 else {
-                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, rootDir);
+                    trace(host, Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots);
                 }
             }
         }
 
         const failedLookupLocations: string[] = [];
 
         // Check primary library paths
-        if (rootDir !== undefined) {
-            const effectivePrimarySearchPaths = options.typesSearchPaths || defaultLibrarySearchPaths;
-            for (const searchPath of effectivePrimarySearchPaths) {
-                const primaryPath = combinePaths(rootDir, searchPath);
-                if (traceEnabled) {
-                    trace(host, Diagnostics.Resolving_with_primary_search_path_0, primaryPath);
-                }
-                const candidate = combinePaths(primaryPath, typeReferenceDirectiveName);
+        if (typeRoots.length) {
+            if (traceEnabled) {
+                trace(host, Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", "));
+            }
+            const primarySearchPaths = typeRoots;
+            for (const typeRoot of primarySearchPaths) {
+                const candidate = combinePaths(typeRoot, typeReferenceDirectiveName);
                 const candidateDirectory = getDirectoryPath(candidate);
                 const resolvedFile = loadNodeModuleFromDirectory(typeReferenceExtensions, candidate, failedLookupLocations,
                     !directoryProbablyExists(candidateDirectory, host), moduleResolutionState);
@@ -251,9 +248,6 @@ namespace ts {
         if (containingFile) {
             initialLocationForSecondaryLookup = getDirectoryPath(containingFile);
         }
-        else {
-            initialLocationForSecondaryLookup = rootDir;
-        }
 
         if (initialLocationForSecondaryLookup !== undefined) {
             // check secondary locations
@@ -932,19 +926,6 @@ namespace ts {
             }
         }
 
-        function getDefaultTypeDirectiveNames(rootPath: string): string[] {
-            const localTypes = combinePaths(rootPath, "types");
-            const npmTypes = combinePaths(rootPath, "node_modules/@types");
-            let result: string[] = [];
-            if (sys.directoryExists(localTypes)) {
-                result = result.concat(sys.getDirectories(localTypes));
-            }
-            if (sys.directoryExists(npmTypes)) {
-                result = result.concat(sys.getDirectories(npmTypes));
-            }
-            return result;
-        }
-
         function getDefaultLibLocation(): string {
             return getDirectoryPath(normalizePath(sys.getExecutingFilePath()));
         }
@@ -953,7 +934,6 @@ namespace ts {
         const realpath = sys.realpath && ((path: string) => sys.realpath(path));
 
         return {
-            getDefaultTypeDirectiveNames,
             getSourceFile,
             getDefaultLibLocation,
             getDefaultLibFileName: options => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),
@@ -967,7 +947,8 @@ namespace ts {
             trace: (s: string) => sys.write(s + newLine),
             directoryExists: directoryName => sys.directoryExists(directoryName),
             realpath,
-            getEnvironmentVariable: name => getEnvironmentVariable(name, /*host*/ undefined)
+            getEnvironmentVariable: name => getEnvironmentVariable(name, /*host*/ undefined),
+            getDirectories: (path: string) => sys.getDirectories(path),
         };
     }
 
@@ -1030,21 +1011,35 @@ namespace ts {
         return resolutions;
     }
 
-    export function getDefaultTypeDirectiveNames(options: CompilerOptions, rootFiles: string[], host: CompilerHost): string[] {
+    function getInferredTypesRoot(options: CompilerOptions, rootFiles: string[], host: CompilerHost) {
+        return computeCommonSourceDirectoryOfFilenames(rootFiles, host.getCurrentDirectory(), f => host.getCanonicalFileName(f));
+    }
+
+    /**
+      * Given a set of options and a set of root files, returns the set of type directive names
+      *   that should be included for this program automatically.
+      * This list could either come from the config file,
+      *   or from enumerating the types root + initial secondary types lookup location.
+      * More type directives might appear in the program later as a result of loading actual source files;
+      *   this list is only the set of defaults that are implicitly included.
+      */
+    export function getAutomaticTypeDirectiveNames(options: CompilerOptions, rootFiles: string[], host: CompilerHost): string[] {
         // Use explicit type list from tsconfig.json
         if (options.types) {
             return options.types;
         }
 
-        // or load all types from the automatic type import fields
-        if (host && host.getDefaultTypeDirectiveNames) {
-            const commonRoot = computeCommonSourceDirectoryOfFilenames(rootFiles, host.getCurrentDirectory(), f => host.getCanonicalFileName(f));
-            if (commonRoot) {
-                return host.getDefaultTypeDirectiveNames(commonRoot);
+        // Walk the primary type lookup locations
+        let result: string[] = [];
+        if (host.directoryExists && host.getDirectories) {
+            const typeRoots = getEffectiveTypeRoots(options, host);
+            for (const root of typeRoots) {
+                if (host.directoryExists(root)) {
+                    result = result.concat(host.getDirectories(root));
+                }
             }
         }
-
-        return undefined;
+        return result;
     }
 
     export function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program): Program {
@@ -1096,11 +1091,13 @@ namespace ts {
         if (!tryReuseStructureFromOldProgram()) {
             forEach(rootNames, name => processRootFile(name, /*isDefaultLib*/ false));
 
-            // load type declarations specified via 'types' argument
-            const typeReferences: string[] = getDefaultTypeDirectiveNames(options, rootNames, host);
+            // load type declarations specified via 'types' argument or implicitly from types/ and node_modules/@types folders
+            const typeReferences: string[] = getAutomaticTypeDirectiveNames(options, rootNames, host);
 
             if (typeReferences) {
-                const resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, /*containingFile*/ undefined);
+                const inferredRoot = getInferredTypesRoot(options, rootNames, host);
+                const containingFilename = combinePaths(inferredRoot, "__inferred type names__.ts");
+                const resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename);
                 for (let i = 0; i < typeReferences.length; i++) {
                     processTypeReferenceDirective(typeReferences[i], resolutions[i]);
                 }
@@ -1208,10 +1205,9 @@ namespace ts {
                 (oldOptions.jsx !== options.jsx) ||
                 (oldOptions.allowJs !== options.allowJs) ||
                 (oldOptions.rootDir !== options.rootDir) ||
-                (oldOptions.typesSearchPaths !== options.typesSearchPaths) ||
                 (oldOptions.configFilePath !== options.configFilePath) ||
                 (oldOptions.baseUrl !== options.baseUrl) ||
-                (oldOptions.typesRoot !== options.typesRoot) ||
+                !arrayIsEqualTo(oldOptions.typeRoots, oldOptions.typeRoots) ||
                 !arrayIsEqualTo(oldOptions.rootDirs, options.rootDirs) ||
                 !mapIsEqualTo(oldOptions.paths, options.paths)) {
                 return false;
@@ -1967,7 +1963,7 @@ namespace ts {
                 }
             }
             else {
-                fileProcessingDiagnostics.add(createDiagnostic(refFile, refPos, refEnd, Diagnostics.Cannot_find_name_0, typeReferenceDirective));
+                fileProcessingDiagnostics.add(createDiagnostic(refFile, refPos, refEnd, Diagnostics.Cannot_find_type_definition_file_for_0, typeReferenceDirective));
             }
 
             if (saveResolution) {
 
@@ -2630,9 +2630,9 @@ namespace ts {
         target?: ScriptTarget;
         traceResolution?: boolean;
         types?: string[];
-        /* @internal */ typesRoot?: string;
+        /** Paths used to used to compute primary types search locations */
+        typeRoots?: string[];
         typesSearchPaths?: string[];
-        /* @internal */ useLegacyEmitter?: boolean;
         /*@internal*/ version?: boolean;
         /*@internal*/ watch?: boolean;
 
@@ -2940,6 +2940,7 @@ namespace ts {
         getDefaultTypeDirectiveNames?(rootPath: string): string[];
         writeFile: WriteFileCallback;
         getCurrentDirectory(): string;
+        getDirectories(path: string): string[];
         getCanonicalFileName(fileName: string): string;
         useCaseSensitiveFileNames(): boolean;
         getNewLine(): string;
 
@@ -1362,6 +1362,18 @@ namespace ts {
         return charCode === CharacterCodes.singleQuote || charCode === CharacterCodes.doubleQuote;
     }
 
+    /**
+     * Returns true if the node is a variable declaration whose initializer is a function expression.
+     * This function does not test if the node is in a JavaScript file or not.
+     */
+    export function isDeclarationOfFunctionExpression(s: Symbol) {
+        if (s.valueDeclaration && s.valueDeclaration.kind === SyntaxKind.VariableDeclaration) {
+            const declaration = s.valueDeclaration as VariableDeclaration;
+            return declaration.initializer && declaration.initializer.kind === SyntaxKind.FunctionExpression;
+        }
+        return false;
+    }
+
     /// Given a BinaryExpression, returns SpecialPropertyAssignmentKind for the various kinds of property
     /// assignments we treat as special in the binder
     export function getSpecialPropertyAssignmentKind(expression: Node): SpecialPropertyAssignmentKind {
Original file line number	Diff line number	Diff line change
`@@ -1985,7 +1985,7 @@ namespace ts {`
`1985`	`1985`	`classPrototype.parent = leftSideOfAssignment;`
`1986`	`1986`
`1987`	`1987`	`const funcSymbol = container.locals[constructorFunction.text];`
`1988`		`- if (!funcSymbol \|\| !(funcSymbol.flags & SymbolFlags.Function)) {`
	`1988`	`+ if (!funcSymbol \|\| !(funcSymbol.flags & SymbolFlags.Function \|\| isDeclarationOfFunctionExpression(funcSymbol))) {`
`1989`	`1989`	`return;`
`1990`	`1990`	`}`
`1991`	`1991`