Remove "ResolvedModuleFromHost" type and just make resolvedTsFileName and resolvedJsFileName optional properties

(but still automatically infer one of them to supply if the host supplied neither)

Author: Andy Hanson

src/compiler/types.ts

@@ -3302,9 +3302,9 @@ namespace ts {
          */
         resolvedFileName: string;
         /** TypeScript (.d.ts, .ts, .tsx) file that the module was resolved to. This will be preferred over a JS file. */
-        resolvedTsFileName: string | undefined;
+        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 | undefined;
+        resolvedJsFileName?: string;
         /**
          * Denotes if 'resolvedFileName' is isExternalLibraryImport and thus should be a proper external module:
          * - be a .d.ts file
@@ -3314,13 +3314,6 @@ namespace ts {
         isExternalLibraryImport: boolean;
     }
 
-    /**
-     * For backwards compatibility, a host may choose not to return `resolvedTsFileName` and `resolvedJsFileName` from a result ResolvedModule,
-     * in which case they will be inferred from the file extension.
-     * Prefer to return a full ResolvedModule.
-     */
-    export type ResolvedModuleFromHost = { resolvedFileName: string; isExternalLibraryImport: boolean } | ResolvedModule;
-
     export interface ResolvedModuleWithFailedLookupLocations {
         resolvedModule: ResolvedModule | undefined;
         failedLookupLocations: string[];
@@ -3358,7 +3351,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): ResolvedModuleFromHost[];
+        resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
         /**
          * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
          */

src/compiler/utilities.ts

@@ -118,18 +118,19 @@ namespace ts {
         sourceFile.resolvedModules[moduleNameText] = resolvedModule;
     }
 
-    /** Host may have omitted resolvedTsFileName and resolvedJsFileName, in which case we should infer them from the file extension of resolvedFileName. */
-    export function convertResolvedModuleFromHost(resolved: ResolvedModuleFromHost | undefined): ResolvedModule | undefined {
+    /** 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;
         }
-        // `resolvedTsFileName` and `resolvedJsFileName` should be present as properties even if undefined.
-        else if ("resolvedTsFileName" in resolved) {
+        // 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 as ResolvedModule;
+            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 };