merge with origin/master

vladima · vladima · commit 3d4e2203b8de · 2016-01-06T14:16:56.000-08:00
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
@@ -189,7 +189,7 @@ namespace ts {
             }
 
             const failedLookupLocations: string[] = [];
-            const resolvedFileName = loadModuleFromFile(supportedExtensions, moduleName, failedLookupLocations, host, traceEnabled);
+            const resolvedFileName = loadModuleFromFile(supportedExtensions, moduleName, failedLookupLocations, !directoryProbablyExists(getDirectoryPath(moduleName), host), host, traceEnabled);
             return {
                 resolvedModule: resolvedFileName ? { resolvedFileName } : undefined,
                 failedLookupLocations
@@ -265,7 +265,7 @@ namespace ts {
             }
         }
 
-        const resolvedFileName = loadModuleFromFile(supportedExtensions, candidate, failedLookupLocations, host, traceEnabled);
+        const resolvedFileName = loadModuleFromFile(supportedExtensions, candidate, failedLookupLocations, !directoryProbablyExists(getDirectoryPath(candidate), host), host, traceEnabled);
         return {
             resolvedModule: resolvedFileName ? { resolvedFileName } : undefined,
             failedLookupLocations
@@ -323,7 +323,7 @@ namespace ts {
                     trace(host, Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path);
                 }
 
-                const resolvedFileName = loadModuleFromFile(supportedExtensions, candidate, failedLookupLocations, host, traceEnabled);
+                const resolvedFileName = loadModuleFromFile(supportedExtensions, candidate, failedLookupLocations, !directoryProbablyExists(getDirectoryPath(candidate), host), host, traceEnabled);
                 if (resolvedFileName) {
                     return { resolvedModule: { resolvedFileName }, failedLookupLocations };
                 }
@@ -338,7 +338,7 @@ namespace ts {
                 trace(host, Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, baseUrl, candidate);
             }
 
-            const resolvedFileName = loadModuleFromFile(supportedExtensions, candidate, failedLookupLocations, host, traceEnabled);
+            const resolvedFileName = loadModuleFromFile(supportedExtensions, candidate, failedLookupLocations, !directoryProbablyExists(getDirectoryPath(candidate), host), host, traceEnabled);
             return {
                 resolvedModule: resolvedFileName ? { resolvedFileName } : undefined,
                 failedLookupLocations
@@ -363,18 +363,16 @@ namespace ts {
         if (isRootedDiskPath(moduleName) || nameStartsWithDotSlashOrDotDotSlash(moduleName)) {
             const failedLookupLocations: string[] = [];
             const candidate = normalizePath(combinePaths(containingDirectory, moduleName));
-
             if (traceEnabled) {
                 trace(host, Diagnostics.Loading_module_0_as_file_Slash_folder_candidate_module_location_1, moduleName, candidate);
             }
 
-            let resolvedFileName = loadModuleFromFile(supportedExtensions, candidate, failedLookupLocations, host, traceEnabled);
-
+            let resolvedFileName = loadModuleFromFile(supportedExtensions, candidate, failedLookupLocations, /*onlyRecordFailures*/ false, host, traceEnabled);
             if (resolvedFileName) {
                 return { resolvedModule: { resolvedFileName }, failedLookupLocations };
             }
 
-            resolvedFileName = loadNodeModuleFromDirectory(supportedExtensions, candidate, failedLookupLocations, host, traceEnabled);
+            resolvedFileName = loadNodeModuleFromDirectory(supportedExtensions, candidate, failedLookupLocations, /*onlyRecordFailures*/ false, host, traceEnabled);
             return resolvedFileName
                 ? { resolvedModule: { resolvedFileName }, failedLookupLocations }
                 : { resolvedModule: undefined, failedLookupLocations };
@@ -388,13 +386,22 @@ namespace ts {
         }
     }
 
-    function loadModuleFromFile(extensions: string[], candidate: string, failedLookupLocation: string[], host: ModuleResolutionHost, traceEnabled: boolean): string {
+    /* @internal */
+    export function directoryProbablyExists(directoryName: string, host: { directoryExists?: (directoryName: string) => boolean } ): boolean {
+        // if host does not support 'directoryExists' assume that directory will exist
+        return !host.directoryExists || host.directoryExists(directoryName);
+    }
+
+    /**
+     * @param {boolean} onlyRecordFailures - if true then function won't try to actually load files but instead record all attempts as failures. This flag is necessary
+     * in cases when we know upfront that all load attempts will fail (because containing folder does not exists) however we still need to record all failed lookup locations. 
+     */
+    function loadModuleFromFile(extensions: string[], candidate: string, failedLookupLocation: string[], onlyRecordFailures: boolean, host: ModuleResolutionHost, traceEnabled: boolean): string {
         return forEach(extensions, tryLoad);
 
         function tryLoad(ext: string): string {
             const fileName = fileExtensionIs(candidate, ext) ? candidate : candidate + ext;
-
-            if (host.fileExists(fileName)) {
+            if (!onlyRecordFailures && host.fileExists(fileName)) {
                 if (traceEnabled) {
                     trace(host, Diagnostics.File_0_exist_use_it_as_a_module_resolution_result, fileName);
                 }
@@ -410,9 +417,10 @@ namespace ts {
         }
     }
 
-    function loadNodeModuleFromDirectory(extensions: string[], candidate: string, failedLookupLocation: string[], host: ModuleResolutionHost, traceEnabled: boolean): string {
+    function loadNodeModuleFromDirectory(extensions: string[], candidate: string, failedLookupLocation: string[], onlyRecordFailures: boolean, host: ModuleResolutionHost, traceEnabled: boolean): string {
         const packageJsonPath = combinePaths(candidate, "package.json");
-        if (host.fileExists(packageJsonPath)) {
+        const directoryExists = !onlyRecordFailures && directoryProbablyExists(candidate, host);
+        if (directoryExists && host.fileExists(packageJsonPath)) {
             if (traceEnabled) {
                 trace(host, Diagnostics.Found_package_json_at_0, packageJsonPath);
             }
@@ -434,7 +442,7 @@ namespace ts {
                     if (traceEnabled) {
                         trace(host, Diagnostics.package_json_has_typings_field_0_that_references_1, jsonContent.typings, typingsFile);
                     }
-                    const result = loadModuleFromFile(extensions, typingsFile, failedLookupLocation, host, traceEnabled);
+                    const result = loadModuleFromFile(extensions, typingsFile, failedLookupLocation, !directoryProbablyExists(getDirectoryPath(typingsFile), host), host, traceEnabled);
                     if (result) {
                         return result;
                     }
@@ -457,7 +465,7 @@ namespace ts {
             failedLookupLocation.push(packageJsonPath);
         }
 
-        return loadModuleFromFile(extensions, combinePaths(candidate, "index"), failedLookupLocation, host, traceEnabled);
+        return loadModuleFromFile(extensions, combinePaths(candidate, "index"), failedLookupLocation, !directoryExists, host, traceEnabled);
     }
 
     function loadModuleFromNodeModules(moduleName: string, directory: string, host: ModuleResolutionHost, traceEnabled: boolean): ResolvedModuleWithFailedLookupLocations {
@@ -467,14 +475,14 @@ namespace ts {
             const baseName = getBaseFileName(directory);
             if (baseName !== "node_modules") {
                 const nodeModulesFolder = combinePaths(directory, "node_modules");
+                const nodeModulesFolderExists = directoryProbablyExists(nodeModulesFolder, host);
                 const candidate = normalizePath(combinePaths(nodeModulesFolder, moduleName));
                 // Load only typescript files irrespective of allowJs option if loading from node modules
-                let result = loadModuleFromFile(supportedTypeScriptExtensions, candidate, failedLookupLocations, host, traceEnabled);
+                let result = loadModuleFromFile(supportedTypeScriptExtensions, candidate, failedLookupLocations, !nodeModulesFolderExists, host, traceEnabled);
                 if (result) {
                     return { resolvedModule: { resolvedFileName: result, isExternalLibraryImport: true }, failedLookupLocations };
                 }
-
-                result = loadNodeModuleFromDirectory(supportedTypeScriptExtensions, candidate, failedLookupLocations, host, traceEnabled);
+                result = loadNodeModuleFromDirectory(supportedTypeScriptExtensions, candidate, failedLookupLocations, !nodeModulesFolderExists, host, traceEnabled);
                 if (result) {
                     return { resolvedModule: { resolvedFileName: result, isExternalLibraryImport: true }, failedLookupLocations };
                 }
@@ -655,7 +663,8 @@ namespace ts {
             getNewLine: () => newLine,
             fileExists: fileName => sys.fileExists(fileName),
             readFile: fileName => sys.readFile(fileName),
-            trace: (s: string) => sys.write(s + newLine)
+            trace: (s: string) => sys.write(s + newLine),
+            directoryExists: directoryName => sys.directoryExists(directoryName)
         };
     }
 
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -2667,6 +2667,7 @@ namespace ts {
         // to determine location of bundled typings for node module
         readFile(fileName: string): string;
         trace?(s: string): void;
+        directoryExists?(directoryName: string): boolean;
     }
 
     export interface ResolvedModule {
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
@@ -267,6 +267,10 @@ namespace Harness.LanguageService {
         log(s: string): void { this.nativeHost.log(s); }
         trace(s: string): void { this.nativeHost.trace(s); }
         error(s: string): void { this.nativeHost.error(s); }
+        directoryExists(directoryName: string): boolean {
+            // for tests pessimistically assume that directory always exists
+            return true;
+        }
     }
 
     class ClassifierShimProxy implements ts.Classifier {
diff --git a/src/lib/dom.generated.d.ts b/src/lib/dom.generated.d.ts
@@ -321,6 +321,7 @@ interface AudioContext extends EventTarget {
     destination: AudioDestinationNode;
     listener: AudioListener;
     sampleRate: number;
+    state: string;
     createAnalyser(): AnalyserNode;
     createBiquadFilter(): BiquadFilterNode;
     createBuffer(numberOfChannels: number, length: number, sampleRate: number): AudioBuffer;
@@ -2774,6 +2775,7 @@ interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelec
     tagName: string;
     id: string;
     className: string;
+    innerHTML: string;
     getAttribute(name?: string): string;
     getAttributeNS(namespaceURI: string, localName: string): string;
     getAttributeNode(name: string): Attr;
@@ -2969,7 +2971,7 @@ interface Element extends Node, GlobalEventHandlers, ElementTraversal, NodeSelec
     removeAttributeNode(oldAttr: Attr): Attr;
     requestFullscreen(): void;
     requestPointerLock(): void;
-    setAttribute(name?: string, value?: string): void;
+    setAttribute(name: string, value: string): void;
     setAttributeNS(namespaceURI: string, qualifiedName: string, value: string): void;
     setAttributeNode(newAttr: Attr): Attr;
     setAttributeNodeNS(newAttr: Attr): Attr;
@@ -5512,7 +5514,7 @@ interface HTMLMediaElement extends HTMLElement {
       * Gets or sets the current playback position, in seconds.
       */
     preload: string;
-    readyState: any;
+    readyState: number;
     /**
       * Returns a TimeRanges object that represents the ranges of the current media resource that can be seeked.
       */
@@ -6169,6 +6171,7 @@ interface HTMLSelectElement extends HTMLElement {
       * Returns whether an element will successfully validate based on forms validation rules and constraints.
       */
     willValidate: boolean;
+    selectedOptions: HTMLCollection;
     /**
       * Adds an element to the areas, controlRange, or options collection.
       * @param element Variant of type Number that specifies the index position in the collection where the element is placed. If no value is given, the method places the element at the end of the collection.
diff --git a/src/server/editorServices.ts b/src/server/editorServices.ts
@@ -100,7 +100,8 @@ namespace ts.server {
             this.filenameToScript = createFileMap<ScriptInfo>();
             this.moduleResolutionHost = {
                 fileExists: fileName => this.fileExists(fileName),
-                readFile: fileName => this.host.readFile(fileName)
+                readFile: fileName => this.host.readFile(fileName),
+                directoryExists: directoryName => this.host.directoryExists(directoryName)
             };
         }
 
diff --git a/src/services/services.ts b/src/services/services.ts
@@ -1034,6 +1034,7 @@ namespace ts {
          * host specific questions using 'getScriptSnapshot'.
          */
         resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
+        directoryExists?(directoryName: string): boolean;
     }
 
     //
@@ -1911,7 +1912,8 @@ namespace ts {
             getCurrentDirectory: () => "",
             getNewLine: () => newLine,
             fileExists: (fileName): boolean => fileName === inputFileName,
-            readFile: (fileName): string => ""
+            readFile: (fileName): string => "",
+            directoryExists: directoryExists => true
         };
 
         const program = createProgram([inputFileName], options, compilerHost);
@@ -2768,6 +2770,10 @@ namespace ts {
                     // stub missing host functionality
                     const entry = hostCache.getOrCreateEntry(fileName);
                     return entry && entry.scriptSnapshot.getText(0, entry.scriptSnapshot.getLength());
+                },
+                directoryExists: directoryName => {
+                    Debug.assert(!host.resolveModuleNames);
+                    return directoryProbablyExists(directoryName, host);
                 }
             };
 
diff --git a/src/services/shims.ts b/src/services/shims.ts
@@ -62,6 +62,7 @@ namespace ts {
         useCaseSensitiveFileNames?(): boolean;
         
         getModuleResolutionsForFile?(fileName: string): string;
+        directoryExists(directoryName: string): boolean;
     }
 
     /** Public interface of the the of a config service shim instance.*/
@@ -276,6 +277,7 @@ namespace ts {
         private tracingEnabled = false;
         
         public resolveModuleNames: (moduleName: string[], containingFile: string) => ResolvedModule[];
+        public directoryExists: (directoryName: string) => boolean;
         
         constructor(private shimHost: LanguageServiceShimHost) {
             // if shimHost is a COM object then property check will become method call with no arguments.
@@ -289,6 +291,9 @@ namespace ts {
                     });
                 };
             }
+            if ("directoryExists" in this.shimHost) {
+                this.directoryExists = directoryName => this.shimHost.directoryExists(directoryName);
+            }
         }
 
         public log(s: string): void {
@@ -407,9 +412,14 @@ namespace ts {
         }
     }
 
-    export class CoreServicesShimHostAdapter implements ParseConfigHost {
+    export class CoreServicesShimHostAdapter implements ParseConfigHost, ModuleResolutionHost {
 
+        public directoryExists: (directoryName: string) => boolean;
+        
         constructor(private shimHost: CoreServicesShimHost) {
+            if ("directoryExists" in this.shimHost) {
+                this.directoryExists = directoryName => this.shimHost.directoryExists(directoryName);
+            }
         }
 
         public readDirectory(rootDir: string, extension: string, exclude: string[]): string[] {
@@ -426,11 +436,11 @@ namespace ts {
             }
             return JSON.parse(encoded);
         }
-        
+
         public fileExists(fileName: string): boolean {
             return this.shimHost.fileExists(fileName);
         }
-        
+
         public readFile(fileName: string): string {
             return this.shimHost.readFile(fileName);
         }
diff --git a/tests/cases/unittests/moduleResolution.ts b/tests/cases/unittests/moduleResolution.ts

Original file line number	Diff line number	Diff line change
`@@ -2667,6 +2667,7 @@ namespace ts {`
`2667`	`2667`	`// to determine location of bundled typings for node module`
`2668`	`2668`	`readFile(fileName: string): string;`
`2669`	`2669`	`trace?(s: string): void;`
	`2670`	`+ directoryExists?(directoryName: string): boolean;`
`2670`	`2671`	`}`
`2671`	`2672`
`2672`	`2673`	`export interface ResolvedModule {`
Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,8 @@ namespace ts.server {`
`100`	`100`	`this.filenameToScript = createFileMap<ScriptInfo>();`
`101`	`101`	`this.moduleResolutionHost = {`
`102`	`102`	`fileExists: fileName => this.fileExists(fileName),`
`103`		`- readFile: fileName => this.host.readFile(fileName)`
	`103`	`+ readFile: fileName => this.host.readFile(fileName),`
	`104`	`+ directoryExists: directoryName => this.host.directoryExists(directoryName)`
`104`	`105`	`};`
`105`	`106`	`}`
`106`	`107`
Original file line number	Diff line number	Diff line change
`@@ -62,6 +62,7 @@ namespace ts {`
`62`	`62`	`useCaseSensitiveFileNames?(): boolean;`
`63`	`63`
`64`	`64`	`getModuleResolutionsForFile?(fileName: string): string;`
	`65`	`+ directoryExists(directoryName: string): boolean;`
`65`	`66`	`}`
`66`	`67`
`67`	`68`	`/** Public interface of the the of a config service shim instance.*/`
`@@ -276,6 +277,7 @@ namespace ts {`
`276`	`277`	`private tracingEnabled = false;`
`277`	`278`
`278`	`279`	`public resolveModuleNames: (moduleName: string[], containingFile: string) => ResolvedModule[];`
	`280`	`+ public directoryExists: (directoryName: string) => boolean;`
`279`	`281`
`280`	`282`	`constructor(private shimHost: LanguageServiceShimHost) {`
`281`	`283`	`// if shimHost is a COM object then property check will become method call with no arguments.`
`@@ -289,6 +291,9 @@ namespace ts {`
`289`	`291`	`});`
`290`	`292`	`};`
`291`	`293`	`}`
	`294`	`+ if ("directoryExists" in this.shimHost) {`
	`295`	`+ this.directoryExists = directoryName => this.shimHost.directoryExists(directoryName);`
	`296`	`+ }`
`292`	`297`	`}`
`293`	`298`
`294`	`299`	`public log(s: string): void {`
`@@ -407,9 +412,14 @@ namespace ts {`
`407`	`412`	`}`
`408`	`413`	`}`
`409`	`414`
`410`		`- export class CoreServicesShimHostAdapter implements ParseConfigHost {`
	`415`	`+ export class CoreServicesShimHostAdapter implements ParseConfigHost, ModuleResolutionHost {`
`411`	`416`
	`417`	`+ public directoryExists: (directoryName: string) => boolean;`
	`418`	`+`
`412`	`419`	`constructor(private shimHost: CoreServicesShimHost) {`
	`420`	`+ if ("directoryExists" in this.shimHost) {`
	`421`	`+ this.directoryExists = directoryName => this.shimHost.directoryExists(directoryName);`
	`422`	`+ }`
`413`	`423`	`}`
`414`	`424`
`415`	`425`	`public readDirectory(rootDir: string, extension: string, exclude: string[]): string[] {`
`@@ -426,11 +436,11 @@ namespace ts {`
`426`	`436`	`}`
`427`	`437`	`return JSON.parse(encoded);`
`428`	`438`	`}`
`429`		`-`
	`439`	`+`
`430`	`440`	`public fileExists(fileName: string): boolean {`
`431`	`441`	`return this.shimHost.fileExists(fileName);`
`432`	`442`	`}`
`433`		`-`
	`443`	`+`
`434`	`444`	`public readFile(fileName: string): string {`
`435`	`445`	`return this.shimHost.readFile(fileName);`
`436`	`446`	`}`