Don't require resolvedTsFileName and resolvedJsFileName, just resolvedFileName and extension. Also, change search order to do all TS searching before searching for JS.

Author: Andy Hanson

src/compiler/moduleNameResolver.ts

@@ -331,7 +331,15 @@ namespace ts {
 
         let resolveModuleNamesWorker: (moduleNames: string[], containingFile: string) => ResolvedModule[];
         if (host.resolveModuleNames) {
-            resolveModuleNamesWorker = (moduleNames, containingFile) => host.resolveModuleNames(moduleNames, containingFile).map(convertResolvedModuleFromHost);
+            resolveModuleNamesWorker = (moduleNames, containingFile) => host.resolveModuleNames(moduleNames, containingFile).map(resolved => {
+                // An older host may have omitted extension, in which case we should infer it from the file extension of resolvedFileName.
+                if (!resolved || resolved.extension) {
+                    return resolved;
+                }
+                resolved = clone(resolved);
+                resolved.extension = extensionFromPath(resolved.resolvedFileName);
+                return resolved;
+            });
         }
         else {
             const loader = (moduleName: string, containingFile: string) => resolveModuleName(moduleName, containingFile, options, host).resolvedModule;
@@ -1317,7 +1325,7 @@ namespace ts {
                     }
 
                     const isFromNodeModulesSearch = resolution.isExternalLibraryImport;
-                    const isJsFileFromNodeModules = isFromNodeModulesSearch && !resolution.resolvedTsFileName;
+                    const isJsFileFromNodeModules = isFromNodeModulesSearch && !extensionIsTypeScript(resolution.extension);
                     const resolvedFileName = resolution.resolvedFileName;
 
                     if (isFromNodeModulesSearch) {
@@ -1581,20 +1589,19 @@ namespace ts {
      * Returns a DiagnosticMessage if we can't use a resolved module due to its extension.
      * The DiagnosticMessage's parameters are the imported module name, and the filename it resolved to.
      */
-    export function getResolutionDiagnostic(options: CompilerOptions, { resolvedTsFileName: ts, resolvedJsFileName: js }: ResolvedModule): DiagnosticMessage | undefined {
-        if (ts) {
-            return !options.jsx && fileExtensionIs(ts, ".tsx") ? Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set : undefined;
-        }
-        else {
-            if (!options.allowJs) {
-                return Diagnostics.Module_0_was_resolved_to_1_but_allowJs_is_not_set;
-            }
-            else if (!options.jsx && fileExtensionIs(js!, ".jsx")) {
-                return Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set;
-            }
-            else {
+    export function getResolutionDiagnostic(options: CompilerOptions, { extension }: ResolvedModule): DiagnosticMessage | undefined {
+        switch (extension) {
+            case Extension.Ts:
+            case Extension.Dts:
+                // These are always allowed.
                 return undefined;
-            }
+
+            case Extension.Tsx:
+            case Extension.Jsx:
+                return options.jsx ? undefined : Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set;
+
+            case Extension.Js:
+                return options.allowJs ? undefined : Diagnostics.Module_0_was_resolved_to_1_but_allowJs_is_not_set;
         }
     }
 }

src/compiler/program.ts

@@ -3296,22 +3296,26 @@ namespace ts {
      * else resolution should just return `undefined` instead of a ResolvedModule.
      */
     export interface ResolvedModule {
-        /**
-         * This should always be set to `resolvedTsFileName || resolvedJsFileName`.
-         * Present for backwards compatibility.
-         */
+        /** Path of the file the module was resolved to. */
         resolvedFileName: string;
-        /** TypeScript (.d.ts, .ts, .tsx) file that the module was resolved to. This will be preferred over a JS file. */
-        resolvedTsFileName?: string;
-        /** JavaScript (or .jsx) file that the module was resolved to. This should be returned even if '--allowJs' (or '--jsx') is disabled. */
-        resolvedJsFileName?: string;
+        /** Extension of resolvedFileName. This must match what's at the end of resolvedFileName. */
+        extension: Extension;
         /**
          * Denotes if 'resolvedFileName' is isExternalLibraryImport and thus should be a proper external module:
          * - be a .d.ts file
          * - use top level imports\exports
          * - don't use tripleslash references
          */
-        isExternalLibraryImport: boolean;
+        isExternalLibraryImport?: boolean;
+    }
+
+    export enum Extension {
+        Ts,
+        Tsx,
+        Dts,
+        Js,
+        Jsx,
+        LastTypeScriptExtension = Dts
     }
 
     export interface ResolvedModuleWithFailedLookupLocations {

src/compiler/types.ts

@@ -118,30 +118,6 @@ namespace ts {
         sourceFile.resolvedModules[moduleNameText] = resolvedModule;
     }
 
-    /** An older host may have omitted resolvedTsFileName and resolvedJsFileName, in which case we should infer them from the file extension of resolvedFileName. */
-    export function convertResolvedModuleFromHost(resolved: ResolvedModule | undefined): ResolvedModule | undefined {
-        if (resolved === undefined) {
-            return undefined;
-        }
-        // At least one of `resolevdTsFileName` or `resolvedJsFileName` should be defined.
-        else if (resolved.resolvedTsFileName || resolved.resolvedJsFileName) {
-            const { resolvedFileName, resolvedTsFileName, resolvedJsFileName } = resolved as ResolvedModule;
-            Debug.assert(resolvedFileName === (resolvedTsFileName || resolvedJsFileName));
-            return resolved;
-        }
-        else {
-            // For backwards compatibility, if both `resolvedTsFileName` and `resolvedJsFileName` are undefined, we infer one of them to define.
-            const { resolvedFileName, isExternalLibraryImport } = resolved;
-            if (fileExtensionIsAny(resolvedFileName, supportedTypeScriptExtensions)) {
-                return { resolvedFileName, resolvedTsFileName: resolvedFileName, resolvedJsFileName: undefined, isExternalLibraryImport };
-            }
-            else {
-                Debug.assert(fileExtensionIsAny(resolvedFileName, supportedJavascriptExtensions));
-                return { resolvedFileName, resolvedTsFileName: undefined, resolvedJsFileName: resolvedFileName, isExternalLibraryImport };
-            }
-        }
-    }
-
     export function setResolvedTypeReferenceDirective(sourceFile: SourceFile, typeReferenceDirectiveName: string, resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective): void {
         if (!sourceFile.resolvedTypeReferenceDirectiveNames) {
             sourceFile.resolvedTypeReferenceDirectiveNames = createMap<ResolvedTypeReferenceDirective>();
@@ -157,9 +133,39 @@ namespace ts {
      */
     export function moduleResolutionIsEqualTo(oldResolution: ResolvedModule, newResolution: ResolvedModule): boolean {
         return oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport &&
+            oldResolution.extension === newResolution.extension &&
             oldResolution.resolvedFileName === newResolution.resolvedFileName;
     }
 
+    /** True if an extension is one of the supported TypeScript extensions. */
+    export function extensionIsTypeScript(ext: Extension): boolean {
+        return ext <= Extension.LastTypeScriptExtension;
+    }
+
+    /**
+     * Gets the extension from a path.
+     * Path must have a valid extension.
+     */
+    export function extensionFromPath(path: string): Extension {
+        if (fileExtensionIs(path, ".d.ts")) {
+            return Extension.Dts;
+        }
+        if (fileExtensionIs(path, ".ts")) {
+            return Extension.Ts;
+        }
+        if (fileExtensionIs(path, ".tsx")) {
+            return Extension.Tsx;
+        }
+        if (fileExtensionIs(path, ".js")) {
+            return Extension.Js;
+        }
+        if (fileExtensionIs(path, ".jsx")) {
+            return Extension.Jsx;
+        }
+        Debug.fail(`File ${path} has unknown extension.`);
+        return Extension.Js;
+    }
+
     /* @internal */
     export function typeDirectiveIsEqualTo(oldResolution: ResolvedTypeReferenceDirective, newResolution: ResolvedTypeReferenceDirective): boolean {
         return oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.primary === newResolution.primary;