Proposal: compute module format based on package.json visible to declarationDir/outDir

src/compiler/diagnosticMessages.json

@@ -1659,6 +1659,10 @@
         "category": "Message",
         "code": 2212
     },
+    "The project root is ambiguous, but is required to determine the module format of output '.js' files. Supply the `rootDir` compiler option to disambiguate.": {
+        "category": "Error",
+        "code": 2213
+    },
 
     "Duplicate identifier '{0}'.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -596,7 +596,21 @@ export function getOutputDeclarationFileName(inputFileName: string, configFile:
     );
 }
 
-function getOutputJSFileName(inputFileName: string, configFile: ParsedCommandLine, ignoreCase: boolean, getCommonSourceDirectory?: () => string) {
+/** @internal */
+export function getOutputDeclarationFileNameWithoutConfigFile(inputFileName: string, options: CompilerOptions, ignoreCase: boolean, currentDirectory: string, getCommonSourceDirectory: () => string) {
+    const directory = (options.declarationDir || options.outDir) ? getNormalizedAbsolutePath(options.declarationDir || options.outDir!, currentDirectory) : undefined;
+    const outputPathWithoutChangedExtension = directory
+        ? resolvePath(directory, getRelativePathFromDirectory(getCommonSourceDirectory(), inputFileName, ignoreCase))
+        : inputFileName;
+    const outputFileName = changeExtension(
+        outputPathWithoutChangedExtension,
+        getDeclarationEmitExtensionForPath(inputFileName)
+    );
+    return outputFileName;
+}
+
+/** @internal */
+export function getOutputJSFileName(inputFileName: string, configFile: ParsedCommandLine, ignoreCase: boolean, getCommonSourceDirectory?: () => string) {
     if (configFile.options.emitDeclarationOnly) return undefined;
     const isJsonFile = fileExtensionIs(inputFileName, Extension.Json);
     const outputFileName = changeExtension(
@@ -608,6 +622,23 @@ function getOutputJSFileName(inputFileName: string, configFile: ParsedCommandLin
         undefined;
 }
 
+/** @internal */
+export function getOutputJSFileNameWithoutConfigFile(inputFileName: string, options: CompilerOptions, ignoreCase: boolean, currentDirectory: string, getCommonSourceDirectory: () => string) {
+    if (options.emitDeclarationOnly) return undefined;
+    const isJsonFile = fileExtensionIs(inputFileName, Extension.Json);
+    const outDir = options.outDir ? getNormalizedAbsolutePath(options.outDir, currentDirectory) : undefined;
+    const outputPathWithoutChangedExtension = outDir
+        ? resolvePath(outDir, getRelativePathFromDirectory(getCommonSourceDirectory(), inputFileName, ignoreCase))
+        : inputFileName;
+    const outputFileName = changeExtension(
+        outputPathWithoutChangedExtension,
+        getOutputExtension(inputFileName, options)
+    );
+    return !isJsonFile || !options.configFilePath || comparePaths(inputFileName, outputFileName, options.configFilePath, ignoreCase) !== Comparison.EqualTo ?
+        outputFileName :
+        undefined;
+}
+
 function createAddOutput() {
     let outputs: string[] | undefined;
     return { addOutput, getOutputs };

src/compiler/program.ts

@@ -134,6 +134,9 @@ import {
     getNormalizedAbsolutePathWithoutRoot,
     getNormalizedPathComponents,
     getOutputDeclarationFileName,
+    getOutputDeclarationFileNameWithoutConfigFile,
+    getOutputJSFileName,
+    getOutputJSFileNameWithoutConfigFile,
     getOutputPathsForBundle,
     getPackageScopeForPath,
     getPathFromPathComponents,
@@ -1336,6 +1339,16 @@ export function getImpliedNodeFormatForFileWorker(
     }
 }
 
+function moduleFormatNeedsPackageJsonLookup(fileName: string, options: CompilerOptions) {
+    switch (getEmitModuleResolutionKind(options)) {
+        case ModuleResolutionKind.Node16:
+        case ModuleResolutionKind.NodeNext:
+            return fileExtensionIsOneOf(fileName, [Extension.Dts, Extension.Ts, Extension.Tsx, Extension.Js, Extension.Jsx]);
+        default:
+            return false;
+    }
+}
+
 /** @internal */
 export const plainJSErrors: Set<number> = new Set([
     // binder errors
@@ -1491,6 +1504,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
     let files: SourceFile[];
     let symlinks: SymlinkCache | undefined;
     let commonSourceDirectory: string;
+    let assumedCommonSourceDirectory: string | undefined;
     let typeChecker: TypeChecker;
     let classifiableNames: Set<__String>;
     const ambientModuleNameToUnmodifiedFileName = new Map<string, string>();
@@ -2053,6 +2067,10 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         return commonSourceDirectory;
     }
 
+    function getAssumedCommonSourceDirectory() {
+        return commonSourceDirectory ?? (assumedCommonSourceDirectory ??= ts_getCommonSourceDirectory(options, () => rootNames, host.getCurrentDirectory(), getCanonicalFileName));
+    }
+
     function getClassifiableNames() {
         if (!classifiableNames) {
             // Initialize a checker so that all our files are bound.
@@ -2367,7 +2385,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         const seenPackageNames = new Map<string, SeenPackageName>();
 
         for (const oldSourceFile of oldSourceFiles) {
-            const sourceFileOptions = getCreateSourceFileOptions(oldSourceFile.fileName, moduleResolutionCache, host, options);
+            const sourceFileOptions = getCreateSourceFileOptions(oldSourceFile.fileName);
             let newSourceFile = host.getSourceFileByPath
                 ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, sourceFileOptions, /*onError*/ undefined, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat)
                 : host.getSourceFile(oldSourceFile.fileName, sourceFileOptions, /*onError*/ undefined, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat); // TODO: GH#18217
@@ -3508,11 +3526,58 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         return result;
     }
 
-    function getCreateSourceFileOptions(fileName: string, moduleResolutionCache: ModuleResolutionCache | undefined, host: CompilerHost, options: CompilerOptions): CreateSourceFileOptions {
+    function getImpliedNodeFormatForFile(fileName: string) {
+        // Map to an output file before looking up a package.json that might
+        // contain `"type": "module"`. This allows the same input `.ts` file to be
+        // compiled as both CommonJS and ESM depending on the tsconfig's `outDir`.
+        let fileNameForModuleFormatDetection = getNormalizedAbsolutePath(fileName, currentDirectory);
+        if (moduleFormatNeedsPackageJsonLookup(fileName, options)) {
+            const projectReference = getResolvedProjectReferenceToRedirect(fileName);
+            if (projectReference) {
+                // We have a source file that is an input to a referenced project.
+                // This should only happen with `useSourceOfProjectReferenceRedirect`
+                // enabled (i.e. TS Server scenarios).
+                Debug.assert(useSourceOfProjectReferenceRedirect);
+                fileNameForModuleFormatDetection =
+                    getOutputDeclarationFileName(
+                        fileNameForModuleFormatDetection,
+                        projectReference.commandLine,
+                        !host.useCaseSensitiveFileNames()) ||
+                    getOutputJSFileName(
+                        fileNameForModuleFormatDetection,
+                        projectReference.commandLine,
+                        !host.useCaseSensitiveFileNames()) ||
+                    fileNameForModuleFormatDetection;
+            }
+            else {
+                fileNameForModuleFormatDetection =
+                    getOutputDeclarationFileNameWithoutConfigFile(
+                        fileNameForModuleFormatDetection,
+                        options,
+                        !host.useCaseSensitiveFileNames(),
+                        currentDirectory,
+                        getAssumedCommonSourceDirectory) ||
+                    getOutputJSFileNameWithoutConfigFile(
+                        fileNameForModuleFormatDetection,
+                        options,
+                        !host.useCaseSensitiveFileNames(),
+                        currentDirectory,
+                        getAssumedCommonSourceDirectory) ||
+                    fileNameForModuleFormatDetection;
+            }
+        }
+        return getImpliedNodeFormatForFileWorker(
+            fileNameForModuleFormatDetection,
+            moduleResolutionCache?.getPackageJsonInfoCache(),
+            host,
+            options);
+    }
+
+    function getCreateSourceFileOptions(fileName: string): CreateSourceFileOptions {
         // It's a _little odd_ that we can't set `impliedNodeFormat` until the program step - but it's the first and only time we have a resolution cache
         // and a freshly made source file node on hand at the same time, and we need both to set the field. Persisting the resolution cache all the way
         // to the check and emit steps would be bad - so we much prefer detecting and storing the format information on the source file node upfront.
-        const result = getImpliedNodeFormatForFileWorker(getNormalizedAbsolutePath(fileName, currentDirectory), moduleResolutionCache?.getPackageJsonInfoCache(), host, options);
+        const result = getImpliedNodeFormatForFile(fileName);
         const languageVersion = getEmitScriptTarget(options);
         const setExternalModuleIndicator = getSetExternalModuleIndicator(options);
         return typeof result === "object" ?
@@ -3610,7 +3675,7 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
         }
 
         // We haven't looked for this file, do so now and cache result
-        const sourceFileOptions = getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options);
+        const sourceFileOptions = getCreateSourceFileOptions(fileName);
         const file = host.getSourceFile(
             fileName,
             sourceFileOptions,
@@ -4304,6 +4369,10 @@ export function createProgram(rootNamesOrOptions: readonly string[] | CreateProg
             }
         }
 
+        if (assumedCommonSourceDirectory && assumedCommonSourceDirectory !== getCommonSourceDirectory()) {
+            programDiagnostics.add(createCompilerDiagnostic(Diagnostics.The_project_root_is_ambiguous_but_is_required_to_determine_the_module_format_of_output_js_files_Supply_the_rootDir_compiler_option_to_disambiguate));
+        }
+
         if (options.useDefineForClassFields && languageVersion === ScriptTarget.ES3) {
             createDiagnosticForOptionName(Diagnostics.Option_0_cannot_be_specified_when_option_target_is_ES3, "useDefineForClassFields");
         }

src/testRunner/tests.ts

@@ -80,6 +80,7 @@ import "./unittests/tsbuild/lateBoundSymbol";
 import "./unittests/tsbuild/libraryResolution";
 import "./unittests/tsbuild/moduleResolution";
 import "./unittests/tsbuild/moduleSpecifiers";
+import "./unittests/tsbuild/nodeModulesOutDirPackageJson";
 import "./unittests/tsbuild/noEmit";
 import "./unittests/tsbuild/noEmitOnError";
 import "./unittests/tsbuild/outFile";

src/testRunner/unittests/tsbuild/nodeModulesOutDirPackageJson.ts

@@ -0,0 +1,33 @@
+import {
+    verifyTsc,
+} from "../helpers/tsc";
+import { loadProjectFromFiles } from "../helpers/vfs";
+
+describe("unittests:: tsbuild:: nodeModulesOutDirPackageJson", () => {
+    verifyTsc({
+        scenario: "nodeModulesOutDirPackageJson",
+        subScenario: "recognizes package.json in outDir of referenced project",
+        commandLineArgs: ["-b", "/src/tsconfig.json", "-v"],
+        fs: () => loadProjectFromFiles({
+            "/shared/tsconfig.json": JSON.stringify({
+                compilerOptions: {
+                    target: "es5",
+                    composite: true,
+                    outDir: "dist"
+                }
+            }),
+            "/shared/red.ts": "export const red = 'fish';",
+            "/shared/dist/package.json": JSON.stringify({ type: "module" }),
+
+            "/src/tsconfig.json": JSON.stringify({
+                compilerOptions: {
+                    target: "es5",
+                    module: "nodenext",
+                    noEmit: true,
+                },
+                references: [{ path: "../shared" }]
+            }),
+            "/src/index.ts": "import { red } from '../shared/red';",
+        }),
+    });
+});

tests/baselines/reference/nodeMOdulesOutDirPackageJson05_declarationDir.errors.txt

@@ -0,0 +1,26 @@
+/src/a.ts(1,19): error TS2835: Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean './b.js'?
+
+
+==== /tsconfig.json (0 errors) ====
+    {
+      "compilerOptions": {
+        "module": "nodenext",
+        "declaration": true,
+        "declarationDir": "out",
+        "emitDeclarationOnly": true,
+        "rootDir": "."
+      },
+      "include": ["src"]
+    }
+
+==== /src/a.ts (1 errors) ====
+    import { b } from "./b";
+                      ~~~~~
+!!! error TS2835: Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean './b.js'?
+
+==== /src/b.ts (0 errors) ====
+    export const b = 0;
+
+==== /out/package.json (0 errors) ====
+    { "type": "module" }
+

tests/baselines/reference/nodeMOdulesOutDirPackageJson05_declarationDir.js

@@ -0,0 +1,18 @@
+//// [tests/cases/conformance/node/nodeModulesOutDirPackageJson05_declarationDir.ts] ////
+
+//// [package.json]
+{ "type": "module" }
+
+//// [a.ts]
+import { b } from "./b";
+
+//// [b.ts]
+export const b = 0;
+
+
+
+
+//// [a.d.ts]
+export {};
+//// [b.d.ts]
+export declare const b = 0;

tests/baselines/reference/nodeMOdulesOutDirPackageJson05_declarationDir.symbols

@@ -0,0 +1,8 @@
+=== /src/a.ts ===
+import { b } from "./b";
+>b : Symbol(b, Decl(a.ts, 0, 8))
+
+=== /src/b.ts ===
+export const b = 0;
+>b : Symbol(b, Decl(b.ts, 0, 12))
+

tests/baselines/reference/nodeMOdulesOutDirPackageJson05_declarationDir.types

@@ -0,0 +1,9 @@
+=== /src/a.ts ===
+import { b } from "./b";
+>b : any
+
+=== /src/b.ts ===
+export const b = 0;
+>b : 0
+>0 : 0
+

tests/baselines/reference/nodeModulesOutDirPackageJson01.errors.txt

@@ -0,0 +1,14 @@
+/src/a.ts(1,19): error TS2835: Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean './b.js'?
+
+
+==== /out/package.json (0 errors) ====
+    { "type": "module" }
+
+==== /src/a.ts (1 errors) ====
+    import { b } from "./b";
+                      ~~~~~
+!!! error TS2835: Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean './b.js'?
+
+==== /src/b.ts (0 errors) ====
+    export const b = 0;
+

tests/baselines/reference/nodeModulesOutDirPackageJson01.js

@@ -0,0 +1,16 @@
+//// [tests/cases/conformance/node/nodeModulesOutDirPackageJson01.ts] ////
+
+//// [package.json]
+{ "type": "module" }
+
+//// [a.ts]
+import { b } from "./b";
+
+//// [b.ts]
+export const b = 0;
+
+
+//// [/out/a.js]
+export {};
+//// [/out/b.js]
+export var b = 0;

tests/baselines/reference/nodeModulesOutDirPackageJson01.symbols

@@ -0,0 +1,8 @@
+=== /src/a.ts ===
+import { b } from "./b";
+>b : Symbol(b, Decl(a.ts, 0, 8))
+
+=== /src/b.ts ===
+export const b = 0;
+>b : Symbol(b, Decl(b.ts, 0, 12))
+

tests/baselines/reference/nodeModulesOutDirPackageJson01.types

@@ -0,0 +1,9 @@
+=== /src/a.ts ===
+import { b } from "./b";
+>b : any
+
+=== /src/b.ts ===
+export const b = 0;
+>b : 0
+>0 : 0
+

tests/baselines/reference/nodeModulesOutDirPackageJson02_tsconfig.errors.txt

@@ -0,0 +1,22 @@
+/src/a.ts(1,19): error TS2835: Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean './b.js'?
+
+
+==== /tsconfig.json (0 errors) ====
+    {
+      "compilerOptions": {
+        "module": "nodenext",
+        "outDir": "out"
+      }
+    }
+
+==== /src/a.ts (1 errors) ====
+    import { b } from "./b";
+                      ~~~~~
+!!! error TS2835: Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean './b.js'?
+
+==== /src/b.ts (0 errors) ====
+    export const b = 0;
+
+==== /out/package.json (0 errors) ====
+    { "type": "module" }
+

tests/baselines/reference/nodeModulesOutDirPackageJson02_tsconfig.js

@@ -0,0 +1,16 @@
+//// [tests/cases/conformance/node/nodeModulesOutDirPackageJson02_tsconfig.ts] ////
+
+//// [package.json]
+{ "type": "module" }
+
+//// [a.ts]
+import { b } from "./b";
+
+//// [b.ts]
+export const b = 0;
+
+
+//// [/out/a.js]
+export {};
+//// [/out/b.js]
+export const b = 0;