Write resolutions to output

Author: andrewbranch

src/compiler/moduleNameResolver.ts

@@ -533,20 +533,6 @@ function getCandidateFromTypeRoot(typeRoot: string, typeReferenceDirectiveName:
  * is assumed to be the same as root directory of the project.
  */
 export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string | undefined, options: CompilerOptions, host: ModuleResolutionHost, redirectedReference?: ResolvedProjectReference, cache?: TypeReferenceDirectiveResolutionCache, resolutionMode?: ResolutionMode): ResolvedTypeReferenceDirectiveWithFailedLookupLocations {
-    // @ts-ignore
-    globalThis.writeTraceFile?.({
-        call: "resolveTypeReferenceDirective",
-        args: {
-            name: typeReferenceDirectiveName,
-            containingFile,
-            compilerOptions: options,
-            resolutionMode,
-            redirectedReference: redirectedReference && {
-                sourceFile: { fileName: redirectedReference.sourceFile.fileName },
-                commandLine: { options: redirectedReference.commandLine.options },
-            },
-        },
-    });
     Debug.assert(typeof typeReferenceDirectiveName === "string", "Non-string value passed to `ts.resolveTypeReferenceDirective`, likely by a wrapping package working with an outdated `resolveTypeReferenceDirectives` signature. This is probably not a problem in TS itself.");
     const traceEnabled = isTraceEnabled(options, host);
     if (redirectedReference) {
@@ -566,6 +552,21 @@ export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string
             trace(host, Diagnostics.Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1, typeReferenceDirectiveName, containingDirectory);
             traceResult(result);
         }
+        // @ts-ignore
+        globalThis.writeTraceFile?.({
+            call: "resolveTypeReferenceDirective",
+            args: {
+                name: typeReferenceDirectiveName,
+                containingFile,
+                compilerOptions: options,
+                resolutionMode,
+                redirectedReference: redirectedReference && {
+                    sourceFile: { fileName: redirectedReference.sourceFile.fileName },
+                    commandLine: { options: redirectedReference.commandLine.options },
+                },
+            },
+            return: result,
+        });
         return result;
     }
 
@@ -656,6 +657,21 @@ export function resolveTypeReferenceDirective(typeReferenceDirectiveName: string
         }
     }
     if (traceEnabled) traceResult(result);
+    // @ts-ignore
+    globalThis.writeTraceFile?.({
+        call: "resolveTypeReferenceDirective",
+        args: {
+            name: typeReferenceDirectiveName,
+            containingFile,
+            compilerOptions: options,
+            resolutionMode,
+            redirectedReference: redirectedReference && {
+                sourceFile: { fileName: redirectedReference.sourceFile.fileName },
+                commandLine: { options: redirectedReference.commandLine.options },
+            },
+        },
+        return: result,
+    });
     return result;
 
     function traceResult(result: ResolvedTypeReferenceDirectiveWithFailedLookupLocations) {
@@ -1413,20 +1429,6 @@ export function resolveModuleNameFromCache(moduleName: string, containingFile: s
 }
 
 export function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache, redirectedReference?: ResolvedProjectReference, resolutionMode?: ResolutionMode): ResolvedModuleWithFailedLookupLocations {
-    // @ts-ignore
-    globalThis.writeTraceFile?.({
-        call: "resolveModuleName",
-        args: {
-            name: moduleName,
-            containingFile,
-            compilerOptions,
-            resolutionMode,
-            redirectedReference: redirectedReference && {
-                sourceFile: { fileName: redirectedReference.sourceFile.fileName },
-                commandLine: { options: redirectedReference.commandLine.options },
-            },
-        },
-    });
     const traceEnabled = isTraceEnabled(compilerOptions, host);
     if (redirectedReference) {
         compilerOptions = redirectedReference.commandLine.options;
@@ -1502,6 +1504,24 @@ export function resolveModuleName(moduleName: string, containingFile: string, co
         }
     }
 
+    if (traceEnabled || !moduleName.startsWith("@typescript/")) {
+        // @ts-ignore
+        globalThis.writeTraceFile?.({
+            call: "resolveModuleName",
+            args: {
+                name: moduleName,
+                containingFile,
+                compilerOptions,
+                resolutionMode,
+                redirectedReference: redirectedReference && {
+                    sourceFile: { fileName: redirectedReference.sourceFile.fileName },
+                    commandLine: { options: redirectedReference.commandLine.options },
+                },
+            },
+            return: result,
+        });
+    }
+
     return result;
 }
 
