Add locks on concurrent alias following checker accesses under incremental mode

internal/compiler/checkerpool.go

@@ -13,7 +13,8 @@ import (
 
 type CheckerPool interface {
 	GetChecker(ctx context.Context) (*checker.Checker, func())
-	GetCheckerForFile(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func())
+	GetCheckerForFileNonexclusive(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func())
+	GetCheckerForFileExclusive(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func())
 	GetAllCheckers(ctx context.Context) ([]*checker.Checker, func())
 	Files(checker *checker.Checker) iter.Seq[*ast.SourceFile]
 }
@@ -24,6 +25,7 @@ type checkerPool struct {
 
 	createCheckersOnce sync.Once
 	checkers           []*checker.Checker
+	locks              []sync.Mutex
 	fileAssociations   map[*ast.SourceFile]*checker.Checker
 }
 
@@ -34,17 +36,28 @@ func newCheckerPool(checkerCount int, program *Program) *checkerPool {
 		program:      program,
 		checkerCount: checkerCount,
 		checkers:     make([]*checker.Checker, checkerCount),
+		locks:        make([]sync.Mutex, checkerCount),
 	}
 
 	return pool
 }
 
-func (p *checkerPool) GetCheckerForFile(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) {
+func (p *checkerPool) GetCheckerForFileNonexclusive(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) {
 	p.createCheckers()
 	checker := p.fileAssociations[file]
 	return checker, noop
 }
 
+func (p *checkerPool) GetCheckerForFileExclusive(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) {
+	c, done := p.GetCheckerForFileNonexclusive(ctx, file)
+	idx := slices.Index(p.checkers, c)
+	p.locks[idx].Lock()
+	return c, sync.OnceFunc(func() {
+		p.locks[idx].Unlock()
+		done()
+	})
+}
+
 func (p *checkerPool) GetChecker(ctx context.Context) (*checker.Checker, func()) {
 	p.createCheckers()
 	checker := p.checkers[0]

internal/compiler/emitHost.go

@@ -35,7 +35,7 @@ type emitHost struct {
 }
 
 func newEmitHost(ctx context.Context, program *Program, file *ast.SourceFile) (*emitHost, func()) {
-	checker, done := program.GetTypeCheckerForFile(ctx, file)
+	checker, done := program.GetTypeCheckerForFileNonexclusive(ctx, file)
 	return &emitHost{
 		program:      program,
 		emitResolver: checker.GetEmitResolver(),

internal/compiler/program.go

@@ -379,8 +379,14 @@ func (p *Program) GetTypeCheckers(ctx context.Context) ([]*checker.Checker, func
 // method returns the checker that was tasked with checking the file. Note that it isn't possible to mix
 // types obtained from different checkers, so only non-type data (such as diagnostics or string
 // representations of types) should be obtained from checkers returned by this method.
-func (p *Program) GetTypeCheckerForFile(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) {
-	return p.checkerPool.GetCheckerForFile(ctx, file)
+func (p *Program) GetTypeCheckerForFileNonexclusive(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) {
+	return p.checkerPool.GetCheckerForFileNonexclusive(ctx, file)
+}
+
+// Return a checker for the given file, locked to the current thread to prevent data races from multiple threads
+// accessing the same checker. The lock will be released when the `done` function is called.
+func (p *Program) GetTypeCheckerForFileExclusive(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) {
+	return p.checkerPool.GetCheckerForFileExclusive(ctx, file)
 }
 
 func (p *Program) GetResolvedModule(file ast.HasFileName, moduleReference string, mode core.ResolutionMode) *module.ResolvedModule {
@@ -1023,7 +1029,7 @@ func (p *Program) getSemanticDiagnosticsForFileNotFilter(ctx context.Context, so
 	var fileChecker *checker.Checker
 	var done func()
 	if sourceFile != nil {
-		fileChecker, done = p.checkerPool.GetCheckerForFile(ctx, sourceFile)
+		fileChecker, done = p.checkerPool.GetCheckerForFileNonexclusive(ctx, sourceFile)
 		defer done()
 	}
 	diags := slices.Clip(sourceFile.BindDiagnostics())
@@ -1128,7 +1134,7 @@ func (p *Program) getSuggestionDiagnosticsForFile(ctx context.Context, sourceFil
 	var fileChecker *checker.Checker
 	var done func()
 	if sourceFile != nil {
-		fileChecker, done = p.checkerPool.GetCheckerForFile(ctx, sourceFile)
+		fileChecker, done = p.checkerPool.GetCheckerForFileNonexclusive(ctx, sourceFile)
 		defer done()
 	}
 
@@ -1273,6 +1279,10 @@ func (p *Program) InstantiationCount() int {
 	return count
 }
 
+func (p *Program) Program() *Program {
+	return p
+}
+
 func (p *Program) GetSourceFileMetaData(path tspath.Path) ast.SourceFileMetaData {
 	return p.sourceFileMetaDatas[path]
 }
@@ -1437,6 +1447,7 @@ func CombineEmitResults(results []*EmitResult) *EmitResult {
 
 type ProgramLike interface {
 	Options() *core.CompilerOptions
+	GetSourceFile(path string) *ast.SourceFile
 	GetSourceFiles() []*ast.SourceFile
 	GetConfigFileParsingDiagnostics() []*ast.Diagnostic
 	GetSyntacticDiagnostics(ctx context.Context, file *ast.SourceFile) []*ast.Diagnostic
@@ -1446,7 +1457,11 @@ type ProgramLike interface {
 	GetGlobalDiagnostics(ctx context.Context) []*ast.Diagnostic
 	GetSemanticDiagnostics(ctx context.Context, file *ast.SourceFile) []*ast.Diagnostic
 	GetDeclarationDiagnostics(ctx context.Context, file *ast.SourceFile) []*ast.Diagnostic
+	GetSuggestionDiagnostics(ctx context.Context, file *ast.SourceFile) []*ast.Diagnostic
 	Emit(ctx context.Context, options EmitOptions) *EmitResult
+	CommonSourceDirectory() string
+	IsSourceFileDefaultLibrary(path tspath.Path) bool
+	Program() *Program
 }
 
 func HandleNoEmitOnError(ctx context.Context, program ProgramLike, file *ast.SourceFile) *EmitResult {

internal/execute/incremental/affectedfileshandler.go

@@ -229,7 +229,7 @@ func (h *affectedFilesHandler) handleDtsMayChangeOfAffectedFile(dtsMayChange dts
 				break
 			}
 			if typeChecker == nil {
-				typeChecker, done = h.program.program.GetTypeCheckerForFile(h.ctx, affectedFile)
+				typeChecker, done = h.program.program.GetTypeCheckerForFileExclusive(h.ctx, affectedFile)
 			}
 			aliased := checker.SkipAlias(exported, typeChecker)
 			if aliased == exported {

internal/execute/incremental/program.go

@@ -84,12 +84,36 @@ func (p *Program) Options() *core.CompilerOptions {
 	return p.snapshot.options
 }
 
+// CommonSourceDirectory implements compiler.AnyProgram interface.
+func (p *Program) CommonSourceDirectory() string {
+	p.panicIfNoProgram("CommonSourceDirectory")
+	return p.program.CommonSourceDirectory()
+}
+
+// Program implements compiler.AnyProgram interface.
+func (p *Program) Program() *compiler.Program {
+	p.panicIfNoProgram("Program")
+	return p.program
+}
+
+// IsSourceFileDefaultLibrary implements compiler.AnyProgram interface.
+func (p *Program) IsSourceFileDefaultLibrary(path tspath.Path) bool {
+	p.panicIfNoProgram("IsSourceFileDefaultLibrary")
+	return p.program.IsSourceFileDefaultLibrary(path)
+}
+
 // GetSourceFiles implements compiler.AnyProgram interface.
 func (p *Program) GetSourceFiles() []*ast.SourceFile {
 	p.panicIfNoProgram("GetSourceFiles")
 	return p.program.GetSourceFiles()
 }
 
+// GetSourceFile implements compiler.AnyProgram interface.
+func (p *Program) GetSourceFile(path string) *ast.SourceFile {
+	p.panicIfNoProgram("GetSourceFile")
+	return p.program.GetSourceFile(path)
+}
+
 // GetConfigFileParsingDiagnostics implements compiler.AnyProgram interface.
 func (p *Program) GetConfigFileParsingDiagnostics() []*ast.Diagnostic {
 	p.panicIfNoProgram("GetConfigFileParsingDiagnostics")
@@ -172,6 +196,12 @@ func (p *Program) GetDeclarationDiagnostics(ctx context.Context, file *ast.Sourc
 	return nil
 }
 
+// GetSuggestionDiagnostics implements compiler.AnyProgram interface.
+func (p *Program) GetSuggestionDiagnostics(ctx context.Context, file *ast.SourceFile) []*ast.Diagnostic {
+	p.panicIfNoProgram("GetSuggestionDiagnostics")
+	return p.program.GetSuggestionDiagnostics(ctx, file) // TODO: incremental suggestion diagnostics (only relevant in editor incremental builder?)
+}
+
 // GetModeForUsageLocation implements compiler.AnyProgram interface.
 func (p *Program) Emit(ctx context.Context, options compiler.EmitOptions) *compiler.EmitResult {
 	p.panicIfNoProgram("Emit")

internal/execute/incremental/programtosnapshot.go

@@ -263,7 +263,7 @@ func getReferencedFiles(program *compiler.Program, file *ast.SourceFile) *collec
 	// We need to use a set here since the code can contain the same import twice,
 	// but that will only be one dependency.
 	// To avoid invernal conversion, the key of the referencedFiles map must be of type Path
-	checker, done := program.GetTypeCheckerForFile(context.TODO(), file)
+	checker, done := program.GetTypeCheckerForFileExclusive(context.TODO(), file)
 	defer done()
 	for _, importName := range file.Imports() {
 		addReferencedFilesFromImportLiteral(file, &referencedFiles, checker, importName)

internal/ls/api.go

@@ -24,14 +24,14 @@ func (l *LanguageService) GetSymbolAtPosition(ctx context.Context, fileName stri
 	if node == nil {
 		return nil, fmt.Errorf("%w: %s:%d", ErrNoTokenAtPosition, fileName, position)
 	}
-	checker, done := program.GetTypeCheckerForFile(ctx, file)
+	checker, done := program.GetTypeCheckerForFileNonexclusive(ctx, file)
 	defer done()
 	return checker.GetSymbolAtLocation(node), nil
 }
 
 func (l *LanguageService) GetSymbolAtLocation(ctx context.Context, node *ast.Node) *ast.Symbol {
 	program := l.GetProgram()
-	checker, done := program.GetTypeCheckerForFile(ctx, ast.GetSourceFileOfNode(node))
+	checker, done := program.GetTypeCheckerForFileNonexclusive(ctx, ast.GetSourceFileOfNode(node))
 	defer done()
 	return checker.GetSymbolAtLocation(node)
 }

internal/ls/completions.go

@@ -388,7 +388,7 @@ func (l *LanguageService) getCompletionsAtPosition(
 		)
 	}
 
-	checker, done := l.GetProgram().GetTypeCheckerForFile(ctx, file)
+	checker, done := l.GetProgram().GetTypeCheckerForFileNonexclusive(ctx, file)
 	defer done()
 	preferences := l.UserPreferences()
 	data := l.getCompletionData(ctx, checker, file, position, preferences)
@@ -1941,7 +1941,7 @@ func (l *LanguageService) getCompletionEntriesFromSymbols(
 ) (uniqueNames collections.Set[string], sortedEntries []*lsproto.CompletionItem) {
 	closestSymbolDeclaration := getClosestSymbolDeclaration(data.contextToken, data.location)
 	useSemicolons := lsutil.ProbablyUsesSemicolons(file)
-	typeChecker, done := l.GetProgram().GetTypeCheckerForFile(ctx, file)
+	typeChecker, done := l.GetProgram().GetTypeCheckerForFileNonexclusive(ctx, file)
 	defer done()
 	isMemberCompletion := isMemberCompletionKind(data.completionKind)
 	// Tracks unique names.
@@ -5056,7 +5056,7 @@ func (l *LanguageService) getCompletionItemDetails(
 	itemData *CompletionItemData,
 	clientOptions *lsproto.CompletionClientCapabilities,
 ) *lsproto.CompletionItem {
-	checker, done := program.GetTypeCheckerForFile(ctx, file)
+	checker, done := program.GetTypeCheckerForFileNonexclusive(ctx, file)
 	defer done()
 	docFormat := getCompletionDocumentationFormat(clientOptions)
 	contextToken, previousToken := getRelevantTokens(position, file)

internal/ls/definition.go

@@ -26,7 +26,7 @@ func (l *LanguageService) ProvideDefinition(
 	}
 	originSelectionRange := l.createLspRangeFromNode(node, file)
 
-	c, done := program.GetTypeCheckerForFile(ctx, file)
+	c, done := program.GetTypeCheckerForFileNonexclusive(ctx, file)
 	defer done()
 
 	if node.Kind == ast.KindOverrideKeyword {
@@ -77,7 +77,7 @@ func (l *LanguageService) ProvideTypeDefinition(
 	}
 	originSelectionRange := l.createLspRangeFromNode(node, file)
 
-	c, done := program.GetTypeCheckerForFile(ctx, file)
+	c, done := program.GetTypeCheckerForFileNonexclusive(ctx, file)
 	defer done()
 
 	node = getDeclarationNameForKeyword(node)

internal/ls/hover.go

@@ -25,7 +25,7 @@ func (l *LanguageService) ProvideHover(ctx context.Context, documentURI lsproto.
 		// Avoid giving quickInfo for the sourceFile as a whole.
 		return lsproto.HoverOrNull{}, nil
 	}
-	c, done := program.GetTypeCheckerForFile(ctx, file)
+	c, done := program.GetTypeCheckerForFileNonexclusive(ctx, file)
 	defer done()
 	rangeNode := getNodeForQuickInfo(node)
 	quickInfo, documentation := l.getQuickInfoAndDocumentationForSymbol(c, c.GetSymbolAtLocation(node), rangeNode, contentFormat)

internal/ls/inlay_hints.go

@@ -31,7 +31,7 @@ func (l *LanguageService) ProvideInlayHint(
 	program, file := l.getProgramAndFile(params.TextDocument.Uri)
 	quotePreference := getQuotePreference(file, l.UserPreferences())
 
-	checker, done := program.GetTypeCheckerForFile(ctx, file)
+	checker, done := program.GetTypeCheckerForFileNonexclusive(ctx, file)
 	defer done()
 	inlayHintState := &inlayHintState{
 		ctx:             ctx,

internal/ls/signaturehelp.go

@@ -67,7 +67,7 @@ func (l *LanguageService) GetSignatureHelpItems(
 	clientOptions *lsproto.SignatureHelpClientCapabilities,
 	docFormat lsproto.MarkupKind,
 ) *lsproto.SignatureHelp {
-	typeChecker, done := program.GetTypeCheckerForFile(ctx, sourceFile)
+	typeChecker, done := program.GetTypeCheckerForFileNonexclusive(ctx, sourceFile)
 	defer done()
 
 	// Decide whether to show signature help

internal/ls/string_completions.go

@@ -225,7 +225,7 @@ func (l *LanguageService) getStringLiteralCompletionEntries(
 	node *ast.StringLiteralLike,
 	position int,
 ) *stringLiteralCompletions {
-	typeChecker, done := l.GetProgram().GetTypeCheckerForFile(ctx, file)
+	typeChecker, done := l.GetProgram().GetTypeCheckerForFileNonexclusive(ctx, file)
 	defer done()
 	parent := walkUpParentheses(node.Parent)
 	switch parent.Kind {

internal/project/checkerpool.go

@@ -20,6 +20,7 @@ type CheckerPool struct {
 	cond                *sync.Cond
 	createCheckersOnce  sync.Once
 	checkers            []*checker.Checker
+	locks               []sync.Mutex
 	inUse               map[*checker.Checker]bool
 	fileAssociations    map[*ast.SourceFile]int
 	requestAssociations map[string]int
@@ -33,6 +34,7 @@ func newCheckerPool(maxCheckers int, program *compiler.Program, log func(msg str
 		program:             program,
 		maxCheckers:         maxCheckers,
 		checkers:            make([]*checker.Checker, maxCheckers),
+		locks:               make([]sync.Mutex, maxCheckers),
 		inUse:               make(map[*checker.Checker]bool),
 		requestAssociations: make(map[string]int),
 		log:                 log,
@@ -42,7 +44,7 @@ func newCheckerPool(maxCheckers int, program *compiler.Program, log func(msg str
 	return pool
 }
 
-func (p *CheckerPool) GetCheckerForFile(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) {
+func (p *CheckerPool) GetCheckerForFileNonexclusive(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) {
 	p.mu.Lock()
 	defer p.mu.Unlock()
 
@@ -75,6 +77,12 @@ func (p *CheckerPool) GetCheckerForFile(ctx context.Context, file *ast.SourceFil
 	return checker, p.createRelease(requestID, index, checker)
 }
 
+// GetCheckerForFileExclusive is the same as GetCheckerForFile but also locks a mutex associated with the checker.
+// Call `done` to free the lock.
+func (p *CheckerPool) GetCheckerForFileExclusive(ctx context.Context, file *ast.SourceFile) (*checker.Checker, func()) {
+	panic("unimplemented") // implement if used by LS
+}
+
 func (p *CheckerPool) GetChecker(ctx context.Context) (*checker.Checker, func()) {
 	p.mu.Lock()
 	defer p.mu.Unlock()

internal/testrunner/compiler_runner.go

@@ -528,7 +528,8 @@ func createHarnessTestFile(unit *testUnit, currentDirectory string) *harnessutil
 
 func (c *compilerTest) verifyUnionOrdering(t *testing.T) {
 	t.Run("union ordering", func(t *testing.T) {
-		checkers, done := c.result.Program.GetTypeCheckers(t.Context())
+		p := c.result.Program.Program()
+		checkers, done := p.GetTypeCheckers(t.Context())
 		defer done()
 		for _, c := range checkers {
 			for union := range c.UnionTypes() {