Try to adjust to latest auto-import changes

Author: bartlomieju

internal/api/api.go

@@ -278,7 +278,7 @@ func (api *API) GetDiagnostics(ctx context.Context, projectId Handle[project.Pro
 		return nil, errors.New("project not found")
 	}
 
-	languageService := ls.NewLanguageService(project.GetProgram(), snapshot)
+	languageService := ls.NewLanguageService(projectPath, project.GetProgram(), snapshot)
 	diagnostics := languageService.GetDiagnostics(ctx, fileNames)
 
 	api.symbolsMu.Lock()

internal/api/server.go

@@ -178,6 +178,11 @@ func (h *hostWrapper) SessionOptions() *project.SessionOptions {
 	return h.inner.SessionOptions()
 }
 
+// SourceFS implements project.ProjectHost.
+func (h *hostWrapper) SourceFS() *project.SourceFS {
+	return h.inner.SourceFS()
+}
+
 // TypesNodeIgnorableNames implements project.ProjectHost.
 func (h *hostWrapper) GetDenoForkContextInfo() ast.DenoForkContextInfo {
 	return h.server.forkContextInfo

internal/ls/autoimport/aliasresolver.go

@@ -108,12 +108,16 @@ func (r *aliasResolver) GetModeForUsageLocation(file ast.HasFileName, moduleSpec
 }
 
 // GetResolvedModule implements checker.Program.
-func (r *aliasResolver) GetResolvedModule(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode) *module.ResolvedModule {
+func (r *aliasResolver) GetResolvedModule(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode, importAttributeType string) *module.ResolvedModule {
 	cache, _ := r.resolvedModules.LoadOrStore(currentSourceFile.Path(), &collections.SyncMap[module.ModeAwareCacheKey, *module.ResolvedModule]{})
 	if resolved, ok := cache.Load(module.ModeAwareCacheKey{Name: moduleReference, Mode: mode}); ok {
 		return resolved
 	}
-	resolved, _ := r.moduleResolver.ResolveModuleName(moduleReference, currentSourceFile.FileName(), mode, nil)
+	var attrPtr *string
+	if importAttributeType != "" {
+		attrPtr = &importAttributeType
+	}
+	resolved, _ := r.moduleResolver.ResolveModuleName(moduleReference, currentSourceFile.FileName(), attrPtr, mode, nil)
 	resolved, _ = cache.LoadOrStore(module.ModeAwareCacheKey{Name: moduleReference, Mode: mode}, resolved)
 	if !resolved.IsResolved() && !tspath.PathIsRelative(moduleReference) {
 		r.onFailedAmbientModuleLookup(currentSourceFile, moduleReference)
@@ -224,4 +228,19 @@ func (r *aliasResolver) SourceFileMayBeEmitted(sourceFile *ast.SourceFile, force
 	panic("unimplemented")
 }
 
+// GetDenoForkContextInfo implements Host.
+func (r *aliasResolver) GetDenoForkContextInfo() ast.DenoForkContextInfo {
+	return ast.DenoForkContextInfo{}
+}
+
+// GetModuleLiteralImportAttributeType implements Program.
+func (r *aliasResolver) GetModuleLiteralImportAttributeType(node *ast.StringLiteralLike) string {
+	return ""
+}
+
+// IsNodeSourceFile implements Host.
+func (r *aliasResolver) IsNodeSourceFile(path tspath.Path) bool {
+	return false
+}
+
 var _ checker.Program = (*aliasResolver)(nil)

internal/ls/autoimport/extract.go

@@ -110,7 +110,7 @@ func (e *exportExtractor) extractFromFile(file *ast.SourceFile) []*Export {
 		moduleDeclarations := core.Filter(file.Statements.Nodes, ast.IsModuleWithStringLiteralName)
 		var exportCount int
 		for _, decl := range moduleDeclarations {
-			exportCount += len(decl.AsModuleDeclaration().Symbol.Exports)
+			exportCount += decl.AsModuleDeclaration().Symbol.Exports.Len()
 		}
 		exports := make([]*Export, 0, exportCount)
 		for _, decl := range moduleDeclarations {
@@ -131,19 +131,19 @@ func (e *exportExtractor) extractFromModule(file *ast.SourceFile) []*Export {
 	})
 	var augmentationExportCount int
 	for _, decl := range moduleAugmentations {
-		augmentationExportCount += len(decl.Symbol.Exports)
+		augmentationExportCount += decl.Symbol.Exports.Len()
 	}
 	moduleID := e.getModuleID(file)
-	exports := make([]*Export, 0, len(file.Symbol.Exports)+augmentationExportCount)
-	for name, symbol := range file.Symbol.Exports {
+	exports := make([]*Export, 0, file.Symbol.Exports.Len()+augmentationExportCount)
+	for name, symbol := range file.Symbol.Exports.Iter() {
 		e.extractFromSymbol(name, symbol, moduleID, file.FileName(), file, &exports)
 	}
 	for _, decl := range moduleAugmentations {
 		name := decl.Name().AsStringLiteral().Text
 		moduleID := ModuleID(name)
 		var moduleFileName string
 		if tspath.IsExternalModuleNameRelative(name) {
-			if resolved, _ := e.moduleResolver.ResolveModuleName(name, file.FileName(), core.ModuleKindCommonJS, nil); resolved.IsResolved() {
+			if resolved, _ := e.moduleResolver.ResolveModuleName(name, file.FileName(), nil, core.ModuleKindCommonJS, nil); resolved.IsResolved() {
 				moduleFileName = resolved.ResolvedFileName
 				moduleID = ModuleID(e.toPath(moduleFileName))
 			} else {
@@ -158,7 +158,7 @@ func (e *exportExtractor) extractFromModule(file *ast.SourceFile) []*Export {
 }
 
 func (e *exportExtractor) extractFromModuleDeclaration(decl *ast.ModuleDeclaration, file *ast.SourceFile, moduleID ModuleID, moduleFileName string, exports *[]*Export) {
-	for name, symbol := range decl.Symbol.Exports {
+	for name, symbol := range decl.Symbol.Exports.Iter() {
 		e.extractFromSymbol(name, symbol, moduleID, moduleFileName, file, exports)
 	}
 }
@@ -173,7 +173,7 @@ func (e *symbolExtractor) extractFromSymbol(name string, symbol *ast.Symbol, mod
 		allExports := e.checker.GetExportsOfModule(symbol.Parent)
 		// allExports includes named exports from the file that will be processed separately;
 		// we want to add only the ones that come from the star
-		for name, namedExport := range symbol.Parent.Exports {
+		for name, namedExport := range symbol.Parent.Exports.Iter() {
 			if name != ast.InternalSymbolNameExportStar {
 				idx := slices.Index(allExports, namedExport)
 				if idx >= 0 || shouldIgnoreSymbol(namedExport) {
@@ -237,8 +237,8 @@ func (e *symbolExtractor) extractFromSymbol(name string, symbol *ast.Symbol, mod
 
 	if target != nil {
 		if syntax == ExportSyntaxEquals && target.Flags&ast.SymbolFlagsNamespace != 0 {
-			*exports = slices.Grow(*exports, len(target.Exports))
-			for _, namedExport := range target.Exports {
+		*exports = slices.Grow(*exports, target.Exports.Len())
+		for namedExport := range target.Exports.Values() {
 				export, _ := e.createExport(namedExport, moduleID, moduleFileName, syntax, file, checkerLease)
 				if export != nil {
 					export.through = name
@@ -255,10 +255,13 @@ func (e *symbolExtractor) extractFromSymbol(name string, symbol *ast.Symbol, mod
 			*exports = slices.Grow(*exports, len(expression.AsObjectLiteralExpression().Properties.Nodes))
 			for _, prop := range expression.AsObjectLiteralExpression().Properties.Nodes {
 				if ast.IsShorthandPropertyAssignment(prop) || ast.IsPropertyAssignment(prop) && prop.AsPropertyAssignment().Name().Kind == ast.KindIdentifier {
-					export, _ := e.createExport(expression.Symbol().Members[prop.Name().Text()], moduleID, moduleFileName, syntax, file, checkerLease)
-					if export != nil {
-						export.through = name
-						*exports = append(*exports, export)
+					memberSymbol := expression.Symbol().Members.Get(prop.Name().Text())
+					if memberSymbol != nil {
+						export, _ := e.createExport(memberSymbol, moduleID, moduleFileName, syntax, file, checkerLease)
+						if export != nil {
+							export.through = name
+							*exports = append(*exports, export)
+						}
 					}
 				}
 			}

internal/project/autoimport.go

@@ -59,7 +59,7 @@ func (a *autoImportBuilderFS) GetFileByPath(fileName string, path tspath.Path) F
 type autoImportRegistryCloneHost struct {
 	projectCollection *ProjectCollection
 	parseCache        *ParseCache
-	fs                *sourceFS
+	fs                *SourceFS
 	currentDirectory  string
 
 	filesMu sync.Mutex

internal/project/compilerhost.go

@@ -1,7 +1,10 @@
 package project
 
 import (
+	"time"
+
 	"github.com/microsoft/typescript-go/internal/ast"
+	"github.com/microsoft/typescript-go/internal/collections"
 	"github.com/microsoft/typescript-go/internal/compiler"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/diagnostics"
@@ -20,6 +23,7 @@ type ProjectHost interface {
 	UpdateSeenFiles(*collections.SyncSet[tspath.Path])
 	Freeze(snapshotFS *SnapshotFS, configFileRegistry *ConfigFileRegistry)
 	CompilerFS() *CompilerFS
+	SourceFS() *SourceFS
 }
 
 var (
@@ -32,7 +36,7 @@ type compilerHost struct {
 	currentDirectory string
 	sessionOptions   *SessionOptions
 
-	fs                 *snapshotFSBuilder
+	sourceFS           *SourceFS
 	compilerFS         *CompilerFS
 	configFileRegistry *ConfigFileRegistry
 
@@ -62,6 +66,11 @@ func (c *builderFileSource) GetFile(fileName string) FileHandle {
 	return c.snapshotFSBuilder.GetFileByPath(fileName, path)
 }
 
+func (c *builderFileSource) GetFileByPath(fileName string, path tspath.Path) FileHandle {
+	c.seenFiles.Add(path)
+	return c.snapshotFSBuilder.GetFileByPath(fileName, path)
+}
+
 func (c *builderFileSource) FS() vfs.FS {
 	return c.snapshotFSBuilder.FS()
 }
@@ -85,7 +94,8 @@ func NewProjectHost(
 		currentDirectory: currentDirectory,
 		sessionOptions:   builder.sessionOptions,
 
-		sourceFS: newSourceFS(true, builder.fs, builder.toPath),
+		sourceFS:   newSourceFS(true, builder.fs, builder.toPath),
+		compilerFS: compilerFS,
 
 		project: project,
 		builder: builder,
@@ -235,11 +245,11 @@ func (c *compilerHost) SessionOptions() *SessionOptions {
 }
 
 func (c *compilerHost) SeenFiles() *collections.SyncSet[tspath.Path] {
-	return c.seenFiles
+	return c.sourceFS.seenFiles
 }
 
 func (c *compilerHost) UpdateSeenFiles(seenFiles *collections.SyncSet[tspath.Path]) {
-	c.seenFiles = seenFiles
+	c.sourceFS.seenFiles = seenFiles
 }
 
 func (c *compilerHost) Freeze(snapshotFS *SnapshotFS, configFileRegistry *ConfigFileRegistry) {
@@ -249,3 +259,7 @@ func (c *compilerHost) Freeze(snapshotFS *SnapshotFS, configFileRegistry *Config
 func (c *compilerHost) CompilerFS() *CompilerFS {
 	return c.compilerFS
 }
+
+func (c *compilerHost) SourceFS() *SourceFS {
+	return c.sourceFS
+}

internal/project/projectcollectionbuilder.go

@@ -990,7 +990,7 @@ func (b *ProjectCollectionBuilder) updateProgram(entry dirty.Value[*Project], lo
 				project.ProgramUpdateKind = result.UpdateKind
 				project.ProgramLastUpdate = b.newSnapshotID
 				if result.UpdateKind == ProgramUpdateKindCloned {
-					project.host.sourceFS.seenFiles = oldHost.sourceFS.seenFiles
+				project.host.SourceFS().seenFiles = oldHost.SourceFS().seenFiles
 				}
 				if result.UpdateKind == ProgramUpdateKindNewFiles {
 					filesChanged = true

internal/project/snapshot.go

@@ -346,7 +346,7 @@ func (s *Snapshot) Clone(ctx context.Context, change SnapshotChange, overlays ma
 			removedFiles := 0
 			fs.diskFiles.Range(func(entry *dirty.SyncMapEntry[tspath.Path, *diskFile]) bool {
 				for _, project := range projectCollection.Projects() {
-					if project.host != nil && project.host.sourceFS.Seen(entry.Key()) {
+					if project.host != nil && project.host.SourceFS().Seen(entry.Key()) {
 						return true
 					}
 				}

internal/project/snapshotfs.go

@@ -199,16 +199,16 @@ func (s *snapshotFSBuilder) markDirtyFiles(change FileChangeSummary) {
 	}
 }
 
-// sourceFS is a vfs.FS that sources files from a FileSource and tracks seen files.
-type sourceFS struct {
+// SourceFS is a vfs.FS that sources files from a FileSource and tracks seen files.
+type SourceFS struct {
 	tracking  bool
 	toPath    func(fileName string) tspath.Path
 	seenFiles *collections.SyncSet[tspath.Path]
 	source    FileSource
 }
 
-func newSourceFS(tracking bool, source FileSource, toPath func(fileName string) tspath.Path) *sourceFS {
-	fs := &sourceFS{
+func newSourceFS(tracking bool, source FileSource, toPath func(fileName string) tspath.Path) *SourceFS {
+	fs := &SourceFS{
 		tracking: tracking,
 		toPath:   toPath,
 		source:   source,
@@ -219,79 +219,79 @@ func newSourceFS(tracking bool, source FileSource, toPath func(fileName string)
 	return fs
 }
 
-var _ vfs.FS = (*sourceFS)(nil)
+var _ vfs.FS = (*SourceFS)(nil)
 
-func (fs *sourceFS) DisableTracking() {
+func (fs *SourceFS) DisableTracking() {
 	fs.tracking = false
 }
 
-func (fs *sourceFS) Track(fileName string) {
+func (fs *SourceFS) Track(fileName string) {
 	if !fs.tracking {
 		return
 	}
 	fs.seenFiles.Add(fs.toPath(fileName))
 }
 
-func (fs *sourceFS) Seen(path tspath.Path) bool {
+func (fs *SourceFS) Seen(path tspath.Path) bool {
 	if fs.seenFiles == nil {
 		return false
 	}
 	return fs.seenFiles.Has(path)
 }
 
-func (fs *sourceFS) GetFile(fileName string) FileHandle {
+func (fs *SourceFS) GetFile(fileName string) FileHandle {
 	fs.Track(fileName)
 	return fs.source.GetFile(fileName)
 }
 
-func (fs *sourceFS) GetFileByPath(fileName string, path tspath.Path) FileHandle {
+func (fs *SourceFS) GetFileByPath(fileName string, path tspath.Path) FileHandle {
 	fs.Track(fileName)
 	return fs.source.GetFileByPath(fileName, path)
 }
 
 // DirectoryExists implements vfs.FS.
-func (fs *sourceFS) DirectoryExists(path string) bool {
+func (fs *SourceFS) DirectoryExists(path string) bool {
 	return fs.source.FS().DirectoryExists(path)
 }
 
 // FileExists implements vfs.FS.
-func (fs *sourceFS) FileExists(path string) bool {
+func (fs *SourceFS) FileExists(path string) bool {
 	if fh := fs.GetFile(path); fh != nil {
 		return true
 	}
 	return fs.source.FS().FileExists(path)
 }
 
 // GetAccessibleEntries implements vfs.FS.
-func (fs *sourceFS) GetAccessibleEntries(path string) vfs.Entries {
+func (fs *SourceFS) GetAccessibleEntries(path string) vfs.Entries {
 	return fs.source.FS().GetAccessibleEntries(path)
 }
 
 // ReadFile implements vfs.FS.
-func (fs *sourceFS) ReadFile(path string) (contents string, ok bool) {
+func (fs *SourceFS) ReadFile(path string) (contents string, ok bool) {
 	if fh := fs.GetFile(path); fh != nil {
 		return fh.Content(), true
 	}
 	return "", false
 }
 
 // Realpath implements vfs.FS.
-func (fs *sourceFS) Realpath(path string) string {
+func (fs *SourceFS) Realpath(path string) string {
 	return fs.source.FS().Realpath(path)
 }
 
 // Stat implements vfs.FS.
-func (fs *sourceFS) Stat(path string) vfs.FileInfo {
+func (fs *SourceFS) Stat(path string) vfs.FileInfo {
 	return fs.source.FS().Stat(path)
 }
 
 // UseCaseSensitiveFileNames implements vfs.FS.
-func (fs *sourceFS) UseCaseSensitiveFileNames() bool {
+func (fs *SourceFS) UseCaseSensitiveFileNames() bool {
 	return fs.source.FS().UseCaseSensitiveFileNames()
 }
 
 // WalkDir implements vfs.FS.
-func (fs *sourceFS) WalkDir(root string, walkFn vfs.WalkDirFunc) error {
+func (fs *SourceFS) WalkDir(root string, walkFn vfs.WalkDirFunc) error {
 	return fs.source.FS().WalkDir(root, walkFn)
 }