@@ -2420,16 +2440,19 @@ export interface PackageJsonInfoContents {
  * @internal
  */
 export function getPackageScopeForPath(directory: string, state: ModuleResolutionState): PackageJsonInfo | undefined {
-    // @ts-ignore
-    globalThis.writeTraceFile?.({
-        call: "getPackageScopeForPath",
-        args: { directory },
-    });
-    return forEachAncestorDirectoryStoppingAtGlobalCache(
+    const result = forEachAncestorDirectoryStoppingAtGlobalCache(
         state.host,
         directory,
         dir => getPackageJsonInfo(dir, /*onlyRecordFailures*/ false, state),
     );
+    if (state.traceEnabled) {
+        // @ts-ignore
+        globalThis.writeTraceFile?.({
+            call: "getPackageScopeForPath",
+            args: { directory },
+        });
+    }
+    return result;
 }
 
 function getVersionPathsOfPackageJsonInfo(packageJsonInfo: PackageJsonInfo, state: ModuleResolutionState): VersionPaths | undefined {

src/compiler/utilities.ts

@@ -8936,7 +8936,7 @@ const _computedOptions = createComputedCompilerOptions({
         },
     },
     moduleResolution: {
-        dependencies: ["module", "target", "traceResolution"],
+        dependencies: ["module", "target"],
         computeValue: (compilerOptions): ModuleResolutionKind => {
             let moduleResolution = compilerOptions.moduleResolution;
             if (moduleResolution === undefined) {
@@ -8954,11 +8954,11 @@ const _computedOptions = createComputedCompilerOptions({
                         moduleResolution = ModuleResolutionKind.Bundler;
                         break;
                     default:
-                        moduleResolution = ModuleResolutionKind.Classic;
+                        moduleResolution = ModuleResolutionKind.Bundler;
                         break;
                 }
             }
-            if (moduleResolution === ModuleResolutionKind.Node10 && compilerOptions.traceResolution) {
+            if (moduleResolution === ModuleResolutionKind.Node10) {
                 moduleResolution = ModuleResolutionKind.Bundler;
             }
             return moduleResolution;

src/testRunner/compilerRunner.ts

@@ -16,8 +16,7 @@ import * as vfs from "./_namespaces/vfs.js";
 import * as vpath from "./_namespaces/vpath.js";
 
 require("fs").mkdirSync("trace-tests", { recursive: true });
-// @ts-ignore
-globalThis.outputFile = `trace-tests/${require("crypto").randomBytes(16).toString("hex")}`;
+const outputFile = `trace-tests/${require("crypto").randomBytes(16).toString("hex")}`;
 
 export const enum CompilerTestType {
     Conformance,
@@ -253,23 +252,17 @@ class CompilerTest {
         const traceResolution = tsConfigOptions?.traceResolution || this.harnessSettings.traceResolution;
         const baseUrl = tsConfigOptions?.baseUrl || this.harnessSettings.baseUrl;
         const rootDirs = tsConfigOptions?.rootDirs || this.harnessSettings.rootDirs;
-        const moduleResolution = tsConfigOptions?.moduleResolution || this.harnessSettings.moduleResolution;
-        if (
-            traceResolution
-            && !baseUrl
-            && !rootDirs
-            && moduleResolution !== ts.ModuleResolutionKind.Classic
-            && (`${moduleResolution}`.toLowerCase()) !== "classic"
-        ) {
-            if (moduleResolution === ts.ModuleResolutionKind.Node10 || ["node", "node10"].includes(("" + moduleResolution).toLowerCase())) {
+        if (!baseUrl && !rootDirs && units.length > 1 && units.some(unit => /import[\s(]|require\(|<reference/.test(unit.content))) {
+            if (["node", "node10"].includes(this.harnessSettings.moduleResolution?.toLowerCase())) {
                 this.harnessSettings.moduleResolution = "bundler";
             }
             // @ts-ignore
-            globalThis.writeTraceFile = json => require("fs").appendFileSync(globalThis.outputFile, JSON.stringify(json) + "\n", "utf8");
+            globalThis.writeTraceFile = json => require("fs").appendFileSync(outputFile, JSON.stringify(json) + "\n", "utf8");
             // @ts-ignore
             globalThis.writeTraceFile({
                 test: this.configuredName,
-                files: units,
+                trace: !!traceResolution,
+                files: units.map(unit => ({ name: unit.name, content: unit.name.endsWith("package.json") ? unit.content : "" })),
             });
         }