resolve: add cross-file candidate stats + tests for ResolveEdgesForNames

internal/indexer/indexer.go

@@ -593,12 +593,15 @@ func (i *Indexer) run(ctx context.Context, opts Options) (store.ScanSummary, err
 				names = append(names, name)
 			}
 			crossStart := time.Now()
-			n, err := i.store.ResolveEdgesForNames(ctx, repo.ID, names)
+			stats, err := i.store.ResolveEdgesForNamesWithStats(ctx, repo.ID, names)
 			if err != nil {
 				_ = i.store.CompleteScan(ctx, scanID, summary, started, "failed", err.Error())
 				return summary, err
 			}
-			summary.ResolveCrossFileTargets = n
+			if stats != (store.ResolveEdgesForNamesStats{}) {
+				summary.ResolveCrossFile = &stats
+			}
+			summary.ResolveCrossFileTargets = stats.TargetsSelected
 			summary.ResolveCrossFileMS = time.Since(crossStart).Milliseconds()
 			summary.ResolveMode = "paths+names"
 		}

internal/store/cross_file_resolution_test.go

@@ -0,0 +1,60 @@
+package store_test
+
+import (
+	"context"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/isink17/codegraph/internal/indexer"
+	"github.com/isink17/codegraph/internal/parser"
+	goparser "github.com/isink17/codegraph/internal/parser/golang"
+	"github.com/isink17/codegraph/internal/store"
+)
+
+func TestCrossFileResolution_PartialRunIntroducedSymbolResolvesOtherFile(t *testing.T) {
+	ctx := context.Background()
+	repoRoot := t.TempDir()
+
+	if err := os.WriteFile(filepath.Join(repoRoot, "b.go"), []byte("package main\nfunc Bar() { Foo() }\n"), 0o644); err != nil {
+		t.Fatalf("WriteFile(b.go) error = %v", err)
+	}
+
+	dbPath := filepath.Join(t.TempDir(), "graph.sqlite")
+	s, err := store.Open(dbPath)
+	if err != nil {
+		t.Fatalf("store.Open() error = %v", err)
+	}
+	defer s.Close()
+
+	idx := indexer.New(s, parser.NewRegistry(goparser.New()), nil)
+	if _, err := idx.Index(ctx, indexer.Options{RepoRoot: repoRoot}); err != nil {
+		t.Fatalf("Index() error = %v", err)
+	}
+
+	if err := os.WriteFile(filepath.Join(repoRoot, "a.go"), []byte("package main\nfunc Foo() {}\n"), 0o644); err != nil {
+		t.Fatalf("WriteFile(a.go) error = %v", err)
+	}
+	summary, err := idx.Update(ctx, indexer.Options{RepoRoot: repoRoot, Paths: []string{"a.go"}})
+	if err != nil {
+		t.Fatalf("Update() error = %v", err)
+	}
+	if summary.ResolveMode != "paths+names" {
+		t.Fatalf("ResolveMode = %q, want %q", summary.ResolveMode, "paths+names")
+	}
+	if summary.ResolveCrossFile == nil || summary.ResolveCrossFile.TargetsSelected == 0 {
+		t.Fatalf("ResolveCrossFile stats missing or empty: %#v", summary.ResolveCrossFile)
+	}
+
+	repo, err := s.UpsertRepo(ctx, repoRoot)
+	if err != nil {
+		t.Fatalf("UpsertRepo() error = %v", err)
+	}
+	unresolved, err := s.CountUnresolvedEdgesByDstName(ctx, repo.ID, "Foo")
+	if err != nil {
+		t.Fatalf("CountUnresolvedEdgesByDstName() error = %v", err)
+	}
+	if unresolved != 0 {
+		t.Fatalf("unresolved edges for Foo = %d, want 0", unresolved)
+	}
+}

internal/store/resolve_edges_for_names_test.go

