Preserve ATA state across project lifecycles

Author: jakebailey

tsc/internal/project/ata/ata.go

@@ -27,6 +27,8 @@ type TypingsInfo struct {
 func (ti TypingsInfo) Equals(other TypingsInfo) bool {
 	return ti.TypeAcquisition.Equals(other.TypeAcquisition) &&
 		ti.CompilerOptions.GetAllowJS() == other.CompilerOptions.GetAllowJS() &&
+		(ti.CompilerOptions.Types == nil) == (other.CompilerOptions.Types == nil) &&
+		slices.Equal(ti.CompilerOptions.Types, other.CompilerOptions.Types) &&
 		ti.UnresolvedImports.Equals(other.UnresolvedImports)
 }
 

tsc/internal/project/project.go

@@ -173,6 +173,84 @@ type Project struct {
 	installedTypingsInfo *ata.TypingsInfo
 	// typingsFiles are the root files added by the typings installer.
 	typingsFiles []string
+	// installedTypingsFileNames are the JavaScript files used during the most
+	// recently completed typings installation.
+	installedTypingsFileNames []string
+	// installedTypingsFilesToWatch are discovery inputs whose changes require
+	// typings discovery to run again.
+	installedTypingsFilesToWatch []string
+	// ataInvalidationSnapshotID is the latest snapshot that invalidated this
+	// project's ATA discovery inputs.
+	ataInvalidationSnapshotID uint64
+}
+
+type inferredProjectATAState struct {
+	installedTypingsInfo         *ata.TypingsInfo
+	installedTypingsFileNames    []string
+	installedTypingsFilesToWatch []string
+	typingsFiles                 []string
+	typingsWatch                 *WatchedFiles[PatternsAndIgnored]
+}
+
+func (p *Project) inferredProjectATAState() *inferredProjectATAState {
+	if p.installedTypingsInfo == nil && len(p.installedTypingsFilesToWatch) == 0 {
+		return nil
+	}
+	return &inferredProjectATAState{
+		installedTypingsInfo:         p.installedTypingsInfo,
+		installedTypingsFileNames:    slices.Clone(p.installedTypingsFileNames),
+		installedTypingsFilesToWatch: slices.Clone(p.installedTypingsFilesToWatch),
+		typingsFiles:                 slices.Clone(p.typingsFiles),
+		typingsWatch:                 p.typingsWatch,
+	}
+}
+
+func (s *inferredProjectATAState) canApply(project *Project, fs *snapshotFSBuilder, watchEnabled bool) bool {
+	if s == nil || s.installedTypingsInfo == nil {
+		return false
+	}
+	if !watchEnabled && len(s.installedTypingsFilesToWatch) > 0 {
+		return false
+	}
+	if !s.installedTypingsInfo.Equals(project.ComputeTypingsInfo()) ||
+		!slices.Equal(s.installedTypingsFileNames, project.ComputeTypingsFileNames()) {
+		return false
+	}
+	for _, fileName := range s.typingsFiles {
+		if !fs.FileExists(fileName, fs.toPath(fileName)) {
+			return false
+		}
+	}
+	return true
+}
+
+func (s *inferredProjectATAState) apply(project *Project) {
+	typingsFilesChanged := !slices.Equal(project.typingsFiles, s.typingsFiles)
+	project.installedTypingsInfo = s.installedTypingsInfo
+	project.installedTypingsFileNames = slices.Clone(s.installedTypingsFileNames)
+	project.installedTypingsFilesToWatch = slices.Clone(s.installedTypingsFilesToWatch)
+	project.typingsFiles = slices.Clone(s.typingsFiles)
+	project.typingsWatch = s.typingsWatch
+	if typingsFilesChanged {
+		project.dirty = true
+		project.dirtyFilePath = ""
+	}
+}
+
+func (s *inferredProjectATAState) canApplyWatchState(project *Project, watchEnabled bool) bool {
+	return s != nil &&
+		s.installedTypingsInfo == nil &&
+		watchEnabled &&
+		slices.Equal(s.installedTypingsFileNames, project.ComputeTypingsFileNames())
+}
+
+func (s *inferredProjectATAState) applyWatchState(project *Project) {
+	project.installedTypingsFileNames = slices.Clone(s.installedTypingsFileNames)
+	project.installedTypingsFilesToWatch = slices.Concat(
+		slices.Clone(s.installedTypingsFilesToWatch),
+		s.typingsFiles,
+	)
+	project.typingsWatch = s.typingsWatch
 }
 
 var _ ls.Project = (*Project)(nil)
@@ -203,6 +281,7 @@ func NewInferredProject(
 	logger *logging.LogTree,
 ) *Project {
 	p := NewProject(inferredProjectID.AsID(), KindInferred, currentDirectory, builder, logger)
+	p.ataInvalidationSnapshotID = builder.inferredProjectATAInvalidationSnapshotID
 	if compilerOptions == nil {
 		compilerOptions = &core.CompilerOptions{
 			AllowJs:                    core.TSTrue,
@@ -278,10 +357,11 @@ func NewProject(
 		logger.Log(fmt.Sprintf("Creating %sProject: %s, currentDirectory: %s", kind.String(), id, currentDirectory))
 	}
 	project := &Project{
-		Kind:             kind,
-		id:               id,
-		currentDirectory: currentDirectory,
-		dirty:            true,
+		Kind:                      kind,
+		id:                        id,
+		currentDirectory:          currentDirectory,
+		dirty:                     true,
+		ataInvalidationSnapshotID: builder.newSnapshotID,
 	}
 
 	project.programFilesWatch = NewWatchedFiles(
@@ -291,12 +371,7 @@ func NewProject(
 		createResolutionLookupGlobMapper(builder.sessionOptions.CurrentDirectory, builder.sessionOptions.DefaultLibraryPath, project.currentDirectory, builder.fs.fs.UseCaseSensitiveFileNames()),
 	)
 	if builder.sessionOptions.TypingsLocation != "" {
-		project.typingsWatch = NewWatchedFiles(
-			"typings installer files",
-			lsproto.WatchKindCreate|lsproto.WatchKindChange|lsproto.WatchKindDelete,
-			lsproto.GetClientCapabilities(builder.ctx).Workspace.DidChangeWatchedFiles.RelativePatternSupport,
-			core.Identity,
-		)
+		project.typingsWatch = newTypingsWatch(builder)
 	}
 	project.contentMapperWatch = NewWatchedFilesForPaths(
 		"content mapper configuration files for "+string(id),
@@ -309,6 +384,15 @@ func NewProject(
 	return project
 }
 
+func newTypingsWatch(builder *ProjectCollectionBuilder) *WatchedFiles[PatternsAndIgnored] {
+	return NewWatchedFiles(
+		"typings installer files",
+		lsproto.WatchKindCreate|lsproto.WatchKindChange|lsproto.WatchKindDelete,
+		lsproto.GetClientCapabilities(builder.ctx).Workspace.DidChangeWatchedFiles.RelativePatternSupport,
+		core.Identity,
+	)
+}
+
 func (p *Project) CurrentDirectory() string {
 	return p.currentDirectory
 }
@@ -418,8 +502,11 @@ func (p *Project) Clone() *Project {
 		moduleResolverFactory: p.moduleResolverFactory,
 		moduleResolverID:      p.moduleResolverID,
 
-		installedTypingsInfo: p.installedTypingsInfo,
-		typingsFiles:         p.typingsFiles,
+		installedTypingsInfo:         p.installedTypingsInfo,
+		installedTypingsFileNames:    p.installedTypingsFileNames,
+		installedTypingsFilesToWatch: p.installedTypingsFilesToWatch,
+		typingsFiles:                 p.typingsFiles,
+		ataInvalidationSnapshotID:    p.ataInvalidationSnapshotID,
 	}
 }
 
@@ -666,7 +753,8 @@ func (p *Project) ShouldTriggerATA(snapshotID uint64) bool {
 		return true
 	}
 
-	return !p.installedTypingsInfo.Equals(p.ComputeTypingsInfo())
+	return !p.installedTypingsInfo.Equals(p.ComputeTypingsInfo()) ||
+		!slices.Equal(p.installedTypingsFileNames, p.ComputeTypingsFileNames())
 }
 
 func (p *Project) ComputeTypingsInfo() ata.TypingsInfo {
@@ -676,3 +764,17 @@ func (p *Project) ComputeTypingsInfo() ata.TypingsInfo {
 		UnresolvedImports: p.GetUnresolvedImports(),
 	}
 }
+
+func (p *Project) ComputeTypingsFileNames() []string {
+	if p.Program == nil {
+		return nil
+	}
+	var fileNames []string
+	for _, file := range p.Program.GetSourceFiles() {
+		if tspath.HasJSFileExtension(file.FileName()) && !p.Program.IsSourceFileFromExternalLibrary(file) {
+			fileNames = append(fileNames, file.FileName())
+		}
+	}
+	slices.Sort(fileNames)
+	return fileNames
+}

tsc/internal/project/projectcollection.go

@@ -31,6 +31,12 @@ type ProjectCollection struct {
 	// inferredProject is a fallback project that is used when no configured
 	// project can be found for an open file.
 	inferredProject *Project
+	// inferredProjectATAState preserves acquired typings while there is no active
+	// inferred project, so reopening a loose file does not wait for ATA again.
+	inferredProjectATAState *inferredProjectATAState
+	// inferredProjectATAInvalidationSnapshotID is the latest snapshot that
+	// invalidated inferred-project ATA discovery inputs.
+	inferredProjectATAInvalidationSnapshotID uint64
 	// apiState tracks the projects and files that API clients have explicitly
 	// opened so they are kept loaded across snapshots.
 	apiState APIState
@@ -71,6 +77,16 @@ type apiOpenedFile struct {
 
 func (c *ProjectCollection) ConfigFileRegistry() *ConfigFileRegistry { return c.configFileRegistry }
 
+func (c *ProjectCollection) inferredProjectTypingsWatch() *WatchedFiles[PatternsAndIgnored] {
+	if c.inferredProject != nil {
+		return c.inferredProject.typingsWatch
+	}
+	if c.inferredProjectATAState != nil {
+		return c.inferredProjectATAState.typingsWatch
+	}
+	return nil
+}
+
 func (c *ProjectCollection) ConfiguredProject(path tspath.Path) *Project {
 	return c.configuredProjects[ConfiguredProjectID(path)]
 }
@@ -328,14 +344,16 @@ func (c *ProjectCollection) findDefaultConfiguredProjectWorker(path tspath.Path,
 // clone creates a shallow copy of the project collection.
 func (c *ProjectCollection) clone() *ProjectCollection {
 	return &ProjectCollection{
-		toPath:              c.toPath,
-		configFileRegistry:  c.configFileRegistry,
-		configuredProjects:  c.configuredProjects,
-		syntheticProjects:   c.syntheticProjects,
-		openFiles:           c.openFiles,
-		inferredProject:     c.inferredProject,
-		fileDefaultProjects: c.fileDefaultProjects,
-		apiState:            c.apiState,
+		toPath:                                   c.toPath,
+		configFileRegistry:                       c.configFileRegistry,
+		configuredProjects:                       c.configuredProjects,
+		syntheticProjects:                        c.syntheticProjects,
+		openFiles:                                c.openFiles,
+		inferredProject:                          c.inferredProject,
+		inferredProjectATAState:                  c.inferredProjectATAState,
+		inferredProjectATAInvalidationSnapshotID: c.inferredProjectATAInvalidationSnapshotID,
+		fileDefaultProjects:                      c.fileDefaultProjects,
+		apiState:                                 c.apiState,
 	}
 }