fix: add import attribute type to resolved file cache key (microsoft#12)

nathanwhit · web-flow · commit 838a7e3d9404 · 2025-10-24T14:52:29.000-07:00
* add import attribute type to resolved file cache key

* fmt
diff --git a/internal/checker/checker.go b/internal/checker/checker.go
@@ -533,7 +533,7 @@ type Program interface {
 	GetEmitModuleFormatOfFile(sourceFile ast.HasFileName) core.ModuleKind
 	GetEmitSyntaxForUsageLocation(sourceFile ast.HasFileName, usageLocation *ast.StringLiteralLike) core.ResolutionMode
 	GetImpliedNodeFormatForEmit(sourceFile ast.HasFileName) core.ModuleKind
-	GetResolvedModule(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode) *module.ResolvedModule
+	GetResolvedModule(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode, importAttributeType string) *module.ResolvedModule
 	GetResolvedModules() map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule]
 	GetSourceFileMetaData(path tspath.Path) ast.SourceFileMetaData
 	GetJSXRuntimeImportSpecifier(path tspath.Path) (moduleReference string, specifier *ast.Node)
@@ -544,6 +544,8 @@ type Program interface {
 	GetProjectReferenceFromOutputDts(path tspath.Path) *tsoptions.SourceOutputAndProjectReference
 	GetRedirectForResolution(file ast.HasFileName) *tsoptions.ParsedCommandLine
 	CommonSourceDirectory() string
+
+	GetModuleLiteralImportAttributeType(node *ast.StringLiteralLike) string
 }
 
 type Host interface {
@@ -14731,7 +14733,7 @@ func (c *Checker) resolveExternalModule(location *ast.Node, moduleReference stri
 		mode = c.program.GetDefaultResolutionModeForFile(importingSourceFile)
 	}
 
-	resolvedModule := c.program.GetResolvedModule(importingSourceFile, moduleReference, mode)
+	resolvedModule := c.program.GetResolvedModule(importingSourceFile, moduleReference, mode, c.program.GetModuleLiteralImportAttributeType(contextSpecifier))
 
 	var resolutionDiagnostic *diagnostics.Message
 	if errorNode != nil && resolvedModule.IsResolved() {
diff --git a/internal/compiler/fileloader.go b/internal/compiler/fileloader.go
@@ -544,11 +544,15 @@ func (p *fileLoader) resolveImportsAndModuleAugmentations(t *parseTask) {
 
 			var kind *string = nil
 			if ast.IsStringLiteralLike(entry) {
-				kind = getModuleLiteralImportKind(entry)
+				kind = getModuleLiteralImportAttributeType(entry)
+			}
+			importAttributeType := ""
+			if kind != nil {
+				importAttributeType = *kind
 			}
 			mode := getModeForUsageLocation(file.FileName(), meta, entry, optionsForFile)
 			resolvedModule, trace := p.resolver.ResolveModuleName(moduleName, fileName, kind, mode, redirect)
-			resolutionsInFile[module.ModeAwareCacheKey{Name: moduleName, Mode: mode}] = resolvedModule
+			resolutionsInFile[module.ModeAwareCacheKey{Name: moduleName, Mode: mode, ImportAttributeType: importAttributeType}] = resolvedModule
 			resolutionsTrace = append(resolutionsTrace, trace...)
 
 			if !resolvedModule.IsResolved() {
@@ -783,7 +787,7 @@ func getRawTypeValue(node *ast.Node) *string {
 	return nil
 }
 
-func getModuleLiteralImportKind(node *ast.StringLiteralLike) *string {
+func getModuleLiteralImportAttributeType(node *ast.StringLiteralLike) *string {
 	parent := node.Parent
 	if parent == nil {
 		return nil
diff --git a/internal/compiler/program.go b/internal/compiler/program.go
@@ -167,6 +167,14 @@ func (p *Program) GetDenoForkContextInfo() ast.DenoForkContextInfo {
 	return p.Host().GetDenoForkContextInfo()
 }
 
+func (p *Program) GetModuleLiteralImportAttributeType(node *ast.StringLiteralLike) string {
+	t := getModuleLiteralImportAttributeType(node)
+	if t != nil {
+		return *t
+	}
+	return ""
+}
+
 var _ checker.Program = (*Program)(nil)
 
 /** This should have similar behavior to 'processSourceFile' without diagnostics or mutation. */
@@ -385,9 +393,9 @@ func (p *Program) GetTypeCheckerForFile(ctx context.Context, file *ast.SourceFil
 	return p.checkerPool.GetCheckerForFile(ctx, file)
 }
 
-func (p *Program) GetResolvedModule(file ast.HasFileName, moduleReference string, mode core.ResolutionMode) *module.ResolvedModule {
+func (p *Program) GetResolvedModule(file ast.HasFileName, moduleReference string, mode core.ResolutionMode, importAttributeType string) *module.ResolvedModule {
 	if resolutions, ok := p.resolvedModules[file.Path()]; ok {
-		if resolved, ok := resolutions[module.ModeAwareCacheKey{Name: moduleReference, Mode: mode}]; ok {
+		if resolved, ok := resolutions[module.ModeAwareCacheKey{Name: moduleReference, Mode: mode, ImportAttributeType: importAttributeType}]; ok {
 			return resolved
 		}
 	}
@@ -399,7 +407,7 @@ func (p *Program) GetResolvedModuleFromModuleSpecifier(file ast.HasFileName, mod
 		panic("moduleSpecifier must be a StringLiteralLike")
 	}
 	mode := p.GetModeForUsageLocation(file, moduleSpecifier)
-	return p.GetResolvedModule(file, moduleSpecifier.Text(), mode)
+	return p.GetResolvedModule(file, moduleSpecifier.Text(), mode, p.GetModuleLiteralImportAttributeType(moduleSpecifier))
 }
 
 func (p *Program) GetResolvedModules() map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule] {
diff --git a/internal/module/resolver_test.go b/internal/module/resolver_test.go
@@ -265,7 +265,7 @@ func doCall(t *testing.T, resolver *module.Resolver, call functionCall, skipLoca
 
 		errorMessageArgs := []any{call.args.Name, call.args.ContainingFile}
 		if call.call == "resolveModuleName" {
-			resolved, _ := resolver.ResolveModuleName(call.args.Name, call.args.ContainingFile, core.ModuleKind(call.args.ResolutionMode), redirectedReference)
+			resolved, _ := resolver.ResolveModuleName(call.args.Name, call.args.ContainingFile, nil, core.ModuleKind(call.args.ResolutionMode), redirectedReference)
 			assert.Check(t, resolved != nil, "ResolveModuleName should not return nil", errorMessageArgs)
 			if expectedResolvedModule, ok := call.returnValue["resolvedModule"].(map[string]any); ok {
 				assert.Check(t, resolved.IsResolved(), errorMessageArgs)
diff --git a/internal/module/types.go b/internal/module/types.go
@@ -17,8 +17,9 @@ type ResolutionHost interface {
 }
 
 type ModeAwareCacheKey struct {
-	Name string
-	Mode core.ResolutionMode
+	Name                string
+	Mode                core.ResolutionMode
+	ImportAttributeType string
 }
 
 type ResolvedProjectReference interface {
diff --git a/internal/transformers/tstransforms/importelision_test.go b/internal/transformers/tstransforms/importelision_test.go
@@ -24,7 +24,7 @@ type fakeProgram struct {
 	files                          []*ast.SourceFile
 	getEmitModuleFormatOfFile      func(sourceFile ast.HasFileName) core.ModuleKind
 	getImpliedNodeFormatForEmit    func(sourceFile ast.HasFileName) core.ModuleKind
-	getResolvedModule              func(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode) *module.ResolvedModule
+	getResolvedModule              func(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode, importAttributeType string) *module.ResolvedModule
 	getSourceFile                  func(FileName string) *ast.SourceFile
 	getSourceFileForResolvedModule func(FileName string) *ast.SourceFile
 }
@@ -133,8 +133,8 @@ func (p *fakeProgram) GetModeForUsageLocation(sourceFile ast.HasFileName, locati
 	return p.getEmitModuleFormatOfFile(sourceFile)
 }
 
-func (p *fakeProgram) GetResolvedModule(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode) *module.ResolvedModule {
-	return p.getResolvedModule(currentSourceFile, moduleReference, mode)
+func (p *fakeProgram) GetResolvedModule(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode, importAttributeType string) *module.ResolvedModule {
+	return p.getResolvedModule(currentSourceFile, moduleReference, mode, importAttributeType)
 }
 
 func (p *fakeProgram) GetSourceFile(FileName string) *ast.SourceFile {
@@ -173,6 +173,10 @@ func (p *fakeProgram) GetDenoForkContextInfo() ast.DenoForkContextInfo {
 	return ast.DenoForkContextInfo{}
 }
 
+func (p *fakeProgram) GetModuleLiteralImportAttributeType(node *ast.StringLiteralLike) string {
+	return ""
+}
+
 func TestImportElision(t *testing.T) {
 	t.Parallel()
 	data := []struct {
@@ -243,7 +247,7 @@ func TestImportElision(t *testing.T) {
 					}
 					return nil
 				},
-				getResolvedModule: func(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode) *module.ResolvedModule {
+				getResolvedModule: func(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode, importAttributeType string) *module.ResolvedModule {
 					if currentSourceFile == file && moduleReference == "other" {
 						return &module.ResolvedModule{
 							ResolvedFileName: "other.ts",

Original file line number	Diff line number	Diff line change
`@@ -167,6 +167,14 @@ func (p *Program) GetDenoForkContextInfo() ast.DenoForkContextInfo {`
`167`	`167`	`return p.Host().GetDenoForkContextInfo()`
`168`	`168`	`}`
`169`	`169`
	`170`	`+func (p Program) GetModuleLiteralImportAttributeType(node ast.StringLiteralLike) string {`
	`171`	`+ t := getModuleLiteralImportAttributeType(node)`
	`172`	`+ if t != nil {`
	`173`	`+ return *t`
	`174`	`+ }`
	`175`	`+ return ""`
	`176`	`+}`
	`177`	`+`
`170`	`178`	`var _ checker.Program = (*Program)(nil)`
`171`	`179`
`172`	`180`	`/** This should have similar behavior to 'processSourceFile' without diagnostics or mutation. */`
`@@ -385,9 +393,9 @@ func (p Program) GetTypeCheckerForFile(ctx context.Context, file ast.SourceFil`
`385`	`393`	`return p.checkerPool.GetCheckerForFile(ctx, file)`
`386`	`394`	`}`
`387`	`395`
`388`		`-func (p Program) GetResolvedModule(file ast.HasFileName, moduleReference string, mode core.ResolutionMode) module.ResolvedModule {`
	`396`	`+func (p Program) GetResolvedModule(file ast.HasFileName, moduleReference string, mode core.ResolutionMode, importAttributeType string) module.ResolvedModule {`
`389`	`397`	`if resolutions, ok := p.resolvedModules[file.Path()]; ok {`
`390`		`- if resolved, ok := resolutions[module.ModeAwareCacheKey{Name: moduleReference, Mode: mode}]; ok {`
	`398`	`+ if resolved, ok := resolutions[module.ModeAwareCacheKey{Name: moduleReference, Mode: mode, ImportAttributeType: importAttributeType}]; ok {`
`391`	`399`	`return resolved`
`392`	`400`	`}`
`393`	`401`	`}`
`@@ -399,7 +407,7 @@ func (p *Program) GetResolvedModuleFromModuleSpecifier(file ast.HasFileName, mod`
`399`	`407`	`panic("moduleSpecifier must be a StringLiteralLike")`
`400`	`408`	`}`
`401`	`409`	`mode := p.GetModeForUsageLocation(file, moduleSpecifier)`
`402`		`- return p.GetResolvedModule(file, moduleSpecifier.Text(), mode)`
	`410`	`+ return p.GetResolvedModule(file, moduleSpecifier.Text(), mode, p.GetModuleLiteralImportAttributeType(moduleSpecifier))`
`403`	`411`	`}`
`404`	`412`
`405`	`413`	`func (p Program) GetResolvedModules() map[tspath.Path]module.ModeAwareCache[module.ResolvedModule] {`
Original file line number	Diff line number	Diff line change
`@@ -17,8 +17,9 @@ type ResolutionHost interface {`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`type ModeAwareCacheKey struct {`
`20`		`- Name string`
`21`		`- Mode core.ResolutionMode`
	`20`	`+ Name string`
	`21`	`+ Mode core.ResolutionMode`
	`22`	`+ ImportAttributeType string`
`22`	`23`	`}`
`23`	`24`
`24`	`25`	`type ResolvedProjectReference interface {`