Handle synthetic tslib and JSX factory imports (microsoft#780)

Author: jakebailey

internal/ast/utilities.go

@@ -1184,6 +1184,10 @@ func WalkUpBindingElementsAndPatterns(binding *Node) *Node {
 	return node.Parent
 }
 
+func IsSourceFileJS(file *SourceFile) bool {
+	return file.ScriptKind == core.ScriptKindJS || file.ScriptKind == core.ScriptKindJSX
+}
+
 func IsInJSFile(node *Node) bool {
 	return node != nil && node.Flags&NodeFlagsJavaScriptFile != 0
 }
@@ -2585,3 +2589,53 @@ func IsRequireCall(node *Node, requireStringLiteralLikeArgument bool) bool {
 func IsUnterminatedLiteral(node *Node) bool {
 	return node.LiteralLikeData().TokenFlags&TokenFlagsUnterminated != 0
 }
+
+func GetJSXImplicitImportBase(compilerOptions *core.CompilerOptions, file *SourceFile) string {
+	jsxImportSourcePragma := getPragmaFromSourceFile(file, "jsximportsource")
+	jsxRuntimePragma := getPragmaFromSourceFile(file, "jsxruntime")
+	if getPragmaArgument(jsxRuntimePragma, "factory") == "classic" {
+		return ""
+	}
+	if compilerOptions.Jsx == core.JsxEmitReactJSX ||
+		compilerOptions.Jsx == core.JsxEmitReactJSXDev ||
+		compilerOptions.JsxImportSource != "" ||
+		jsxImportSourcePragma != nil ||
+		getPragmaArgument(jsxRuntimePragma, "factory") == "automatic" {
+		result := getPragmaArgument(jsxImportSourcePragma, "factory")
+		if result == "" {
+			result = compilerOptions.JsxImportSource
+		}
+		if result == "" {
+			result = "react"
+		}
+		return result
+	}
+	return ""
+}
+
+func GetJSXRuntimeImport(base string, options *core.CompilerOptions) string {
+	if base == "" {
+		return base
+	}
+	return base + "/" + core.IfElse(options.Jsx == core.JsxEmitReactJSXDev, "jsx-dev-runtime", "jsx-runtime")
+}
+
+func getPragmaFromSourceFile(file *SourceFile, name string) *Pragma {
+	if file != nil {
+		for i := range file.Pragmas {
+			if file.Pragmas[i].Name == name {
+				return &file.Pragmas[i]
+			}
+		}
+	}
+	return nil
+}
+
+func getPragmaArgument(pragma *Pragma, name string) string {
+	if pragma != nil {
+		if arg, ok := pragma.Args[name]; ok {
+			return arg.Value
+		}
+	}
+	return ""
+}

internal/checker/checker.go

@@ -525,6 +525,8 @@ type Program interface {
 	GetImpliedNodeFormatForEmit(sourceFile *ast.SourceFile) core.ModuleKind
 	GetResolvedModule(currentSourceFile *ast.SourceFile, moduleReference string) *ast.SourceFile
 	GetSourceFileMetaData(path tspath.Path) *ast.SourceFileMetaData
+	GetJSXRuntimeImportSpecifier(path tspath.Path) (moduleReference string, specifier *ast.Node)
+	GetImportHelpersImportSpecifier(path tspath.Path) *ast.Node
 }
 
 type Host interface{}

internal/checker/jsx.go

@@ -1246,13 +1246,13 @@ func (c *Checker) getJsxNamespaceContainerForImplicitImport(location *ast.Node)
 	if links != nil && links.jsxImplicitImportContainer != nil {
 		return core.IfElse(links.jsxImplicitImportContainer == c.unknownSymbol, nil, links.jsxImplicitImportContainer)
 	}
-	runtimeImportSpecifier := getJSXRuntimeImport(getJSXImplicitImportBase(c.compilerOptions, file), c.compilerOptions)
-	if runtimeImportSpecifier == "" {
+
+	moduleReference, specifier := c.getJSXRuntimeImportSpecifier(file)
+	if moduleReference == "" {
 		return nil
 	}
 	errorMessage := diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed
-	specifier := c.getJSXRuntimeImportSpecifier(file, runtimeImportSpecifier)
-	mod := c.resolveExternalModule(core.OrElse(specifier, location), runtimeImportSpecifier, errorMessage, location, false)
+	mod := c.resolveExternalModule(core.OrElse(specifier, location), moduleReference, errorMessage, location, false)
 	var result *ast.Symbol
 	if mod != nil && mod != c.unknownSymbol {
 		result = c.getMergedSymbol(c.resolveSymbol(mod))
@@ -1263,45 +1263,8 @@ func (c *Checker) getJsxNamespaceContainerForImplicitImport(location *ast.Node)
 	return result
 }
 
-func (c *Checker) getJSXRuntimeImportSpecifier(file *ast.SourceFile, specifierText string) *ast.Node {
-	// Synthesized JSX import is either first or after tslib
-	jsxImportIndex := core.IfElse(c.compilerOptions.ImportHelpers.IsTrue(), 1, 0)
-	if jsxImportIndex >= len(file.Imports) {
-		return nil
-	}
-	specifier := file.Imports[jsxImportIndex]
-	// Debug.assert(nodeIsSynthesized(specifier) && specifier.Text == specifierText, __TEMPLATE__("Expected sourceFile.imports[", jsxImportIndex, "] to be the synthesized JSX runtime import"))
-	return specifier
-}
-
-func getJSXImplicitImportBase(compilerOptions *core.CompilerOptions, file *ast.SourceFile) string {
-	jsxImportSourcePragma := getPragmaFromSourceFile(file, "jsximportsource")
-	jsxRuntimePragma := getPragmaFromSourceFile(file, "jsxruntime")
-	if getPragmaArgument(jsxRuntimePragma, "factory") == "classic" {
-		return ""
-	}
-	if compilerOptions.Jsx == core.JsxEmitReactJSX ||
-		compilerOptions.Jsx == core.JsxEmitReactJSXDev ||
-		compilerOptions.JsxImportSource != "" ||
-		jsxImportSourcePragma != nil ||
-		getPragmaArgument(jsxRuntimePragma, "factory") == "automatic" {
-		result := getPragmaArgument(jsxImportSourcePragma, "factory")
-		if result == "" {
-			result = compilerOptions.JsxImportSource
-		}
-		if result == "" {
-			result = "react"
-		}
-		return result
-	}
-	return ""
-}
-
-func getJSXRuntimeImport(base string, options *core.CompilerOptions) string {
-	if base == "" {
-		return base
-	}
-	return base + "/" + core.IfElse(options.Jsx == core.JsxEmitReactJSXDev, "jsx-dev-runtime", "jsx-runtime")
+func (c *Checker) getJSXRuntimeImportSpecifier(file *ast.SourceFile) (moduleReference string, specifier *ast.Node) {
+	return c.program.GetJSXRuntimeImportSpecifier(file.Path())
 }
 
 func getPragmaFromSourceFile(file *ast.SourceFile, name string) *ast.Pragma {

internal/compiler/fileloader.go

@@ -5,6 +5,7 @@ import (
 	"iter"
 	"slices"
 	"strings"
+	"sync"
 	"sync/atomic"
 
 	"github.com/microsoft/typescript-go/internal/ast"
@@ -30,12 +31,22 @@ type fileLoader struct {
 
 	totalFileCount atomic.Int32
 	libFileCount   atomic.Int32
+
+	factoryMu sync.Mutex
+	factory   ast.NodeFactory
 }
 
 type processedFiles struct {
-	files               []*ast.SourceFile
-	resolvedModules     map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule]
-	sourceFileMetaDatas map[tspath.Path]*ast.SourceFileMetaData
+	files                         []*ast.SourceFile
+	resolvedModules               map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule]
+	sourceFileMetaDatas           map[tspath.Path]*ast.SourceFileMetaData
+	jsxRuntimeImportSpecifiers    map[tspath.Path]*jsxRuntimeImportSpecifier
+	importHelpersImportSpecifiers map[tspath.Path]*ast.Node
+}
+
+type jsxRuntimeImportSpecifier struct {
+	moduleReference string
+	specifier       *ast.Node
 }
 
 func processAllProgramFiles(
@@ -78,6 +89,8 @@ func processAllProgramFiles(
 
 	resolvedModules := make(map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule], totalFileCount)
 	sourceFileMetaDatas := make(map[tspath.Path]*ast.SourceFileMetaData, totalFileCount)
+	var jsxRuntimeImportSpecifiers map[tspath.Path]*jsxRuntimeImportSpecifier
+	var importHelpersImportSpecifiers map[tspath.Path]*ast.Node
 
 	for task := range loader.collectTasks(loader.rootTasks) {
 		file := task.file
@@ -89,15 +102,29 @@ func processAllProgramFiles(
 		path := file.Path()
 		resolvedModules[path] = task.resolutionsInFile
 		sourceFileMetaDatas[path] = task.metadata
+		if task.jsxRuntimeImportSpecifier != nil {
+			if jsxRuntimeImportSpecifiers == nil {
+				jsxRuntimeImportSpecifiers = make(map[tspath.Path]*jsxRuntimeImportSpecifier, totalFileCount)
+			}
+			jsxRuntimeImportSpecifiers[path] = task.jsxRuntimeImportSpecifier
+		}
+		if task.importHelpersImportSpecifier != nil {
+			if importHelpersImportSpecifiers == nil {
+				importHelpersImportSpecifiers = make(map[tspath.Path]*ast.Node, totalFileCount)
+			}
+			importHelpersImportSpecifiers[path] = task.importHelpersImportSpecifier
+		}
 	}
 	loader.sortLibs(libFiles)
 
 	allFiles := append(libFiles, files...)
 
 	return processedFiles{
-		files:               allFiles,
-		resolvedModules:     resolvedModules,
-		sourceFileMetaDatas: sourceFileMetaDatas,
+		files:                         allFiles,
+		resolvedModules:               resolvedModules,
+		sourceFileMetaDatas:           sourceFileMetaDatas,
+		jsxRuntimeImportSpecifiers:    jsxRuntimeImportSpecifiers,
+		importHelpersImportSpecifiers: importHelpersImportSpecifiers,
 	}
 }
 
@@ -203,8 +230,10 @@ type parseTask struct {
 	isLib              bool
 	subTasks           []*parseTask
 
-	metadata          *ast.SourceFileMetaData
-	resolutionsInFile module.ModeAwareCache[*module.ResolvedModule]
+	metadata                     *ast.SourceFileMetaData
+	resolutionsInFile            module.ModeAwareCache[*module.ResolvedModule]
+	importHelpersImportSpecifier *ast.Node
+	jsxRuntimeImportSpecifier    *jsxRuntimeImportSpecifier
 }
 
 func (t *parseTask) start(loader *fileLoader) {
@@ -245,12 +274,14 @@ func (t *parseTask) start(loader *fileLoader) {
 			}
 		}
 
-		importsAndAugmentations, resolutionsInFile := loader.resolveImportsAndModuleAugmentations(file)
-		for _, imp := range importsAndAugmentations {
+		toParse, resolutionsInFile, importHelpersImportSpecifier, jsxRuntimeImportSpecifier := loader.resolveImportsAndModuleAugmentations(file)
+		for _, imp := range toParse {
 			t.addSubTask(imp, false)
 		}
 
 		t.resolutionsInFile = resolutionsInFile
+		t.importHelpersImportSpecifier = importHelpersImportSpecifier
+		t.jsxRuntimeImportSpecifier = jsxRuntimeImportSpecifier
 
 		loader.startTasks(t.subTasks)
 	})
@@ -286,13 +317,50 @@ func (p *fileLoader) resolveTripleslashPathReference(moduleName string, containi
 	return tspath.NormalizePath(referencedFileName)
 }
 
-func (p *fileLoader) resolveImportsAndModuleAugmentations(file *ast.SourceFile) ([]string, module.ModeAwareCache[*module.ResolvedModule]) {
-	if len(file.Imports) > 0 || len(file.ModuleAugmentations) > 0 {
-		toParse := make([]string, 0, len(file.Imports))
-		moduleNames := getModuleNames(file)
+const externalHelpersModuleNameText = "tslib" // TODO(jakebailey): dedupe
+
+func (p *fileLoader) resolveImportsAndModuleAugmentations(file *ast.SourceFile) (
+	toParse []string,
+	resolutionsInFile module.ModeAwareCache[*module.ResolvedModule],
+	importHelpersImportSpecifier *ast.Node,
+	jsxRuntimeImportSpecifier_ *jsxRuntimeImportSpecifier,
+) {
+	moduleNames := make([]*ast.Node, 0, len(file.Imports)+len(file.ModuleAugmentations)+2)
+	moduleNames = append(moduleNames, file.Imports...)
+	for _, imp := range file.ModuleAugmentations {
+		if imp.Kind == ast.KindStringLiteral {
+			moduleNames = append(moduleNames, imp)
+		}
+		// Do nothing if it's an Identifier; we don't need to do module resolution for `declare global`.
+	}
+
+	isJavaScriptFile := ast.IsSourceFileJS(file)
+	isExternalModuleFile := ast.IsExternalModule(file)
+
+	if isJavaScriptFile || (!file.IsDeclarationFile && (p.compilerOptions.GetIsolatedModules() || isExternalModuleFile)) {
+		if p.compilerOptions.ImportHelpers.IsTrue() {
+			specifier := p.createSyntheticImport(externalHelpersModuleNameText, file)
+			moduleNames = append(moduleNames, specifier)
+			importHelpersImportSpecifier = specifier
+		}
+
+		jsxImport := ast.GetJSXRuntimeImport(ast.GetJSXImplicitImportBase(p.compilerOptions, file), p.compilerOptions)
+		if jsxImport != "" {
+			specifier := p.createSyntheticImport(jsxImport, file)
+			moduleNames = append(moduleNames, specifier)
+			jsxRuntimeImportSpecifier_ = &jsxRuntimeImportSpecifier{
+				moduleReference: jsxImport,
+				specifier:       specifier,
+			}
+		}
+	}
+
+	if len(moduleNames) != 0 {
+		toParse = make([]string, 0, len(moduleNames))
+
 		resolutions := p.resolveModuleNames(moduleNames, file)
 
-		resolutionsInFile := make(module.ModeAwareCache[*module.ResolvedModule], len(resolutions))
+		resolutionsInFile = make(module.ModeAwareCache[*module.ResolvedModule], len(resolutions))
 
 		for i, resolution := range resolutions {
 			resolvedFileName := resolution.ResolvedFileName
@@ -325,10 +393,9 @@ func (p *fileLoader) resolveImportsAndModuleAugmentations(file *ast.SourceFile)
 				toParse = append(toParse, resolvedFileName)
 			}
 		}
-
-		return toParse, resolutionsInFile
 	}
-	return nil, nil
+
+	return toParse, resolutionsInFile, importHelpersImportSpecifier, jsxRuntimeImportSpecifier_
 }
 
 func (p *fileLoader) resolveModuleNames(entries []*ast.Node, file *ast.SourceFile) []*module.ResolvedModule {
@@ -349,3 +416,16 @@ func (p *fileLoader) resolveModuleNames(entries []*ast.Node, file *ast.SourceFil
 
 	return resolvedModules
 }
+
+func (p *fileLoader) createSyntheticImport(text string, file *ast.SourceFile) *ast.Node {
+	p.factoryMu.Lock()
+	defer p.factoryMu.Unlock()
+	externalHelpersModuleReference := p.factory.NewStringLiteral(text)
+	importDecl := p.factory.NewImportDeclaration(nil, nil, externalHelpersModuleReference, nil)
+	// !!! addInternalEmitFlags(importDecl, InternalEmitFlags.NeverApplyImportHelper);
+	externalHelpersModuleReference.Parent = importDecl
+	importDecl.Parent = file.AsNode()
+	// !!! externalHelpersModuleReference.Flags &^= ast.NodeFlagsSynthesized
+	// !!! importDecl.Flags &^= ast.NodeFlagsSynthesized
+	return externalHelpersModuleReference
+}

internal/compiler/program.go

@@ -263,17 +263,6 @@ func (p *Program) findSourceFile(candidate string, reason FileIncludeReason) *as
 	return p.filesByPath[path]
 }
 
-func getModuleNames(file *ast.SourceFile) []*ast.Node {
-	res := slices.Clone(file.Imports)
-	for _, imp := range file.ModuleAugmentations {
-		if imp.Kind == ast.KindStringLiteral {
-			res = append(res, imp)
-		}
-		// Do nothing if it's an Identifier; we don't need to do module resolution for `declare global`.
-	}
-	return res
-}
-
 func (p *Program) GetSyntacticDiagnostics(sourceFile *ast.SourceFile) []*ast.Diagnostic {
 	return p.getDiagnosticsHelper(sourceFile, false /*ensureBound*/, false /*ensureChecked*/, p.getSyntacticDiagnosticsForFile)
 }
@@ -681,3 +670,14 @@ type FileIncludeReason struct {
 func (p *Program) UnsupportedExtensions() []string {
 	return p.unsupportedExtensions
 }
+
+func (p *Program) GetJSXRuntimeImportSpecifier(path tspath.Path) (moduleReference string, specifier *ast.Node) {
+	if result := p.jsxRuntimeImportSpecifiers[path]; result != nil {
+		return result.moduleReference, result.specifier
+	}
+	return "", nil
+}
+
+func (p *Program) GetImportHelpersImportSpecifier(path tspath.Path) *ast.Node {
+	return p.importHelpersImportSpecifiers[path]
+}

internal/parser/parser.go

@@ -345,7 +345,7 @@ func (p *Parser) finishSourceFile(result *ast.SourceFile, isDeclarationFile bool
 	result.Pragmas = getCommentPragmas(&p.factory, p.sourceText)
 	processPragmasIntoFields(result)
 	result.SetDiagnostics(attachFileToDiagnostics(p.diagnostics, result))
-	result.ExternalModuleIndicator = isFileProbablyExternalModule(result)
+	result.ExternalModuleIndicator = isFileProbablyExternalModule(result) // !!!
 	result.IsDeclarationFile = isDeclarationFile
 	result.LanguageVersion = p.languageVersion
 	result.LanguageVariant = p.languageVariant

internal/parser/references.go

@@ -9,23 +9,6 @@ import (
 )
 
 func collectExternalModuleReferences(file *ast.SourceFile) {
-	// !!!
-	// If we are importing helpers, we need to add a synthetic reference to resolve the
-	// helpers library. (A JavaScript file without `externalModuleIndicator` set might be
-	// a CommonJS module; `commonJSModuleIndicator` doesn't get set until the binder has
-	// run. We synthesize a helpers import for it just in case; it will never be used if
-	// the binder doesn't find and set a `commonJSModuleIndicator`.)
-	// if (isJavaScriptFile || (!file.isDeclarationFile && (getIsolatedModules(options) || isExternalModule(file)))) {
-	// 	if (options.importHelpers) {
-	// 		// synthesize 'import "tslib"' declaration
-	// 		imports = [createSyntheticImport(externalHelpersModuleNameText, file)];
-	// 	}
-	// 	const jsxImport = getJSXRuntimeImport(getJSXImplicitImportBase(options, file), options);
-	// 	if (jsxImport) {
-	// 		// synthesize `import "base/jsx-runtime"` declaration
-	// 		(imports ||= []).push(createSyntheticImport(jsxImport, file));
-	// 	}
-	// }
 	for _, node := range file.Statements.Nodes {
 		collectModuleReferences(file, node, false /*inAmbientModule*/)
 	}