@@ -0,0 +1,152 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"path/filepath"
+	"testing"
+)
+
+func TestResolveEdgesForNames_ExactName(t *testing.T) {
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "graph.sqlite")
+	s, err := Open(dbPath)
+	if err != nil {
+		t.Fatalf("Open() error = %v", err)
+	}
+	defer s.Close()
+
+	repo, err := s.UpsertRepo(ctx, t.TempDir())
+	if err != nil {
+		t.Fatalf("UpsertRepo() error = %v", err)
+	}
+
+	fileA, err := insertTestFile(ctx, s, repo.ID, "a.go")
+	if err != nil {
+		t.Fatalf("insertTestFile(a.go) error = %v", err)
+	}
+	fileB, err := insertTestFile(ctx, s, repo.ID, "b.go")
+	if err != nil {
+		t.Fatalf("insertTestFile(b.go) error = %v", err)
+	}
+
+	dstID, err := insertTestSymbol(ctx, s, repo.ID, fileA, "Foo", "Foo")
+	if err != nil {
+		t.Fatalf("insertTestSymbol(dst) error = %v", err)
+	}
+	srcID, err := insertTestSymbol(ctx, s, repo.ID, fileB, "Bar", "Bar")
+	if err != nil {
+		t.Fatalf("insertTestSymbol(src) error = %v", err)
+	}
+	edgeID, err := insertTestEdge(ctx, s, repo.ID, fileB, srcID, "Foo")
+	if err != nil {
+		t.Fatalf("insertTestEdge() error = %v", err)
+	}
+
+	stats, err := s.ResolveEdgesForNamesWithStats(ctx, repo.ID, []string{"Foo"})
+	if err != nil {
+		t.Fatalf("ResolveEdgesForNamesWithStats() error = %v", err)
+	}
+	if stats.TargetsSelected != 1 {
+		t.Fatalf("TargetsSelected = %d, want 1", stats.TargetsSelected)
+	}
+	if stats.ExactHits != 1 {
+		t.Fatalf("ExactHits = %d, want 1", stats.ExactHits)
+	}
+
+	var gotDst sql.NullInt64
+	if err := s.db.QueryRowContext(ctx, `SELECT dst_symbol_id FROM edges WHERE id = ?`, edgeID).Scan(&gotDst); err != nil {
+		t.Fatalf("QueryRow(dst_symbol_id) error = %v", err)
+	}
+	if !gotDst.Valid || gotDst.Int64 != dstID {
+		t.Fatalf("dst_symbol_id = (%v,%d), want (%v,%d)", gotDst.Valid, gotDst.Int64, true, dstID)
+	}
+}
+
+func TestResolveEdgesForNames_QualifiedSuffix(t *testing.T) {
+	ctx := context.Background()
+	dbPath := filepath.Join(t.TempDir(), "graph.sqlite")
+	s, err := Open(dbPath)
+	if err != nil {
+		t.Fatalf("Open() error = %v", err)
+	}
+	defer s.Close()
+
+	repo, err := s.UpsertRepo(ctx, t.TempDir())
+	if err != nil {
+		t.Fatalf("UpsertRepo() error = %v", err)
+	}
+	fileA, err := insertTestFile(ctx, s, repo.ID, "a.go")
+	if err != nil {
+		t.Fatalf("insertTestFile(a.go) error = %v", err)
+	}
+	fileB, err := insertTestFile(ctx, s, repo.ID, "b.go")
+	if err != nil {
+		t.Fatalf("insertTestFile(b.go) error = %v", err)
+	}
+
+	dstID, err := insertTestSymbol(ctx, s, repo.ID, fileA, "Foo", "pkg.Foo")
+	if err != nil {
+		t.Fatalf("insertTestSymbol(dst) error = %v", err)
+	}
+	srcID, err := insertTestSymbol(ctx, s, repo.ID, fileB, "Bar", "Bar")
+	if err != nil {
+		t.Fatalf("insertTestSymbol(src) error = %v", err)
+	}
+	edgeID, err := insertTestEdge(ctx, s, repo.ID, fileB, srcID, "pkg.Foo")
+	if err != nil {
+		t.Fatalf("insertTestEdge() error = %v", err)
+	}
+
+	stats, err := s.ResolveEdgesForNamesWithStats(ctx, repo.ID, []string{"Foo"})
+	if err != nil {
+		t.Fatalf("ResolveEdgesForNamesWithStats() error = %v", err)
+	}
+	if stats.TargetsSelected != 1 {
+		t.Fatalf("TargetsSelected = %d, want 1", stats.TargetsSelected)
+	}
+	if stats.SuffixHits != 1 {
+		t.Fatalf("SuffixHits = %d, want 1", stats.SuffixHits)
+	}
+
+	var gotDst sql.NullInt64
+	if err := s.db.QueryRowContext(ctx, `SELECT dst_symbol_id FROM edges WHERE id = ?`, edgeID).Scan(&gotDst); err != nil {
+		t.Fatalf("QueryRow(dst_symbol_id) error = %v", err)
+	}
+	if !gotDst.Valid || gotDst.Int64 != dstID {
+		t.Fatalf("dst_symbol_id = (%v,%d), want (%v,%d)", gotDst.Valid, gotDst.Int64, true, dstID)
+	}
+}
+
+func insertTestFile(ctx context.Context, s *Store, repoID int64, path string) (int64, error) {
+	res, err := s.db.ExecContext(ctx, `INSERT INTO files(repo_id, path, language, indexed_at) VALUES(?, ?, ?, '')`, repoID, path, "go")
+	if err != nil {
+		return 0, err
+	}
+	return res.LastInsertId()
+}
+
+func insertTestSymbol(ctx context.Context, s *Store, repoID, fileID int64, name, qualified string) (int64, error) {
+	res, err := s.db.ExecContext(ctx, `
+		INSERT INTO symbols(
+			repo_id, file_id, language, kind, name, qualified_name,
+			start_line, start_col, end_line, end_col, stable_key
+		)
+		VALUES(?, ?, ?, ?, ?, ?, 1, 1, 1, 1, ?)
+	`, repoID, fileID, "go", "function", name, qualified, qualified)
+	if err != nil {
+		return 0, err
+	}
+	return res.LastInsertId()
+}
+
+func insertTestEdge(ctx context.Context, s *Store, repoID, fileID, srcSymbolID int64, dstName string) (int64, error) {
+	res, err := s.db.ExecContext(ctx, `
+		INSERT INTO edges(repo_id, src_symbol_id, dst_symbol_id, dst_name, edge_kind, evidence, file_id, line)
+		VALUES(?, ?, NULL, ?, 'call', '', ?, 1)
+	`, repoID, srcSymbolID, dstName, fileID)
+	if err != nil {
+		return 0, err
+	}
+	return res.LastInsertId()
+}