perf(kotlin): one fact read per file, edges only where resolved

The JVM builder reread and reparsed a Kotlin file for every fragment
and asked the resolver for the same definition once per use; the base
side of a range spawned `git show` per file and per changed definition.
Facts now come from the resolver's cache, uses are found by binary
search on line, a definition is resolved once per fragment, base reads
go through one `git cat-file --batch`, and a project lookup memoises
every directory it walks. Impact on the 35-file yay-tsa commit
31935cdd7: 3.2 s -> 1.8 s warm.

Output change: a Kotlin member use now links in the context graph only
to the definition it resolves to. A candidate (untyped receiver,
overload, dispatch) suggests in impact; it no longer adds an edge.

Claude-Session: https://claude.ai/code/session_0176zGy9cjNvwmtiRJLjDcKp

Author: nikolay-e

CHANGELOG.md

@@ -34,7 +34,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   implementations of a changed abstract member are their own relation, a
   removed declaration is found by comparing the file's declarations at the
   base and the head, and a public contract changes when the header does —
-  parameter defaults and all.
+  parameter defaults and all. In the context graph a Kotlin member use links
+  only to the definition it resolves to: a candidate suggests, it does not
+  link.
 
 ### Fixed
 

crates/diffctx-native/src/edges/semantic/jvm.rs

@@ -494,10 +494,6 @@ impl EdgeBuilder for JVMEdgeBuilder {
             return FxHashMap::default();
         };
         let source = crate::source::current();
-        let kotlin_facts = |f: &Fragment| {
-            crate::source::read_to_string(Path::new(f.path()))
-                .and_then(|text| crate::facts::kotlin::facts(&text))
-        };
 
         let import_weight = EDGE_WEIGHTS["jvm_import"].forward;
         let inheritance_weight = EDGE_WEIGHTS["jvm_inheritance"].forward;
@@ -771,9 +767,10 @@ impl EdgeBuilder for JVMEdgeBuilder {
         }
 
         // Kotlin users bind through their syntax facts: a member use links to
