wild idea

Author: jakebailey

internal/compiler/fileloader.go

@@ -138,8 +138,10 @@ func processAllProgramFiles(
 			CurrentDirectory:          opts.Host.GetCurrentDirectory(),
 		},
 		filesParser: &filesParser{
-			wg:       core.NewThrottledWorkGroup(singleThreaded),
-			maxDepth: maxNodeModuleJsDepth,
+			wg:         core.NewWorkGroup(singleThreaded),
+			resolveSem: core.NewSemaphore(singleThreaded),
+			parseSem:   core.NewSemaphore(singleThreaded),
+			maxDepth:   maxNodeModuleJsDepth,
 		},
 		rootTasks:           make([]*parseTask, 0, len(rootFiles)+len(compilerOptions.Lib)),
 		supportedExtensions: supportedExtensions,
@@ -268,7 +270,7 @@ func (p *fileLoader) addProjectReferenceTasks(singleThreaded bool) {
 
 	parser := &projectReferenceParser{
 		loader: p,
-		wg:     core.NewThrottledWorkGroup(singleThreaded),
+		wg:     core.NewWorkGroup(singleThreaded),
 	}
 	rootTasks := createProjectReferenceParseTasks(projectReferences)
 	parser.parse(rootTasks)

internal/compiler/filesparser.go

@@ -102,17 +102,26 @@ func (t *parseTask) load(loader *fileLoader) {
 		// to avoid adding spurious lookups to file watcher tracking.
 		t.metadata = ast.SourceFileMetaData{ImpliedNodeFormat: core.ResolutionModeCommonJS}
 	} else {
+		// Resolution: load metadata (package.json lookups involve stat calls).
+		loader.filesParser.resolveSem.Acquire()
 		t.metadata = loader.loadSourceFileMetaData(t.normalizedFilePath)
+		loader.filesParser.resolveSem.Release()
 	}
 
+	// Parsing: parse the source file (CPU-heavy).
+	loader.filesParser.parseSem.Acquire()
 	file := loader.parseSourceFile(t)
+	loader.filesParser.parseSem.Release()
 	if file == nil {
 		return
 	}
 
 	t.file = file
 	t.subTasks = make([]*parseTask, 0, len(file.ReferencedFiles)+len(file.Imports())+len(file.ModuleAugmentations))
 
+	// Resolution: resolve references, type directives, and imports (stat-heavy).
+	loader.filesParser.resolveSem.Acquire()
+
 	compilerOptions := loader.opts.Config.CompilerOptions()
 	if !compilerOptions.NoResolve.IsTrue() {
 		for index, ref := range file.ReferencedFiles {
@@ -152,6 +161,8 @@ func (t *parseTask) load(loader *fileLoader) {
 	}
 
 	loader.resolveImportsAndModuleAugmentations(t)
+
+	loader.filesParser.resolveSem.Release()
 }
 
 func (t *parseTask) redirect(loader *fileLoader, fileName string) {
@@ -165,6 +176,8 @@ func (t *parseTask) redirect(loader *fileLoader, fileName string) {
 }
 
 func (t *parseTask) loadAutomaticTypeDirectives(loader *fileLoader) {
+	loader.filesParser.resolveSem.Acquire()
+	defer loader.filesParser.resolveSem.Release()
 	toParseTypeRefs, typeResolutionsInFile, typeResolutionsTrace, pDiagnostics := loader.resolveAutomaticTypeDirectives(t.normalizedFilePath)
 	t.typeResolutionsInFile = typeResolutionsInFile
 	t.typeResolutionsTrace = typeResolutionsTrace
@@ -197,6 +210,8 @@ func (t *parseTask) addSubTask(ref resolvedRef, libFile *LibFile) {
 
 type filesParser struct {
 	wg             core.WorkGroup
+	resolveSem     *core.Semaphore
+	parseSem       *core.Semaphore
 	taskDataByPath collections.SyncMap[tspath.Path, *parseTaskData]
 	maxDepth       int
 }

internal/core/workgroup.go

@@ -36,6 +36,38 @@ func NewThrottledWorkGroup(singleThreaded bool) WorkGroup {
 	}
 }
 
+// Semaphore limits concurrent access to a resource.
+// A nil *Semaphore is valid and performs no limiting;
+// callers are expected to arrange sequential execution themselves
+// when no semaphore is provided.
+type Semaphore struct {
+	ch chan struct{}
+}
+
+// NewSemaphore creates a Semaphore sized to GOMAXPROCS.
+// Returns nil when singleThreaded is true, as the caller's WorkGroup
+// already ensures sequential execution.
+func NewSemaphore(singleThreaded bool) *Semaphore {
+	if singleThreaded {
+		return nil
+	}
+	return &Semaphore{ch: make(chan struct{}, runtime.GOMAXPROCS(0))}
+}
+
+// Acquire blocks until a slot is available.
+func (s *Semaphore) Acquire() {
+	if s != nil {
+		s.ch <- struct{}{}
+	}
+}
+
+// Release frees a slot.
+func (s *Semaphore) Release() {
+	if s != nil {
+		<-s.ch
+	}
+}
+
 type parallelWorkGroup struct {
 	done atomic.Bool
 	wg   sync.WaitGroup