Run trace tests with bundler and emit instrumentation

Author: andrewbranch

src/compiler/moduleNameResolver.ts

@@ -533,6 +533,20 @@ 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) {
@@ -1399,6 +1413,20 @@ 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;
@@ -2392,6 +2420,11 @@ export interface PackageJsonInfoContents {
  * @internal
  */
 export function getPackageScopeForPath(directory: string, state: ModuleResolutionState): PackageJsonInfo | undefined {
+    // @ts-ignore
+    globalThis.writeTraceFile?.({
+        call: "getPackageScopeForPath",
+        args: { directory },
+    });
     return forEachAncestorDirectoryStoppingAtGlobalCache(
         state.host,
         directory,

src/compiler/utilities.ts

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

src/testRunner/compilerRunner.ts

@@ -15,6 +15,10 @@ import * as Utils from "./_namespaces/Utils.js";
 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")}`;
+
 export const enum CompilerTestType {
     Conformance,
     Regressions,
@@ -246,6 +250,29 @@ class CompilerTest {
             tsConfigOptions.configFile!.fileName = tsConfigOptions.configFilePath;
         }
 
+        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())) {
+                this.harnessSettings.moduleResolution = "bundler";
+            }
+            // @ts-ignore
+            globalThis.writeTraceFile = json => require("fs").appendFileSync(globalThis.outputFile, JSON.stringify(json) + "\n", "utf8");
+            // @ts-ignore
+            globalThis.writeTraceFile({
+                test: this.configuredName,
+                files: units,
+            });
+        }
+
         this.result = Compiler.compileFiles(
             this.toBeCompiled,
             this.otherFiles,
@@ -255,6 +282,9 @@ class CompilerTest {
             testCaseContent.symlinks,
         );
 
+        // @ts-ignore
+        globalThis.writeTraceFile = () => {};
+
         this.options = this.result.options;
     }