feat(rust): enhance AST extraction with scoped function references and sibling file submodule handling

Author: GertL

internal/cachecov/coverage_test.go

@@ -144,6 +144,7 @@ var versionCoverage = map[int][]string{
 	110: {"TestJavaIO_FeignClientMethodPerformsIO", "TestJavaIO_SpringDataRepositoryMethodPerformsIO", "TestJavaIO_QueryAnnotationPerformsIO", "TestJavaIO_PlainServiceMethodNotPerformsIO", "TestJavaIO_ControllerHandlerNotPerformsIO", "TestGolden"}, // Java emits io_direct/performs_io on DB/network round-trips (@FeignClient / Spring Data repository interfaces, @Query/@Modifying/@Procedure, Room @Dao ops) so isExpensiveJvmCall's I/O index is populated on pure-Java; type-level seed avoids the JAX-RS/@GetMapping inbound-handler trap; no transitive fixpoint (GAP-JV-02)
 	111: {"TestGolden", "TestOwnsFile", "TestAST_ImplTraitForType_EmitsImplements"}, // Rust extractor added: symbols, implements post-pass, dependency/calls/route facts, cache participation
 	112: {"TestGolden", "TestAST_CallInsideMacroArgument", "TestAST_MatchesMacroGuardCall", "TestAST_FunctionPassedAsCallbackArgument", "TestAST_OrdinaryArgument_NoPhantomReference", "TestAST_FunctionReferenceInStructField", "TestAST_FunctionReferenceTakenByAddress", "TestAST_SerdeDefaultAttribute_ReferencesFunction", "TestAST_SerdeSkipSerializingIfAttribute_ReferencesFunction", "TestAST_ClapValueParserAttribute_ReferencesFunction", "TestAST_LocalFunctionPassedAsCallbackWithinSameBody", "TestAST_FunctionReferenceNestedInsideMacroArgument"}, // Rust call-reference precision: macro-arg calls, function-as-value references (incl. nested inside a macro arg, e.g. vec![Box::new(f)]), serde/clap attribute refs, stale-owner-pointer fix
+	113: {"TestAST_MergeStrategyAttribute_ReferencesScopedFunction", "TestExtract_UnprefixedUseOfSiblingFileSubmodule", "TestAST_ThiserrorAttributeCall_ReferencesFunction", "TestAST_MacroRulesBodyCall_EmitsFileRef", "TestAST_ItemLevelMacroInvocationCall_EmitsFileRef"}, // Rust: merge-attribute scoped-path fix, sibling-file submodule use-resolution, calls embedded in any attribute macro, owner-less macro content (macro_rules! bodies, item-level macro invocations) recorded via file_ref
 }
 
 func TestCacheVersionCoverage(t *testing.T) {

internal/engine/cache.go

@@ -399,7 +399,19 @@ import (
 // now tracked as references. Also fixes a latent bug where a nested item (a local `fn`
 // inside a function body) could reallocate the fact slice and silently drop the
 // enclosing function's own relations recorded afterward.
-const cacheVersion = "v112"
+// v113: Rust — a function reference nested inside a macro argument (vec![Box::new(f)])
+// is now tracked; the merge crate's #[merge(strategy = mod::path)] attribute (and any
+// other flattened scoped-path attribute value, previously mis-read as just its first
+// segment) resolves correctly; an unprefixed `use foo::bar;` where foo is a body-less
+// `mod foo;` in the same file/mod scope is now classified internal instead of external
+// (it shares its parent's directory, so classifyUsePath had nothing to match it
+// against); an attribute can embed an ordinary call — thiserror's #[error("{}",
+// helper(x))] — scanned the same way as a macro invocation regardless of macro name;
+// and calls/references made in macro content with no enclosing symbol (a macro_rules!
+// template body, or an item-level macro invocation standing in for a whole function
+// like `ffi_fn! { fn foo() { ... } }`) are now recorded on a file_ref fact instead of
+// silently dropped for lack of an owner.
+const cacheVersion = "v113"
 
 // extractorCache holds per-extractor facts keyed by a content hash of the files
 // the extractor depends on. It is loaded from disk at the start of a snapshot and

internal/extractors/rustextractor/rust_ast.go

@@ -36,6 +36,7 @@ func extractFileAST(src []byte, relFile string, crates []crateInfo, moduleDirs m
 		crateDir:   nearestCrateDir(dir, crates),
 		crates:     crates,
 		moduleDirs: moduleDirs,
+		fileRefIdx: -1,
 	}
 	w.walkSourceFile(root)
 
@@ -78,6 +79,14 @@ type astWalker struct {
 	// reallocate its backing array and strand a raw pointer.
 	ownerStack []int
 
+	// fileRefIdx: index into out of the lazily-created file-scope reference
+	// fact (facts.KindFileRef), or -1 until first used. Catches calls/
+	// references made in macro content with no enclosing symbol — a
+	// macro_rules! template body, or an item-level macro invocation standing
+	// in for a whole function (e.g. `ffi_fn! { fn foo() { ... } }`) — which
+	// emitEdge would otherwise silently drop for lack of an owner.
+	fileRefIdx int
+
 	// modStack/typeStack hold the enclosing inline-`mod { }` and
 	// impl/trait-block names, so a nested declaration's canonical name is
 	// "<dir>.<mod1>.<mod2>...<Type>.<name>" — the same qualification scheme
@@ -93,6 +102,10 @@ type astWalker struct {
 	// mod/file scope, order-independent. Parallel to modStack.
 	modFnStack []map[string]bool
 
+	// modSubmoduleStack[len-1]: body-less `mod foo;` names declared directly
+	// in the enclosing mod/file scope. Parallel to modStack.
+	modSubmoduleStack []map[string]bool
+
 	// decisions counts cyclomatic decision points in the function/method body
 	// currently being walked; saved/restored around nested function items.
 	decisions int
@@ -174,7 +187,9 @@ func (w *astWalker) currentMethods() map[string]bool {
 
 func (w *astWalker) walkSourceFile(root *sitter.Node) {
 	w.modFnStack = append(w.modFnStack, collectFnNames(root, w.src))
+	w.modSubmoduleStack = append(w.modSubmoduleStack, collectSubmoduleNames(root, w.src))
 	w.walkItemsTrackingAttrs(root)
+	w.modSubmoduleStack = w.modSubmoduleStack[:len(w.modSubmoduleStack)-1]
 	w.modFnStack = w.modFnStack[:len(w.modFnStack)-1]
 }
 
@@ -190,6 +205,18 @@ func (w *astWalker) isKnownFn(name string) bool {
 	return false
 }
 
+// isKnownSubmodule checks every enclosing mod/file scope for a body-less
+// `mod name;` declaration, so `use name::item;` (no self::/crate:: prefix)
+// is recognized as a reference to that sibling file, not an external crate.
+func (w *astWalker) isKnownSubmodule(name string) bool {
+	for i := len(w.modSubmoduleStack) - 1; i >= 0; i-- {
+		if w.modSubmoduleStack[i][name] {
+			return true
+		}
+	}
+	return false
+}
+
 // walkItemsTrackingAttrs iterates parent's children like walkChild, but first
 // tracks preceding attribute_item siblings so a `#[cfg(test)] mod { ... }` can
 // be detected and routed into test mode (enterTestMod) instead of being walked
@@ -322,7 +349,9 @@ func (w *astWalker) handleMod(node *sitter.Node) {
 	}
 	w.modStack = append(w.modStack, name)
 	w.modFnStack = append(w.modFnStack, collectFnNames(body, w.src))
+	w.modSubmoduleStack = append(w.modSubmoduleStack, collectSubmoduleNames(body, w.src))
 	w.walkItemsTrackingAttrs(body)
+	w.modSubmoduleStack = w.modSubmoduleStack[:len(w.modSubmoduleStack)-1]
 	w.modFnStack = w.modFnStack[:len(w.modFnStack)-1]
 	w.modStack = w.modStack[:len(w.modStack)-1]
 }
@@ -585,7 +614,18 @@ func (w *astWalker) emitDependency(segs []string, line int) {
 	if len(segs) == 0 || segs[len(segs)-1] == "" {
 		return
 	}
-	target, source := classifyUsePath(segs, w.dir, w.crateDir, w.crates, w.moduleDirs)
+	var target, source string
+	switch {
+	case segs[0] != "self" && segs[0] != "super" && segs[0] != "crate" && w.isKnownSubmodule(segs[0]):
+		// An unprefixed `use foo::bar;` where "foo" is a body-less `mod foo;`
+		// declared in this same file/mod scope is a reference to that sibling
+		// file, not an external crate — classifyUsePath can't see that on its
+		// own since foo.rs shares its parent's directory (no subdirectory to
+		// find in moduleDirs).
+		target, source = joinRustPath(w.dir, segs, w.moduleDirs), "internal"
+	default:
+		target, source = classifyUsePath(segs, w.dir, w.crateDir, w.crates, w.moduleDirs)
+	}
 	raw := strings.Join(segs, "::")
 	w.out = append(w.out, facts.Fact{
 		Kind: facts.KindDependency,
@@ -840,7 +880,9 @@ func (w *astWalker) handleCallExpression(node *sitter.Node) {
 // while walking a #[cfg(test)] module (w.inTestMod) — as a deduplicated
 // RelCalls reference into testRefRels. KindTestRef carries only RelCalls (per
 // its doc comment), so a would-be RelInstantiates from a test still just
-// proves the target is used, not constructed for real.
+// proves the target is used, not constructed for real. With no owner and not
+// in test mode, it's file-scope macro content (see fileRefIdx) — recorded
+// there instead of dropped.
 func (w *astWalker) emitEdge(kind, target string) {
 	if w.inTestMod {
 		if w.testRefSeen == nil {
@@ -855,22 +897,40 @@ func (w *astWalker) emitEdge(kind, target string) {
 	}
 	owner := w.currentOwner()
 	if owner == nil {
+		idx := w.ensureFileRefFact()
+		w.out[idx].Relations = append(w.out[idx].Relations, facts.Relation{Kind: kind, Target: target})
 		return
 	}
 	owner.Relations = append(owner.Relations, facts.Relation{Kind: kind, Target: target})
 }
 
+// ensureFileRefFact returns the index of this file's lazily-created
+// file-scope reference fact (facts.KindFileRef), creating it on first use.
+func (w *astWalker) ensureFileRefFact() int {
+	if w.fileRefIdx < 0 {
+		w.out = append(w.out, facts.Fact{
+			Kind:  facts.KindFileRef,
+			Name:  w.relFile,
+			File:  w.relFile,
+			Props: map[string]any{"language": "rust"},
+		})
+		w.fileRefIdx = len(w.out) - 1
+	}
+	return w.fileRefIdx
+}
+
 // attrFnRefKeys: field-attribute options whose value names a function —
-// serde's #[serde(default = "some_fn")] (string) or clap's
-// #[arg(value_parser = some_fn)] (bare path) — resolved by that macro.
+// serde's #[serde(default = "some_fn")] (string), clap's
+// #[arg(value_parser = some_fn)] (bare path), or the merge crate's
+// #[merge(strategy = mod::path)] (scoped path) — resolved by that macro.
 var attrFnRefKeys = map[string]bool{
 	"default": true, "skip_serializing_if": true,
 	"serialize_with": true, "deserialize_with": true, "with": true,
-	"value_parser": true,
+	"value_parser": true, "strategy": true,
 }
 
 // attrFnRefMacros: attribute macro names worth scanning for attrFnRefKeys.
-var attrFnRefMacros = map[string]bool{"serde": true, "arg": true}
+var attrFnRefMacros = map[string]bool{"serde": true, "arg": true, "merge": true}
 
 // scanAttributeFnRefs walks a struct/enum body for #[serde(...)]/#[arg(...)]
 // attributes referencing a function by name.
@@ -882,6 +942,13 @@ func (w *astWalker) scanAttributeFnRefs(body *sitter.Node) {
 	walk = func(n *sitter.Node) {
 		if n.Kind() == "attribute" {
 			w.scanAttribute(n)
+			// Beyond the curated key=value macros above, an attribute can embed
+			// an ordinary call — thiserror's #[error("{}", helper(x))] — using
+			// the exact same flattened shape as a macro invocation's token_tree,
+			// so the same scan applies regardless of which macro this is.
+			if tree := findChildByKind(n, "token_tree"); tree != nil {
+				w.scanTokenTreeCalls(tree)
+			}
 			return
 		}
 		for i := uint(0); i < uint(n.ChildCount()); i++ {
@@ -912,15 +979,24 @@ func (w *astWalker) scanAttribute(attr *sitter.Node) {
 			if content := findChildByKind(v, "string_content"); content != nil {
 				name = nodeText(content, w.src)
 			}
-		case "identifier", "scoped_identifier":
+		case "identifier":
+			// A scoped path (mod::path::fn) is flattened into separate
+			// identifier/"::" siblings inside a macro-like token_tree, not a
+			// single scoped_identifier node — walk to the last segment.
+			j := i + 2
+			for j+2 < n && tree.Child(j+1).Kind() == "::" && tree.Child(j+2).Kind() == "identifier" {
+				j += 2
+			}
+			name = nodeText(tree.Child(j), w.src)
+		case "scoped_identifier":
 			name = nodeText(v, w.src)
+			if idx := strings.LastIndex(name, "::"); idx >= 0 {
+				name = name[idx+2:]
+			}
 		}
 		if name == "" {
 			continue
 		}
-		if idx := strings.LastIndex(name, "::"); idx >= 0 {
-			name = name[idx+2:]
-		}
 		w.emitEdge(facts.RelCalls, name)
 	}
 }
@@ -1059,6 +1135,28 @@ func collectFnNames(body *sitter.Node, src []byte) map[string]bool {
 	return names
 }
 
+// collectSubmoduleNames returns the names declared by body-less `mod foo;`
+// items directly in body — a file-based submodule (foo.rs or foo/mod.rs),
+// as opposed to an inline `mod foo { ... }` block. Used to recognize an
+// unprefixed `use foo::bar;` as a reference to that sibling file rather than
+// an external crate.
+func collectSubmoduleNames(body *sitter.Node, src []byte) map[string]bool {
+	names := make(map[string]bool)
+	if body == nil {
+		return names
+	}
+	for i := uint(0); i < uint(body.ChildCount()); i++ {
+		c := body.Child(i)
+		if c.Kind() != "mod_item" || c.ChildByFieldName("body") != nil {
+			continue
+		}
+		if n := c.ChildByFieldName("name"); n != nil {
+			names[nodeText(n, src)] = true
+		}
+	}
+	return names
+}
+
 // simpleTypeName returns a type node's simple (rightmost) identifier, e.g.
 // "Wrapper" for "Wrapper<T>" or "MyError" for "&MyError". Used for impl-block
 // types/traits, where generics and references must be stripped.

internal/extractors/rustextractor/rust_ast_test.go

@@ -829,3 +829,73 @@ fn handle_error(s: String) -> String { s }
 		t.Errorf("expected RelCalls -> pkg.handle_error, got %+v", c.Relations)
 	}
 }
+
+func TestAST_MergeStrategyAttribute_ReferencesScopedFunction(t *testing.T) {
+	ff := extractAST(t, `
+pub struct Config {
+    #[merge(strategy = merge_strategies_extend::overwrite_always)]
+    name: Option<String>,
+}
+mod merge_strategies_extend {
+    pub fn overwrite_always(a: &mut Option<String>, b: Option<String>) { *a = b; }
+}
+`)
+	s, ok := findFact(ff, "pkg.Config")
+	if !ok {
+		t.Fatal("expected fact for pkg.Config")
+	}
+	if !hasRelation(s, facts.RelCalls, "overwrite_always") {
+		t.Errorf("expected RelCalls -> overwrite_always, got %+v", s.Relations)
+	}
+}
+
+func TestAST_ThiserrorAttributeCall_ReferencesFunction(t *testing.T) {
+	ff := extractAST(t, `
+#[derive(Debug, thiserror::Error)]
+pub enum ProfileError {
+    #[error("{}", not_found_message(.searched, .explicit_profiles_dir))]
+    NotFound {
+        searched: Vec<String>,
+        explicit_profiles_dir: bool,
+    },
+}
+fn not_found_message(searched: &[String], explicit: &bool) -> String { String::new() }
+`)
+	e, ok := findFact(ff, "pkg.ProfileError")
+	if !ok {
+		t.Fatal("expected fact for pkg.ProfileError")
+	}
+	if !hasRelation(e, facts.RelCalls, "pkg.not_found_message") {
+		t.Errorf("expected RelCalls -> pkg.not_found_message, got %+v", e.Relations)
+	}
+}
+
+func TestAST_MacroRulesBodyCall_EmitsFileRef(t *testing.T) {
+	ff := extractAST(t, `
+fn utf8(name: &str) -> String { name.to_string() }
+
+macro_rules! table_schema {
+    (@field $name:expr, utf8) => { utf8($name) };
+}
+`)
+	refs := findFactsByKind(ff, facts.KindFileRef)
+	if len(refs) != 1 || !hasRelation(refs[0], facts.RelCalls, "pkg.utf8") {
+		t.Errorf("expected a KindFileRef -> pkg.utf8, got %+v", refs)
+	}
+}
+
+func TestAST_ItemLevelMacroInvocationCall_EmitsFileRef(t *testing.T) {
+	ff := extractAST(t, `
+fn with_cow(x: i32) {}
+
+ffi_fn! {
+    fn my_ffi_func(x: i32) {
+        with_cow(x);
+    }
+}
+`)
+	refs := findFactsByKind(ff, facts.KindFileRef)
+	if len(refs) != 1 || !hasRelation(refs[0], facts.RelCalls, "pkg.with_cow") {
+		t.Errorf("expected a KindFileRef -> pkg.with_cow, got %+v", refs)
+	}
+}

internal/extractors/rustextractor/rust_test.go

@@ -152,3 +152,36 @@ func TestExtract_ImplSplitAcrossFilesStillAttaches(t *testing.T) {
 		t.Errorf("expected RelImplements -> Display attached across files, got %+v", w.Relations)
 	}
 }
+
+func TestExtract_UnprefixedUseOfSiblingFileSubmodule(t *testing.T) {
+	repo, files := writeRustRepo(t, map[string]string{
+		"Cargo.toml": "[package]\nname = \"demo\"\n",
+		"src/mod.rs": `
+pub mod writer;
+pub use writer::spawn_writer;
+
+pub fn start() {
+    spawn_writer();
+}
+`,
+		"src/writer.rs": "pub fn spawn_writer() {}\n",
+	})
+	ff, err := New().Extract(context.Background(), repo, files)
+	if err != nil {
+		t.Fatalf("Extract error: %v", err)
+	}
+	start, ok := findFact(ff, "src.start")
+	if !ok {
+		t.Fatalf("expected fact for src.start, got %+v", ff)
+	}
+	if !hasRelation(start, facts.RelCalls, "src.spawn_writer") {
+		t.Errorf("expected RelCalls -> src.spawn_writer, got %+v", start.Relations)
+	}
+	dep, ok := findFact(ff, "src -> writer::spawn_writer")
+	if !ok {
+		t.Fatalf("expected a dependency fact for writer::spawn_writer, got %+v", findFactsByKind(ff, facts.KindDependency))
+	}
+	if dep.Props["source"] != "internal" {
+		t.Errorf("sibling-file submodule source = %v, want internal", dep.Props["source"])
+	}
+}