Set implied node format during source file creation

internal/ast/ast.go

@@ -8666,6 +8666,11 @@ type CommentDirective struct {
 
 // SourceFile
 
+type SourceFileMetaData struct {
+	PackageJsonType   string
+	ImpliedNodeFormat core.ResolutionMode
+}
+
 type SourceFile struct {
 	NodeBase
 	DeclarationBase
@@ -8726,7 +8731,6 @@ type SourceFile struct {
 
 	// !!!
 
-	ImpliedNodeFormat       core.ModuleKind
 	CommonJsModuleIndicator *Node
 	ExternalModuleIndicator *Node
 	JsGlobalAugmentations   SymbolTable
@@ -8811,7 +8815,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
+	GetCachedSourceFileMetaDatas() map[tspath.Path]*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.GetCachedSourceFileMetaDatas()[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.GetCachedSourceFileMetaDatas()[sourceFile.Path()]
+					if sourceFileMetaData != nil && sourceFileMetaData.ImpliedNodeFormat == core.ModuleKindCommonJS {
 						if !spanCalculated {
 							span = scanner.GetRangeOfTokenAtPosition(sourceFile, node.Pos())
 						}

internal/compiler/emitHost.go

@@ -4,6 +4,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/printer"
+	"github.com/microsoft/typescript-go/internal/tspath"
 )
 
 type WriteFileData struct {
@@ -23,6 +24,7 @@ type EmitHost interface {
 	CommonSourceDirectory() string
 	IsEmitBlocked(file string) bool
 	WriteFile(fileName string, text string, writeByteOrderMark bool, relatedSourceFiles []*ast.SourceFile, data *WriteFileData) error
+	GetCachedSourceFileMetaDatas() map[tspath.Path]*ast.SourceFileMetaData
 	GetEmitResolver(file *ast.SourceFile, skipDiagnostics bool) printer.EmitResolver
 }
 
@@ -54,3 +56,7 @@ func (host *emitHost) GetEmitResolver(file *ast.SourceFile, skipDiagnostics bool
 	checker := host.program.GetTypeCheckerForFile(file)
 	return checker.GetEmitResolver(file, skipDiagnostics)
 }
+
+func (host *emitHost) GetCachedSourceFileMetaDatas() map[tspath.Path]*ast.SourceFileMetaData {
+	return host.program.GetCachedSourceFileMetaDatas()
+}

internal/compiler/emitter.go

@@ -105,6 +105,7 @@ func (e *emitter) emitJsFile(sourceFile *ast.SourceFile, jsFilePath string, sour
 	}
 
 	emitContext := printer.NewEmitContext()
+	emitContext.SetSourcefileMetaDatas(e.host.GetCachedSourceFileMetaDatas())
 	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[tspath.Path]*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[tspath.Path]*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 tspath.Path) {
+	p.sourceFileMetaDatasMutex.Lock()
+	defer p.sourceFileMetaDatasMutex.Unlock()
+	if _, ok := p.sourceFileMetaDatas[path]; ok {
+		return
+	}
+
+	if p.sourceFileMetaDatas == nil {
+		p.sourceFileMetaDatas = make(map[tspath.Path]*ast.SourceFileMetaData)
+	}
+
+	packageJsonType := p.resolver.GetPackageJsonTypeIfApplicable(string(path))
+	impliedNodeFormat := ast.GetImpliedNodeFormatForFile(string(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(path)
 	return sourceFile
 }
 

internal/compiler/host.go

@@ -73,5 +73,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{tspath.ExtensionMts, tspath.ExtensionCts, tspath.ExtensionMjs, tspath.ExtensionCjs}) {
+		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[tspath.Path]*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.
@@ -68,13 +70,12 @@ type Program struct {
 	unsupportedExtensions []string
 }
 
-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[tspath.Path]*ast.SourceFileMetaData)
 	if p.compilerOptions == nil {
 		p.compilerOptions = &core.CompilerOptions{}
 	}
@@ -152,7 +153,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
@@ -416,16 +417,20 @@ func (p *Program) PrintSourceFileWithTypes() {
 	}
 }
 
+func (p *Program) GetCachedSourceFileMetaDatas() map[tspath.Path]*ast.SourceFileMetaData {
+	return p.sourceFileMetaDatas
+}
+
 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.GetCachedSourceFileMetaDatas()[sourceFile.Path()])
 }
 
 func (p *Program) GetImpliedNodeFormatForEmit(sourceFile *ast.SourceFile) core.ResolutionMode {
-	return ast.GetImpliedNodeFormatForEmitWorker(sourceFile, p.compilerOptions)
+	return ast.GetImpliedNodeFormatForEmitWorker(sourceFile.FileName(), p.compilerOptions, p.GetCachedSourceFileMetaDatas()[sourceFile.Path()])
 }
 
 func (p *Program) CommonSourceDirectory() string {

internal/parser/parser.go

@@ -198,6 +198,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)

internal/printer/emitcontext.go

@@ -10,20 +10,22 @@ import (
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/collections"
 	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/tspath"
 )
 
 // Stores side-table information used during transformation that can be read by the printer to customize emit
 //
 // NOTE: EmitContext is not guaranteed to be thread-safe.
 type EmitContext struct {
-	Factory       *ast.NodeFactory // Required. The NodeFactory to use to create new nodes
-	autoGenerate  map[*ast.MemberName]*AutoGenerateInfo
-	textSource    map[*ast.StringLiteralNode]*ast.Node
-	original      map[*ast.Node]*ast.Node
-	emitNodes     core.LinkStore[*ast.Node, emitNode]
-	varScopeStack core.Stack[*varScope]
-	letScopeStack core.Stack[*varScope]
-	emitHelpers   collections.OrderedSet[*EmitHelper]
+	Factory             *ast.NodeFactory // Required. The NodeFactory to use to create new nodes
+	autoGenerate        map[*ast.MemberName]*AutoGenerateInfo
+	textSource          map[*ast.StringLiteralNode]*ast.Node
+	original            map[*ast.Node]*ast.Node
+	emitNodes           core.LinkStore[*ast.Node, emitNode]
+	varScopeStack       core.Stack[*varScope]
+	letScopeStack       core.Stack[*varScope]
+	emitHelpers         collections.OrderedSet[*EmitHelper]
+	sourceFileMetaDatas map[tspath.Path]*ast.SourceFileMetaData
 
 	isCustomPrologue           func(node *ast.Statement) bool
 	isHoistedFunction          func(node *ast.Statement) bool
@@ -625,6 +627,10 @@ func (c *EmitContext) NewRewriteRelativeImportExtensionsHelper(firstArgument *as
 	)
 }
 
+func (c *EmitContext) SetSourcefileMetaDatas(sourceFileMetaDatas map[tspath.Path]*ast.SourceFileMetaData) {
+	c.sourceFileMetaDatas = sourceFileMetaDatas
+}
+
 //
 // Original Node Tracking
 //
@@ -949,3 +955,16 @@ func (c *EmitContext) VisitIterationBody(body *ast.Statement, visitor *ast.NodeV
 
 	return updated
 }
+
+func (c *EmitContext) GetSourceFileMetaData(file *ast.SourceFile) *ast.SourceFileMetaData {
+	for {
+		if meta, ok := c.sourceFileMetaDatas[file.Path()]; ok {
+			return meta
+		}
+		original := c.Original(file.AsNode())
+		if original == nil || !ast.IsSourceFile(original) {
+			return nil
+		}
+		file = original.AsSourceFile()
+	}
+}

internal/testutil/harnessutil/harnessutil.go

@@ -399,6 +399,7 @@ func (h *cachedCompilerHost) GetSourceFile(fileName string, path tspath.Path, la
 		fileName        string
 		path            tspath.Path
 		languageVersion core.ScriptTarget
+		packageJsonType string
 		text            string
 	}
 

internal/transformers/commonjsmodule.go

@@ -1680,7 +1680,7 @@ func (tx *CommonJSModuleTransformer) visitCallExpression(node *ast.CallExpressio
 
 func (tx *CommonJSModuleTransformer) shouldTransformImportCall() bool {
 	// !!! host.shouldTransformImportCall?
-	return shouldTransformImportCallWorker(tx.currentSourceFile, tx.compilerOptions)
+	return shouldTransformImportCallWorker(tx.currentSourceFile, tx.compilerOptions, tx.emitContext.GetSourceFileMetaData(tx.currentSourceFile))
 }
 
 func (tx *CommonJSModuleTransformer) visitImportCallExpression(node *ast.CallExpression, rewriteOrShim bool) *ast.Node {
@@ -1997,10 +1997,10 @@ func (tx *CommonJSModuleTransformer) getExports(name *ast.IdentifierNode) []*ast
 	return nil
 }
 
-func shouldTransformImportCallWorker(sourceFile *ast.SourceFile, options *core.CompilerOptions) bool {
+func shouldTransformImportCallWorker(sourceFile *ast.SourceFile, options *core.CompilerOptions, sourceFileMetaData *ast.SourceFileMetaData) bool {
 	moduleKind := options.GetEmitModuleKind()
 	if core.ModuleKindNode16 <= moduleKind && moduleKind <= core.ModuleKindNodeNext || moduleKind == core.ModuleKindPreserve {
 		return false
 	}
-	return ast.GetEmitModuleFormatOfFileWorker(sourceFile, options) < core.ModuleKindES2015
+	return ast.GetEmitModuleFormatOfFileWorker(sourceFile, options, sourceFileMetaData) < core.ModuleKindES2015
 }