fix(progress): report polyglot analysis per file

Author: 12ya

internal/build/build.go

@@ -84,7 +84,12 @@ func RunWithCache(ctx context.Context, root string, cfg config.Config, progress
 				}
 				progress(Progress{Stage: stage, Path: unit.files[0].Path, Completed: completed, Total: len(scanResult.Files)})
 			}
-			analysis, err := analyzeWithCache(ctx, cache, analyzerIdentity(language, cfg), unit.name, analyzer, scanResult.Root, unit.files, status)
+			fileProgress := func(path string, unitCompleted int) {
+				if progress != nil {
+					progress(Progress{Stage: "Analyzing " + language, Path: path, Completed: completed + unitCompleted, Total: len(scanResult.Files)})
+				}
+			}
+			analysis, err := analyzeWithCache(ctx, cache, analyzerIdentity(language, cfg), unit.name, analyzer, scanResult.Root, unit.files, status, fileProgress)
 			if err != nil {
 				return Result{}, err
 			}
@@ -141,7 +146,7 @@ func boolString(value bool) string {
 	return "false"
 }
 
-func analyzeWithCache(ctx context.Context, cache *analysisCache, identity, unit string, analyzer lang.Analyzer, root string, files []scan.File, status func(cached bool)) (*lang.AnalysisResult, error) {
+func analyzeWithCache(ctx context.Context, cache *analysisCache, identity, unit string, analyzer lang.Analyzer, root string, files []scan.File, status func(cached bool), fileProgress func(path string, completed int)) (*lang.AnalysisResult, error) {
 	if err := ctx.Err(); err != nil {
 		return nil, err
 	}
@@ -155,7 +160,7 @@ func analyzeWithCache(ctx context.Context, cache *analysisCache, identity, unit
 			return result, nil
 		}
 		status(false)
-		result, err := analyzer.Analyze(ctx, root, files)
+		result, err := analyze(ctx, analyzer, root, files, fileProgress)
 		if err != nil {
 			return nil, err
 		}
@@ -165,10 +170,17 @@ func analyzeWithCache(ctx context.Context, cache *analysisCache, identity, unit
 		return result, nil
 	}
 	status(false)
-	result, err := analyzer.Analyze(ctx, root, files)
+	result, err := analyze(ctx, analyzer, root, files, fileProgress)
 	return result, err
 }
 
+func analyze(ctx context.Context, analyzer lang.Analyzer, root string, files []scan.File, progress func(path string, completed int)) (*lang.AnalysisResult, error) {
+	if progressive, ok := analyzer.(lang.ProgressAnalyzer); ok {
+		return progressive.AnalyzeWithProgress(ctx, root, files, progress)
+	}
+	return analyzer.Analyze(ctx, root, files)
+}
+
 func addFileTopology(builder *graph.Builder, scanResult scan.Result) {
 	builder.AddNode(graph.Node{ID: graph.DirID("."), Kind: graph.NodeDir, Name: ".", Path: ".", Meta: topologyMeta(".")})
 	builder.AddEdge(graph.Edge{Kind: graph.EdgeContains, From: graph.RepoID(), To: graph.DirID("."), Meta: topologyMeta(".")})

internal/build/build_test.go

@@ -88,6 +88,51 @@ func TestRunBuildsAndCanDisablePolyglotGraph(t *testing.T) {
 	}
 }
 
+func TestRunReportsPerFilePolyglotProgress(t *testing.T) {
+	root := t.TempDir()
+	for _, name := range []string{"App.swift", "Feature.swift"} {
+		if err := os.WriteFile(filepath.Join(root, name), []byte("func run() {}\n"), 0o644); err != nil {
+			t.Fatal(err)
+		}
+	}
+	cfg := config.Default()
+	cfg.Analysis.Go = false
+	cfg.Analysis.Documents = false
+	cfg.Analysis.Schemas = false
+	var events []Progress
+	_, err := RunWithProgress(context.Background(), root, cfg, func(event Progress) {
+		if event.Stage == "Analyzing swift" {
+			events = append(events, event)
+		}
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(events) < 3 {
+		t.Fatalf("Swift progress events = %#v, want start, per-file, and completion events", events)
+	}
+	want := []struct {
+		path      string
+		completed int
+	}{
+		{path: "App.swift", completed: 0},
+		{path: "Feature.swift", completed: 1},
+		{path: "Feature.swift", completed: 2},
+	}
+	for _, expected := range want {
+		found := false
+		for _, event := range events {
+			if event.Path == expected.path && event.Completed == expected.completed && event.Total == 2 {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("missing progress path=%q completed=%d in %#v", expected.path, expected.completed, events)
+		}
+	}
+}
+
 func TestRunWithCacheReusesAndInvalidatesMarkdownFilesIndependently(t *testing.T) {
 	root := t.TempDir()
 	for name, content := range map[string]string{

internal/lang/analyzer.go

@@ -18,3 +18,10 @@ type Analyzer interface {
 	Extensions() []string
 	Analyze(ctx context.Context, root string, files []scan.File) (*AnalysisResult, error)
 }
+
+// ProgressAnalyzer reports the file currently being analyzed while preserving
+// a language-wide analysis unit for cross-file relationship resolution.
+type ProgressAnalyzer interface {
+	Analyzer
+	AnalyzeWithProgress(ctx context.Context, root string, files []scan.File, progress func(path string, completed int)) (*AnalysisResult, error)
+}

internal/lang/treeanalyzer/analyzer.go

@@ -104,12 +104,19 @@ type reference struct {
 }
 
 func (a *Analyzer) Analyze(ctx context.Context, _ string, files []scan.File) (*lang.AnalysisResult, error) {
+	return a.AnalyzeWithProgress(ctx, "", files, nil)
+}
+
+func (a *Analyzer) AnalyzeWithProgress(ctx context.Context, _ string, files []scan.File, progress func(path string, completed int)) (*lang.AnalysisResult, error) {
 	result := &lang.AnalysisResult{}
 	parsed := make([]parsedFile, 0, len(files))
-	for _, file := range files {
+	for i, file := range files {
 		if err := ctx.Err(); err != nil {
 			return nil, err
 		}
+		if progress != nil {
+			progress(file.Path, i)
+		}
 		entry := entryForFile(a.language, file.Path)
 		if entry == nil || entry.Language == nil {
 			continue
@@ -121,6 +128,9 @@ func (a *Analyzer) Analyze(ctx context.Context, _ string, files []scan.File) (*l
 		}
 		parsed = append(parsed, pf)
 	}
+	if progress != nil && len(files) > 0 {
+		progress(files[len(files)-1].Path, len(files))
+	}
 
 	emitDefinitions(parsed, result)
 	emitReferences(parsed, result)