Set implied node format during source file creation

internal/ast/ast.go

@@ -8663,6 +8663,11 @@ type CommentDirective struct {
 
 // SourceFile
 
+type SourceFileMetaData struct {
+	PackageJsonType   string
+	ImpliedNodeFormat core.ResolutionMode
+}
+
 type SourceFile struct {
 	NodeBase
 	DeclarationBase
@@ -8723,7 +8728,6 @@ type SourceFile struct {
 
 	// !!!
 
-	ImpliedNodeFormat       core.ModuleKind
 	CommonJsModuleIndicator *Node
 	ExternalModuleIndicator *Node
 	JsGlobalAugmentations   SymbolTable
@@ -8808,7 +8812,6 @@ func (node *SourceFile) copyFrom(other *SourceFile) {
 	node.ReferencedFiles = other.ReferencedFiles
 	node.TypeReferenceDirectives = other.TypeReferenceDirectives
 	node.LibReferenceDirectives = other.LibReferenceDirectives
-	node.ImpliedNodeFormat = other.ImpliedNodeFormat
 	node.CommonJsModuleIndicator = other.CommonJsModuleIndicator
 	node.ExternalModuleIndicator = other.ExternalModuleIndicator
 	node.JsGlobalAugmentations = other.JsGlobalAugmentations

internal/ast/utilities.go

@@ -2354,27 +2354,40 @@ func IsDefaultImport(node *Node /*ImportDeclaration | ImportEqualsDeclaration |
 	return importClause != nil && importClause.AsImportClause().name != nil
 }
 
-func GetEmitModuleFormatOfFileWorker(sourceFile *SourceFile, options *core.CompilerOptions) core.ModuleKind {
-	result := GetImpliedNodeFormatForEmitWorker(sourceFile, options)
+func GetImpliedNodeFormatForFile(path string, packageJsonType string) core.ModuleKind {
+	impliedNodeFormat := core.ResolutionModeNone
+	if tspath.FileExtensionIsOneOf(path, []string{tspath.ExtensionDmts, tspath.ExtensionMts, tspath.ExtensionMjs}) {
+		impliedNodeFormat = core.ResolutionModeESM
+	} else if tspath.FileExtensionIsOneOf(path, []string{tspath.ExtensionDcts, tspath.ExtensionCts, tspath.ExtensionCjs}) {
+		impliedNodeFormat = core.ResolutionModeCommonJS
+	} else if packageJsonType != "" && tspath.FileExtensionIsOneOf(path, []string{tspath.ExtensionDts, tspath.ExtensionTs, tspath.ExtensionTsx, tspath.ExtensionJs, tspath.ExtensionJsx}) {
+		impliedNodeFormat = core.IfElse(packageJsonType == "module", core.ResolutionModeESM, core.ResolutionModeCommonJS)
+	}
+
+	return impliedNodeFormat
+}
+
+func GetEmitModuleFormatOfFileWorker(sourceFile *SourceFile, options *core.CompilerOptions, sourceFileMetaData *SourceFileMetaData) core.ModuleKind {
+	result := GetImpliedNodeFormatForEmitWorker(sourceFile.FileName(), options, sourceFileMetaData)
 	if result != core.ModuleKindNone {
 		return result
 	}
 	return options.GetEmitModuleKind()
 }
 
-func GetImpliedNodeFormatForEmitWorker(sourceFile *SourceFile, options *core.CompilerOptions) core.ResolutionMode {
+func GetImpliedNodeFormatForEmitWorker(fileName string, options *core.CompilerOptions, sourceFileMetaData *SourceFileMetaData) core.ModuleKind {
 	moduleKind := options.GetEmitModuleKind()
-	if core.ModuleKindNode16 <= moduleKind && moduleKind <= core.ModuleKindNodeNext {
-		return sourceFile.ImpliedNodeFormat
+	if core.ModuleKindNode16 <= moduleKind && moduleKind <= core.ModuleKindNodeNext && sourceFileMetaData != nil {
+		return sourceFileMetaData.ImpliedNodeFormat
 	}
-	if sourceFile.ImpliedNodeFormat == core.ModuleKindCommonJS &&
-		( /*sourceFile.packageJsonScope.contents.packageJsonContent.type == "commonjs" ||*/ // !!!
-		tspath.FileExtensionIsOneOf(sourceFile.FileName(), []string{tspath.ExtensionCjs, tspath.ExtensionCts})) {
+	if sourceFileMetaData != nil && sourceFileMetaData.ImpliedNodeFormat == core.ModuleKindCommonJS &&
+		(sourceFileMetaData.PackageJsonType != "module" ||
+			tspath.FileExtensionIsOneOf(fileName, []string{tspath.ExtensionCjs, tspath.ExtensionCts})) {
 		return core.ModuleKindCommonJS
 	}
-	if sourceFile.ImpliedNodeFormat == core.ModuleKindESNext &&
-		( /*sourceFile.packageJsonScope?.contents.packageJsonContent.type === "module" ||*/ // !!!
-		tspath.FileExtensionIsOneOf(sourceFile.fileName, []string{tspath.ExtensionMjs, tspath.ExtensionMts})) {
+	if sourceFileMetaData != nil && sourceFileMetaData.ImpliedNodeFormat == core.ModuleKindESNext &&
+		(sourceFileMetaData.PackageJsonType == "module" ||
+			tspath.FileExtensionIsOneOf(fileName, []string{tspath.ExtensionMjs, tspath.ExtensionMts})) {
 		return core.ModuleKindESNext
 	}
 	return core.ModuleKindNone

internal/checker/checker.go

@@ -514,6 +514,7 @@ type Program interface {
 	GetEmitModuleFormatOfFile(sourceFile *ast.SourceFile) core.ModuleKind
 	GetImpliedNodeFormatForEmit(sourceFile *ast.SourceFile) core.ModuleKind
 	GetResolvedModule(currentSourceFile *ast.SourceFile, moduleReference string) *ast.SourceFile
+	GetCachedSourceFileMetaData(path string) *ast.SourceFileMetaData
 }
 
 type Host interface{}

internal/checker/grammarchecks.go

@@ -1217,7 +1217,8 @@ func (c *Checker) checkGrammarForInOrForOfStatement(forInOrOfStatement *ast.ForI
 					}
 					switch c.moduleKind {
 					case core.ModuleKindNode16, core.ModuleKindNodeNext:
-						if sourceFile.ImpliedNodeFormat == core.ModuleKindCommonJS {
+						sourceFileMetaData := c.program.GetCachedSourceFileMetaData(string(sourceFile.Path()))
+						if sourceFileMetaData != nil && sourceFileMetaData.ImpliedNodeFormat == core.ModuleKindCommonJS {
 							c.diagnostics.Add(createDiagnosticForNode(forInOrOfStatement.AwaitModifier, diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level))
 							break
 						}
@@ -1719,7 +1720,8 @@ func (c *Checker) checkGrammarAwaitOrAwaitUsing(node *ast.Node) bool {
 				switch c.moduleKind {
 				case core.ModuleKindNode16,
 					core.ModuleKindNodeNext:
-					if sourceFile.ImpliedNodeFormat == core.ModuleKindCommonJS {
+					sourceFileMetaData := c.program.GetCachedSourceFileMetaData(string(sourceFile.Path()))
+					if sourceFileMetaData != nil && sourceFileMetaData.ImpliedNodeFormat == core.ModuleKindCommonJS {
 						if !spanCalculated {
 							span = scanner.GetRangeOfTokenAtPosition(sourceFile, node.Pos())
 						}

internal/compiler/emitHost.go

@@ -23,6 +23,7 @@ type EmitHost interface {
 	CommonSourceDirectory() string
 	IsEmitBlocked(file string) bool
 	WriteFile(fileName string, text string, writeByteOrderMark bool, relatedSourceFiles []*ast.SourceFile, data *WriteFileData) error
+	GetCachedSourceFileMetaData(path string) *ast.SourceFileMetaData
 	GetEmitResolver(file *ast.SourceFile, skipDiagnostics bool) printer.EmitResolver
 }
 
@@ -54,3 +55,7 @@ func (host *emitHost) GetEmitResolver(file *ast.SourceFile, skipDiagnostics bool
 	checker := host.program.GetTypeCheckerForFile(file)
 	return checker.GetEmitResolver(file, skipDiagnostics)
 }
+
+func (host *emitHost) GetCachedSourceFileMetaData(path string) *ast.SourceFileMetaData {
+	return host.program.GetCachedSourceFileMetaData(path)
+}

internal/compiler/emitter.go

@@ -20,15 +20,16 @@ const (
 )
 
 type emitter struct {
-	host               EmitHost
-	emitOnly           emitOnly
-	emittedFilesList   []string
-	emitterDiagnostics ast.DiagnosticsCollection
-	emitSkipped        bool
-	sourceMapDataList  []*sourceMapEmitResult
-	writer             printer.EmitTextWriter
-	paths              *outputPaths
-	sourceFile         *ast.SourceFile
+	host                EmitHost
+	emitOnly            emitOnly
+	emittedFilesList    []string
+	emitterDiagnostics  ast.DiagnosticsCollection
+	emitSkipped         bool
+	sourceMapDataList   []*sourceMapEmitResult
+	writer              printer.EmitTextWriter
+	paths               *outputPaths
+	sourceFile          *ast.SourceFile
+	sourcefileMetaDatas map[string]*ast.SourceFileMetaData
 }
 
 func (e *emitter) emit() {
@@ -105,6 +106,7 @@ func (e *emitter) emitJsFile(sourceFile *ast.SourceFile, jsFilePath string, sour
 	}
 
 	emitContext := printer.NewEmitContext()
+	emitContext.SetSourcefileMetaDatas(e.sourcefileMetaDatas)
 	for _, transformer := range e.getScriptTransformers(emitContext, sourceFile) {
 		sourceFile = transformer.TransformSourceFile(sourceFile)
 	}

internal/compiler/fileloader.go

@@ -23,6 +23,9 @@ type fileLoader struct {
 	resolvedModulesMutex sync.Mutex
 	resolvedModules      map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule]
 
+	sourceFileMetaDatasMutex sync.Mutex
+	sourceFileMetaDatas      map[string]*ast.SourceFileMetaData
+
 	mu                      sync.Mutex
 	wg                      core.WorkGroup
 	tasksByFileName         map[string]*parseTask
@@ -40,7 +43,7 @@ func processAllProgramFiles(
 	resolver *module.Resolver,
 	rootFiles []string,
 	libs []string,
-) (files []*ast.SourceFile, resolvedModules map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule]) {
+) (files []*ast.SourceFile, resolvedModules map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule], sourceFileMetaDatas map[string]*ast.SourceFileMetaData) {
 	supportedExtensions := tsoptions.GetSupportedExtensions(compilerOptions, nil /*extraFileExtensions*/)
 	loader := fileLoader{
 		host:               host,
@@ -76,7 +79,7 @@ func processAllProgramFiles(
 	}
 	loader.sortLibs(libFiles)
 
-	return append(libFiles, files...), loader.resolvedModules
+	return append(libFiles, files...), loader.resolvedModules, loader.sourceFileMetaDatas
 }
 
 func (p *fileLoader) addRootTasks(files []string, isLib bool) {
@@ -221,9 +224,31 @@ func (t *parseTask) start(loader *fileLoader) {
 	})
 }
 
+func (p *fileLoader) CacheSourceFileMetaData(path string) {
+	p.sourceFileMetaDatasMutex.Lock()
+	defer p.sourceFileMetaDatasMutex.Unlock()
+	if _, ok := p.sourceFileMetaDatas[path]; ok {
+		return
+	}
+
+	if p.sourceFileMetaDatas == nil {
+		p.sourceFileMetaDatas = make(map[string]*ast.SourceFileMetaData)
+	}
+
+	packageJsonType := p.resolver.GetPackageJsonTypeIfApplicable(path)
+	impliedNodeFormat := ast.GetImpliedNodeFormatForFile(path, packageJsonType)
+	metadata := &ast.SourceFileMetaData{
+		PackageJsonType:   packageJsonType,
+		ImpliedNodeFormat: impliedNodeFormat,
+	}
+
+	p.sourceFileMetaDatas[path] = metadata
+}
+
 func (p *fileLoader) parseSourceFile(fileName string) *ast.SourceFile {
 	path := tspath.ToPath(fileName, p.host.GetCurrentDirectory(), p.host.FS().UseCaseSensitiveFileNames())
 	sourceFile := p.host.GetSourceFile(fileName, path, p.compilerOptions.GetEmitScriptTarget())
+	p.CacheSourceFileMetaData(string(path))
 	return sourceFile
 }
 

internal/compiler/host.go

@@ -26,10 +26,11 @@ type FileInfo struct {
 var _ CompilerHost = (*compilerHost)(nil)
 
 type compilerHost struct {
-	options            *core.CompilerOptions
-	currentDirectory   string
-	fs                 vfs.FS
-	defaultLibraryPath string
+	options                  *core.CompilerOptions
+	currentDirectory         string
+	fs                       vfs.FS
+	defaultLibraryPath       string
+	pathToSourceFileMetaData map[string]*ast.SourceFileMetaData
 }
 
 func NewCompilerHost(options *core.CompilerOptions, currentDirectory string, fs vfs.FS, defaultLibraryPath string) CompilerHost {
@@ -38,6 +39,7 @@ func NewCompilerHost(options *core.CompilerOptions, currentDirectory string, fs
 	h.currentDirectory = currentDirectory
 	h.fs = fs
 	h.defaultLibraryPath = defaultLibraryPath
+	h.pathToSourceFileMetaData = make(map[string]*ast.SourceFileMetaData)
 	return h
 }
 
@@ -73,5 +75,6 @@ func (h *compilerHost) GetSourceFile(fileName string, path tspath.Path, language
 	if tspath.FileExtensionIs(fileName, tspath.ExtensionJson) {
 		return parser.ParseJSONText(fileName, path, text)
 	}
+
 	return parser.ParseSourceFile(fileName, path, text, languageVersion, scanner.JSDocParsingModeParseForTypeErrors)
 }

internal/compiler/module/resolver.go

@@ -145,6 +145,28 @@ func (r *Resolver) GetPackageScopeForPath(directory string) *packagejson.InfoCac
 	return (&resolutionState{compilerOptions: r.compilerOptions, resolver: r}).getPackageScopeForPath(directory)
 }
 
+func (r *Resolver) GetPackageJsonTypeIfApplicable(path string) string {
+	if tspath.FileExtensionIsOneOf(path, []string{".mts", ".cts", "mjs", "cjs"}) {
+		return ""
+	}
+
+	var moduleResolutionKind core.ModuleResolutionKind
+	if r.compilerOptions != nil {
+		moduleResolutionKind = r.compilerOptions.GetModuleResolutionKind()
+	}
+
+	var packageJsonType string
+	shouldLookupFromPackageJson := core.ModuleResolutionKindNode16 <= moduleResolutionKind && moduleResolutionKind <= core.ModuleResolutionKindNodeNext || strings.Contains(path, "/node_modules/")
+	if shouldLookupFromPackageJson {
+		packageJsonScope := r.GetPackageScopeForPath(tspath.GetDirectoryPath(path))
+		if packageJsonScope.Exists() {
+			packageJsonType, _ = packageJsonScope.Contents.Type.GetValue()
+		}
+	}
+
+	return packageJsonType
+}
+
 func (r *Resolver) ResolveTypeReferenceDirective(typeReferenceDirectiveName string, containingFile string, resolutionMode core.ResolutionMode, redirectedReference *ResolvedProjectReference) *ResolvedTypeReferenceDirective {
 	traceEnabled := r.traceEnabled()
 

internal/compiler/program.go

@@ -49,6 +49,8 @@ type Program struct {
 	files       []*ast.SourceFile
 	filesByPath map[tspath.Path]*ast.SourceFile
 
+	sourceFileMetaDatas map[string]*ast.SourceFileMetaData
+
 	// The below settings are to track if a .js file should be add to the program if loaded via searching under node_modules.
 	// This works as imported modules are discovered recursively in a depth first manner, specifically:
 	// - For each root file, findSourceFile is called.
@@ -65,13 +67,12 @@ type Program struct {
 	commonSourceDirectoryOnce sync.Once
 }
 
-var extensions = []string{".ts", ".tsx"}
-
 func NewProgram(options ProgramOptions) *Program {
 	p := &Program{}
 	p.programOptions = options
 	p.compilerOptions = options.Options
 	p.configFileParsingDiagnostics = slices.Clip(options.ConfigFileParsingDiagnostics)
+	p.sourceFileMetaDatas = make(map[string]*ast.SourceFileMetaData)
 	if p.compilerOptions == nil {
 		p.compilerOptions = &core.CompilerOptions{}
 	}
@@ -149,7 +150,7 @@ func NewProgram(options ProgramOptions) *Program {
 		}
 	}
 
-	p.files, p.resolvedModules = processAllProgramFiles(p.host, p.programOptions, p.compilerOptions, p.resolver, rootFiles, libs)
+	p.files, p.resolvedModules, p.sourceFileMetaDatas = processAllProgramFiles(p.host, p.programOptions, p.compilerOptions, p.resolver, rootFiles, libs)
 	p.filesByPath = make(map[tspath.Path]*ast.SourceFile, len(p.files))
 	for _, file := range p.files {
 		p.filesByPath[file.Path()] = file
@@ -406,16 +407,20 @@ func (p *Program) PrintSourceFileWithTypes() {
 	}
 }
 
+func (p *Program) GetCachedSourceFileMetaData(path string) *ast.SourceFileMetaData {
+	return p.sourceFileMetaDatas[path]
+}
+
 func (p *Program) GetEmitModuleFormatOfFile(sourceFile *ast.SourceFile) core.ModuleKind {
 	return p.GetEmitModuleFormatOfFileWorker(sourceFile, p.compilerOptions)
 }
 
 func (p *Program) GetEmitModuleFormatOfFileWorker(sourceFile *ast.SourceFile, options *core.CompilerOptions) core.ModuleKind {
-	return ast.GetEmitModuleFormatOfFileWorker(sourceFile, options)
+	return ast.GetEmitModuleFormatOfFileWorker(sourceFile, options, p.GetCachedSourceFileMetaData(sourceFile.FileName()))
 }
 
 func (p *Program) GetImpliedNodeFormatForEmit(sourceFile *ast.SourceFile) core.ResolutionMode {
-	return ast.GetImpliedNodeFormatForEmitWorker(sourceFile, p.compilerOptions)
+	return ast.GetImpliedNodeFormatForEmitWorker(sourceFile.FileName(), p.compilerOptions, p.GetCachedSourceFileMetaData(sourceFile.FileName()))
 }
 
 func (p *Program) CommonSourceDirectory() string {
@@ -535,11 +540,12 @@ func (p *Program) Emit(options *EmitOptions) *EmitResult {
 
 	for _, sourceFile := range sourceFiles {
 		emitter := &emitter{
-			host:              host,
-			emittedFilesList:  nil,
-			sourceMapDataList: nil,
-			writer:            nil,
-			sourceFile:        sourceFile,
+			host:                host,
+			emittedFilesList:    nil,
+			sourceMapDataList:   nil,
+			writer:              nil,
+			sourceFile:          sourceFile,
+			sourcefileMetaDatas: p.sourceFileMetaDatas,
 		}
 		emitters = append(emitters, emitter)
 		wg.Queue(func() {

internal/parser/parser.go

@@ -196,6 +196,7 @@ func (p *Parser) initializeState(fileName string, path tspath.Path, sourceText s
 	default:
 		p.contextFlags = ast.NodeFlagsNone
 	}
+
 	p.scanner.SetText(p.sourceText)
 	p.scanner.SetOnError(p.scanError)
 	p.scanner.SetScriptTarget(p.languageVersion)