Use resolveModuleNames when making an extension cache, if available. Implement loadExtension on LSHost

Author: weswigham

src/compiler/extensions.ts

@@ -30,6 +30,7 @@ namespace ts {
 
     export interface ExtensionHost extends ModuleResolutionHost {
         loadExtension?(name: string): any;
+        resolveModuleNames?(moduleNames: string[], containingFile: string, loadJs?: boolean): ResolvedModule[];
     }
 
     export interface Program {
@@ -113,11 +114,22 @@ namespace ts {
         };
         return cache;
 
+        // Defer to the host's `resolveModuleName` method if it has it, otherwise use it as a ModuleResolutionHost.
+        function resolveModuleName(name: string, fromLocation: string) {
+            if (host.resolveModuleNames) {
+                const results = host.resolveModuleNames([name], fromLocation, /*loadJs*/true);
+                return results && results[0];
+            }
+            else {
+                return ts.resolveModuleName(name, fromLocation, options, host, /*loadJs*/true).resolvedModule;
+            }
+        }
+
         function resolveExtensionNames(): Map<string> {
             const basePath = options.configFilePath || combinePaths(host.getCurrentDirectory ? host.getCurrentDirectory() : "", "tsconfig.json");
             const extMap: Map<string> = {};
             forEach(extensionNames, name => {
-                const resolved = resolveModuleName(name, basePath, options, host, /*loadJs*/true).resolvedModule;
+                const resolved = resolveModuleName(name, basePath);
                 if (resolved) {
                     extMap[name] = resolved.resolvedFileName;
                 }

src/compiler/tsconfig.json

@@ -24,7 +24,7 @@
         "declarationEmitter.ts",
         "emitter.ts",
         "program.ts",
-        "extensions.ts",
+        "extensions.ts",
         "commandLineParser.ts",
         "tsc.ts",
         "diagnosticInformationMap.generated.ts"

src/compiler/types.ts

@@ -2962,7 +2962,7 @@ namespace ts {
          * If resolveModuleNames is implemented then implementation for members from ModuleResolutionHost can be just
          * 'throw new Error("NotImplemented")'
          */
-        resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
+        resolveModuleNames?(moduleNames: string[], containingFile: string, loadJs?: boolean): ResolvedModule[];
         /**
          * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
          */

src/harness/harnessLanguageService.ts

@@ -216,7 +216,7 @@ namespace Harness.LanguageService {
     class ShimLanguageServiceHost extends LanguageServiceAdapterHost implements ts.LanguageServiceShimHost, ts.CoreServicesShimHost {
         private nativeHost: NativeLanguageServiceHost;
 
-        public getModuleResolutionsForFile: (fileName: string) => string;
+        public getModuleResolutionsForFile: (fileName: string, loadJs?: boolean) => string;
         public getTypeReferenceDirectiveResolutionsForFile: (fileName: string) => string;
 
         constructor(preprocessToResolve: boolean, cancellationToken?: ts.HostCancellationToken, options?: ts.CompilerOptions) {
@@ -232,12 +232,12 @@ namespace Harness.LanguageService {
                         return scriptInfo && scriptInfo.content;
                     }
                 };
-                this.getModuleResolutionsForFile = (fileName) => {
+                this.getModuleResolutionsForFile = (fileName, loadJs) => {
                     const scriptInfo = this.getScriptInfo(fileName);
                     const preprocessInfo = ts.preProcessFile(scriptInfo.content, /*readImportFiles*/ true);
                     const imports: ts.Map<string> = {};
                     for (const module of preprocessInfo.importedFiles) {
-                        const resolutionInfo = ts.resolveModuleName(module.fileName, fileName, compilerOptions, moduleResolutionHost);
+                        const resolutionInfo = ts.resolveModuleName(module.fileName, fileName, compilerOptions, moduleResolutionHost, loadJs);
                         if (resolutionInfo.resolvedModule) {
                             imports[module.fileName] = resolutionInfo.resolvedModule.resolvedFileName;
                         }

src/server/editorServices.ts

@@ -124,8 +124,9 @@ namespace ts.server {
             names: string[],
             containingFile: string,
             cache: ts.FileMap<Map<T>>,
-            loader: (name: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost) => T,
-            getResult: (s: T) => R): R[] {
+            loader: (name: string, containingFile: string, options: CompilerOptions, host: ModuleResolutionHost, loadJs?: boolean) => T,
+            getResult: (s: T) => R,
+            loadJs: boolean): R[] {
 
             const path = toPath(containingFile, this.host.getCurrentDirectory(), this.getCanonicalFileName);
             const currentResolutionsInFile = cache.get(path);
@@ -144,7 +145,7 @@ namespace ts.server {
                         resolution = existingResolution;
                     }
                     else {
-                        resolution = loader(name, containingFile, compilerOptions, this.moduleResolutionHost);
+                        resolution = loader(name, containingFile, compilerOptions, this.moduleResolutionHost, loadJs);
                         resolution.lastCheckTime = Date.now();
                         newResolutions[name] = resolution;
                     }
@@ -177,11 +178,11 @@ namespace ts.server {
         }
 
         resolveTypeReferenceDirectives(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[] {
-            return this.resolveNamesWithLocalCache(typeDirectiveNames, containingFile, this.resolvedTypeReferenceDirectives, resolveTypeReferenceDirective, m => m.resolvedTypeReferenceDirective);
+            return this.resolveNamesWithLocalCache(typeDirectiveNames, containingFile, this.resolvedTypeReferenceDirectives, resolveTypeReferenceDirective, m => m.resolvedTypeReferenceDirective, /*loadJs*/false);
         }
 
-        resolveModuleNames(moduleNames: string[], containingFile: string): ResolvedModule[] {
-            return this.resolveNamesWithLocalCache(moduleNames, containingFile, this.resolvedModuleNames, resolveModuleName, m => m.resolvedModule);
+        resolveModuleNames(moduleNames: string[], containingFile: string, loadJs?: boolean): ResolvedModule[] {
+            return this.resolveNamesWithLocalCache(moduleNames, containingFile, this.resolvedModuleNames, resolveModuleName, m => m.resolvedModule, loadJs);
         }
 
         getDefaultLibFileName() {
@@ -1377,6 +1378,13 @@ namespace ts.server {
             return false;
         }
 
+        loadExtension(name: string) {
+            if (!sys.loadExtension) {
+                throw new Error("Extension loading not implemented on the active host!");
+            }
+            return sys.loadExtension(name);
+        }
+
         openConfigFile(configFilename: string, clientFileName?: string): { success: boolean, project?: Project, errors?: Diagnostic[] } {
             const { succeeded, projectOptions, errors } = this.configFileToProjectOptions(configFilename);
             if (!succeeded) {

src/services/services.ts

@@ -1163,7 +1163,7 @@ namespace ts {
          * if implementation is omitted then language service will use built-in module resolution logic and get answers to
          * host specific questions using 'getScriptSnapshot'.
          */
-        resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
+        resolveModuleNames?(moduleNames: string[], containingFile: string, loadJs?: boolean): ResolvedModule[];
         resolveTypeReferenceDirectives?(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
         directoryExists?(directoryName: string): boolean;
         getDirectories?(directoryName: string): string[];
@@ -3147,7 +3147,7 @@ namespace ts {
             }
 
             if (host.resolveModuleNames) {
-                compilerHost.resolveModuleNames = (moduleNames, containingFile) => host.resolveModuleNames(moduleNames, containingFile);
+                compilerHost.resolveModuleNames = (moduleNames, containingFile, loadJs) => host.resolveModuleNames(moduleNames, containingFile, loadJs);
             }
             if (host.resolveTypeReferenceDirectives) {
                 compilerHost.resolveTypeReferenceDirectives = (typeReferenceDirectiveNames, containingFile) => {

src/services/shims.ts

@@ -67,7 +67,7 @@ namespace ts {
         getProjectVersion?(): string;
         useCaseSensitiveFileNames?(): boolean;
 
-        getModuleResolutionsForFile?(fileName: string): string;
+        getModuleResolutionsForFile?(fileName: string, loadJs?: boolean): string;
         getTypeReferenceDirectiveResolutionsForFile?(fileName: string): string;
         directoryExists(directoryName: string): boolean;
     }
@@ -303,16 +303,16 @@ namespace ts {
         private loggingEnabled = false;
         private tracingEnabled = false;
 
-        public resolveModuleNames: (moduleName: string[], containingFile: string) => ResolvedModule[];
+        public resolveModuleNames: (moduleName: string[], containingFile: string, loadJs?: boolean) => ResolvedModule[];
         public resolveTypeReferenceDirectives: (typeDirectiveNames: string[], containingFile: string) => ResolvedTypeReferenceDirective[];
         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.
             // 'in' does not have this effect.
             if ("getModuleResolutionsForFile" in this.shimHost) {
-                this.resolveModuleNames = (moduleNames: string[], containingFile: string) => {
-                    const resolutionsInFile = <Map<string>>JSON.parse(this.shimHost.getModuleResolutionsForFile(containingFile));
+                this.resolveModuleNames = (moduleNames: string[], containingFile: string, loadJs?: boolean) => {
+                    const resolutionsInFile = <Map<string>>JSON.parse(this.shimHost.getModuleResolutionsForFile(containingFile, loadJs));
                     return map(moduleNames, name => {
                         const result = lookUp(resolutionsInFile, name);
                         return result ? { resolvedFileName: result } : undefined;

tests/baselines/reference/CompilerHost/loadsExtensions/test-normal.js

@@ -0,0 +1,5 @@
+//// [hello.ts]
+console.log("Hello, world!");/*EOL*/
+
+//// [hello.js]
+console.log("Hello, world!"); /*EOL*/

tests/baselines/reference/LanguageServiceHost/loadsExtensions/test-normal.js

@@ -0,0 +1,5 @@
+//// [hello.ts]
+console.log("Hello, world!");/*EOL*/
+
+//// [hello.js]
+console.log("Hello, world!"); /*EOL*/

tests/cases/extensions/available/dummy/index.ts

@@ -0,0 +1 @@
+console.log("loaded");

tests/cases/extensions/available/dummy/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "dummy",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "author": ""
+}

tests/cases/extensions/scenarios/loadsExtensions/test-normal.json

@@ -0,0 +1,9 @@
+{
+    "inputFiles": [
+        "hello.ts"
+    ],
+    "availableExtensions": ["dummy"],
+    "compilerOptions": {
+        "extensions": ["dummy"]
+    }
+}