-        // the definitions the Kotlin binding model does not reject, whatever
-        // the length of the name, and a spelling in a string or a comment,
-        // or a receiver of another type, links nothing.
+        // the definitions the Kotlin binding model resolves it to, whatever
+        // the length of the name. A candidate (an untyped receiver, an
+        // overload) is no edge — a guess suggests, it does not link — and a
+        // spelling in a string or a comment links nothing.
         let kotlin_defs: FxHashMap<&str, Vec<&Fragment>> = {
             let mut m: FxHashMap<&str, Vec<&Fragment>> = FxHashMap::default();
             for f in jvm_frags.iter().filter(|f| is_kotlin(Path::new(f.path()))) {
@@ -795,15 +792,17 @@ impl EdgeBuilder for JVMEdgeBuilder {
                     .map(|r| r.to_string_lossy().replace('\\', "/"))
                     .unwrap_or_else(|_| p.to_string())
             };
+            let mut defs_of: FxHashMap<&FragmentId, Option<crate::kotlin_bindings::KDef>> =
+                FxHashMap::default();
             for jf in jvm_frags.iter().filter(|f| is_kotlin(Path::new(f.path()))) {
-                let Some(facts) = kotlin_facts(jf) else {
+                let user = rel(jf.path());
+                let Some(facts) = resolver.facts(&user) else {
                     continue;
                 };
-                let user = rel(jf.path());
-                let mut names: Vec<&str> = facts
-                    .uses
+                let first = facts.uses.partition_point(|u| u.line < jf.start_line());
+                let mut names: Vec<&str> = facts.uses[first..]
                     .iter()
-                    .filter(|u| u.line >= jf.start_line() && u.line <= jf.end_line())
+                    .take_while(|u| u.line <= jf.end_line())
                     .map(|u| u.name.as_str())
                     .collect();
                 names.sort_unstable();
@@ -820,13 +819,18 @@ impl EdgeBuilder for JVMEdgeBuilder {
                         if d.id == jf.id || crate::container::within(&jf.id, d) {
                             continue;
                         }
-                        let Some(def) = resolver.definition(&rel(d.path()), name, d.start_line())
+                        let Some(def) = defs_of
+                            .entry(&d.id)
+                            .or_insert_with(|| {
+                                resolver.definition(&rel(d.path()), name, d.start_line())
+                            })
+                            .as_ref()
                         else {
                             continue;
                         };
                         if resolver
-                            .classify(&user, (jf.start_line(), jf.end_line()), &def)
-                            .is_some()
+                            .classify(&user, (jf.start_line(), jf.end_line()), def)
+                            .is_some_and(|f| f.evidence == crate::bindings::Evidence::Resolved)
                         {
                             add_edge(&mut edges, &jf.id, &d.id, member_weight, reverse_factor);
                         }

crates/diffctx-native/src/kotlin_bindings.rs

@@ -73,6 +73,11 @@ pub struct KotlinResolver<'a> {
     root: &'a Path,
     source: &'a Source,
     facts: RefCell<FxHashMap<String, Option<Arc<KotlinFacts>>>>,
+    /// Facts of other revisions, by (revision, path): the base side of a
+    /// range is asked for once per changed definition.
+    facts_at: RefCell<FxHashMap<(String, String), Option<Arc<KotlinFacts>>>>,
+    /// One `git cat-file --batch` for those reads, not a process per file.
+    batch: RefCell<Option<crate::git::CatFileBatch>>,
     type_files: RefCell<FxHashMap<String, Vec<String>>>,
     projects: RefCell<FxHashMap<PathBuf, Option<PathBuf>>>,
     deps: RefCell<FxHashMap<PathBuf, Vec<PathBuf>>>,
@@ -84,6 +89,8 @@ impl<'a> KotlinResolver<'a> {
             root,
             source,
             facts: RefCell::default(),
+            facts_at: RefCell::default(),
+            batch: RefCell::default(),
             type_files: RefCell::default(),
             projects: RefCell::default(),
             deps: RefCell::default(),
@@ -120,8 +127,23 @@ impl<'a> KotlinResolver<'a> {
 
     /// The facts of `rel` at another revision of the repository.
     pub fn facts_at(&self, rev: &str, rel: &str) -> Option<Arc<KotlinFacts>> {
-        let text = crate::git::show_file_at_revision(self.root, rev, Path::new(rel)).ok()?;
-        crate::facts::kotlin::facts(&text)
+        let key = (rev.to_string(), rel.to_string());
+        if let Some(known) = self.facts_at.borrow().get(&key) {
+            return known.clone();
+        }
+        let read = {
+            let mut batch = self.batch.borrow_mut();
+            if batch.is_none() {
+                *batch = crate::git::CatFileBatch::new(self.root).ok();
+            }
+            batch
+                .as_mut()
+                .and_then(|b| b.get(rev, Path::new(rel)).ok())
+                .or_else(|| crate::git::show_file_at_revision(self.root, rev, Path::new(rel)).ok())
+        }
+        .and_then(|text| crate::facts::kotlin::facts(&text));
+        self.facts_at.borrow_mut().insert(key, read.clone());
+        read
     }
 
     /// The lines of `rel` where a use could reach `def` by spelling: its
@@ -147,10 +169,11 @@ impl<'a> KotlinResolver<'a> {
         let facts = self.facts(rel)?;
         let names = self.names_for(&facts, def);
         let mut best: Option<Finding> = None;
-        for u in facts
-            .uses
+        let first = facts.uses.partition_point(|u| u.line < lines.0);
+        for u in facts.uses[first..]
             .iter()
-            .filter(|u| u.line >= lines.0 && u.line <= lines.1 && names.contains(&u.name))
+            .take_while(|u| u.line <= lines.1)
+            .filter(|u| names.contains(&u.name))
         {
             // The definition's own declaration is no use of it.
             if rel == def.path && def.decl.span.contains(&u.at) {
@@ -802,11 +825,14 @@ impl<'a> KotlinResolver<'a> {
     /// above it holding a build file.
     fn project_of(&self, rel: &str) -> Option<PathBuf> {
         let mut dir = Path::new(rel).parent()?.to_path_buf();
-        let start = dir.clone();
-        if let Some(known) = self.projects.borrow().get(&start) {
-            return known.clone();
-        }
+        // Every directory walked through shares the answer, so a sibling
+        // file stops at the first directory already asked about.
+        let mut walked: Vec<PathBuf> = Vec::new();
         let found = loop {
+            if let Some(known) = self.projects.borrow().get(&dir) {
+                break known.clone();
+            }
+            walked.push(dir.clone());
             let has_build = ["build.gradle.kts", "build.gradle", "pom.xml"]
                 .iter()
                 .any(|b| {
@@ -821,7 +847,10 @@ impl<'a> KotlinResolver<'a> {
                 break None;
             }
         };
-        self.projects.borrow_mut().insert(start, found.clone());
+        let mut projects = self.projects.borrow_mut();
+        for d in walked {
+            projects.insert(d, found.clone());
+        }
         found
     }