From 660bf60cca534e1cf58d0fb052d234ac040d2d77 Mon Sep 17 00:00:00 2001
From: Andrew Branch <andrew@wheream.io>
Date: Mon, 26 Jun 2023 11:45:35 -0700
Subject: [PATCH] Make module, not moduleResolution, the trigger for setting
 impliedNodeFormat

---
 src/compiler/checker.ts | 3 ++-
 src/compiler/parser.ts  | 2 +-
 src/compiler/program.ts | 8 ++++----
 3 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index ee86ae50306..17023803055 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4883,6 +4883,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 (isLiteralImportTypeNode(location) ? location : undefined)?.argument.literal;
         const mode = contextSpecifier && isStringLiteralLike(contextSpecifier) ? getModeForUsageLocation(currentSourceFile, contextSpecifier) : currentSourceFile.impliedNodeFormat;
         const moduleResolutionKind = getEmitModuleResolutionKind(compilerOptions);
+        const moduleKind = getEmitModuleKind(compilerOptions);
         const resolvedModule = getResolvedModule(currentSourceFile, moduleReference, mode);
         const resolutionDiagnostic = resolvedModule && getResolutionDiagnostic(compilerOptions, resolvedModule, currentSourceFile);
         const sourceFile = resolvedModule
@@ -4914,7 +4915,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 if (resolvedModule.isExternalLibraryImport && !resolutionExtensionIsTSOrJson(resolvedModule.extension)) {
                     errorOnImplicitAnyModule(/*isError*/ false, errorNode, currentSourceFile, mode, resolvedModule, moduleReference);
                 }
-                if (moduleResolutionKind === ModuleResolutionKind.Node16 || moduleResolutionKind === ModuleResolutionKind.NodeNext) {
+                if (ModuleKind.Node16 <= moduleKind && moduleKind <= ModuleKind.NodeNext) {
                     const isSyncImport = (currentSourceFile.impliedNodeFormat === ModuleKind.CommonJS && !findAncestor(location, isImportCall)) || !!findAncestor(location, isImportEqualsDeclaration);
                     const overrideClauseHost = findAncestor(location, l => isImportTypeNode(l) || isExportDeclaration(l) || isImportDeclaration(l)) as ImportTypeNode | ImportDeclaration | ExportDeclaration | undefined;
                     const overrideClause = overrideClauseHost && isImportTypeNode(overrideClauseHost) ? overrideClauseHost.assertions?.assertClause : overrideClauseHost?.assertClause;
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 436fb04ef2b..c2bf3bb69c6 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -1310,7 +1310,7 @@ export interface CreateSourceFileOptions {
     /**
      * Controls the format the file is detected as - this can be derived from only the path
      * and files on disk, but needs to be done with a module resolution cache in scope to be performant.
-     * This is usually `undefined` for compilations that do not have `moduleResolution` values of `node16` or `nodenext`.
+     * This is usually `undefined` for compilations that do not have `module` values of `node16` or `nodenext`.
      */
     impliedNodeFormat?: ResolutionMode;
     /**
diff --git a/src/compiler/program.ts b/src/compiler/program.ts
index a61e46e3565..29ead379c8b 100644
--- a/src/compiler/program.ts
+++ b/src/compiler/program.ts
@@ -883,7 +883,7 @@ export function isExclusivelyTypeOnlyImportOrExport(decl: ImportDeclaration | Ex
  * Calculates the final resolution mode for a given module reference node. This is generally the explicitly provided resolution mode, if
  * one exists, or the mode of the containing source file. (Excepting import=require, which is always commonjs, and dynamic import, which is always esm).
  * Notably, this function always returns `undefined` if the containing file has an `undefined` `impliedNodeFormat` - this field is only set when
- * `moduleResolution` is `node16`+.
+ * `module` is `node16`+.
  * @param file The file the import or import-like reference is contained within
  * @param usage The module reference string
  * @returns The final resolution mode of the import
@@ -1315,9 +1315,9 @@ export function getImpliedNodeFormatForFileWorker(
     host: ModuleResolutionHost,
     options: CompilerOptions,
 ) {
-    switch (getEmitModuleResolutionKind(options)) {
-        case ModuleResolutionKind.Node16:
-        case ModuleResolutionKind.NodeNext:
+    switch (getEmitModuleKind(options)) {
+        case ModuleKind.Node16:
+        case ModuleKind.NodeNext:
             return fileExtensionIsOneOf(fileName, [Extension.Dmts, Extension.Mts, Extension.Mjs]) ? ModuleKind.ESNext :
                 fileExtensionIsOneOf(fileName, [Extension.Dcts, Extension.Cts, Extension.Cjs]) ? ModuleKind.CommonJS :
                 fileExtensionIsOneOf(fileName, [Extension.Dts, Extension.Ts, Extension.Tsx, Extension.Js, Extension.Jsx]) ? lookupFromPackageJson() :