feat(rust): enhance Rust AST extraction with function reference tracking and macro argument handling

Author: GertL

internal/cachecov/coverage_test.go

@@ -142,7 +142,8 @@ var versionCoverage = map[int][]string{
 	108: {"TestConditionalCompilation_TagsBothBranches", "TestConditionalCompilation_UnconditionalNotTagged", "TestConditionalCompilation_MemberLevelDirective", "TestGolden"}, // Swift tags symbols inside #if/#elseif/#else branches with conditional=true, so the counting consumers collapse the #if/#else double emission via facts.CanonicalSymbols (GAP-SW-10)
 	109: {"TestDetectFlask", "TestRouteExtractor_FlaskAppRoute", "TestRouteExtractor_FlaskAppRouteDefaultGet", "TestRouteExtractor_FlaskAppRouteMultiVerb", "TestRouteExtractor_Blueprint", "TestRouteExtractor_Expose", "TestRouteExtractor_FlaskGetLabeledFlask", "TestRouteExtractor_VerbShorthandDefaultsFastAPI", "TestGolden"}, // Python detects Flask routes: @app.route/@bp.route (methods=[...]) and Flask-AppBuilder @expose emit KindRoute framework="flask"; @app.get labeled from project detection instead of hardcoded fastapi (GAP-PY-01)
 	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
+	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
 }
 
 func TestCacheVersionCoverage(t *testing.T) {

internal/engine/cache.go

@@ -386,14 +386,19 @@ import (
 // which on server-side Java is an inbound JAX-RS/Spring handler, not I/O; and there is
 // no transitive fixpoint (performs_io == io_direct), matching the Kotlin design. Cached
 // Java snapshots must re-extract (GAP-JV-02).
-// v112: adds the Rust extractor (fn/struct/enum/trait/type/const/static symbols; impl/trait
+// v111: adds the Rust extractor (fn/struct/enum/trait/type/const/static symbols; impl/trait
 // "implements" edges attached via a post-pass; use-based dependency facts classified
 // internal/external/stdlib; calls/instantiates edges; cyclomatic complexity; Axum route
-// facts; calls inside a macro invocation's token_tree; a function passed by name as a
-// value — call argument, struct field, &f; serde default/skip_serializing_if attribute
-// strings). Rust is a new FileOwner, so its arrival also reshuffles which files count as
+// facts). Rust is a new FileOwner, so its arrival also reshuffles which files count as
 // "shared" for every other cached extractor's key in a mixed-language repo. Cached
 // snapshots of any repo containing Rust files must re-extract.
+// v112: Rust call-reference precision — calls inside a macro invocation's token_tree
+// (bail!/format!/matches! arguments), a function passed by name as a value (call
+// argument, struct field, &f, a local fn declared earlier in the same body), and
+// serde/clap attribute strings/paths (default, skip_serializing_if, value_parser) are
+// 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"
 
 // extractorCache holds per-extractor facts keyed by a content hash of the files

internal/extractors/rustextractor/rust_ast.go

@@ -72,10 +72,11 @@ type astWalker struct {
 	out   []facts.Fact
 	impls []implPair
 
-	// ownerStack[len-1] points at the symbol fact currently being constructed.
-	// Calls/instantiations discovered while walking that symbol's body are
-	// appended to its Relations slice.
-	ownerStack []*facts.Fact
+	// ownerStack[len-1] indexes into out for the symbol fact currently being
+	// constructed. Stored as an index, not a *facts.Fact: a nested item (a
+	// local `fn` inside a function body) appends to out too, which can
+	// reallocate its backing array and strand a raw pointer.
+	ownerStack []int
 
 	// modStack/typeStack hold the enclosing inline-`mod { }` and
 	// impl/trait-block names, so a nested declaration's canonical name is
@@ -145,13 +146,13 @@ func (w *astWalker) qualifyMod(name string) string {
 	return strings.Join(parts, ".")
 }
 
-func (w *astWalker) pushOwner(f *facts.Fact) { w.ownerStack = append(w.ownerStack, f) }
-func (w *astWalker) popOwner()               { w.ownerStack = w.ownerStack[:len(w.ownerStack)-1] }
+func (w *astWalker) pushOwner(idx int) { w.ownerStack = append(w.ownerStack, idx) }
+func (w *astWalker) popOwner()         { w.ownerStack = w.ownerStack[:len(w.ownerStack)-1] }
 func (w *astWalker) currentOwner() *facts.Fact {
 	if len(w.ownerStack) == 0 {
 		return nil
 	}
-	return w.ownerStack[len(w.ownerStack)-1]
+	return &w.out[w.ownerStack[len(w.ownerStack)-1]]
 }
 
 func (w *astWalker) pushType(name string, methods map[string]bool) {
@@ -177,11 +178,16 @@ func (w *astWalker) walkSourceFile(root *sitter.Node) {
 	w.modFnStack = w.modFnStack[:len(w.modFnStack)-1]
 }
 
-func (w *astWalker) currentModFns() map[string]bool {
-	if len(w.modFnStack) == 0 {
-		return nil
+// isKnownFn checks every enclosing scope (function-local, then outward
+// through mod/file scope), not just the innermost, so a value-reference
+// inside a function body still resolves to an outer mod-level sibling.
+func (w *astWalker) isKnownFn(name string) bool {
+	for i := len(w.modFnStack) - 1; i >= 0; i-- {
+		if w.modFnStack[i][name] {
+			return true
+		}
 	}
-	return w.modFnStack[len(w.modFnStack)-1]
+	return false
 }
 
 // walkItemsTrackingAttrs iterates parent's children like walkChild, but first
@@ -344,8 +350,8 @@ func (w *astWalker) handleStruct(node *sitter.Node) {
 		Relations: []facts.Relation{{Kind: facts.RelDeclares, Target: w.dir}},
 	})
 	ownerIdx := len(w.out) - 1
-	w.pushOwner(&w.out[ownerIdx])
-	w.scanSerdeAttributeRefs(node.ChildByFieldName("body"))
+	w.pushOwner(ownerIdx)
+	w.scanAttributeFnRefs(node.ChildByFieldName("body"))
 	w.popOwner()
 }
 
@@ -368,8 +374,8 @@ func (w *astWalker) handleEnum(node *sitter.Node) {
 		Relations: []facts.Relation{{Kind: facts.RelDeclares, Target: w.dir}},
 	})
 	ownerIdx := len(w.out) - 1
-	w.pushOwner(&w.out[ownerIdx])
-	w.scanSerdeAttributeRefs(node.ChildByFieldName("body"))
+	w.pushOwner(ownerIdx)
+	w.scanAttributeFnRefs(node.ChildByFieldName("body"))
 	w.popOwner()
 }
 
@@ -460,12 +466,14 @@ func (w *astWalker) handleFunction(node *sitter.Node) {
 
 	w.out = append(w.out, f)
 	ownerIdx := len(w.out) - 1
-	w.pushOwner(&w.out[ownerIdx])
+	w.pushOwner(ownerIdx)
 
 	savedDecisions := w.decisions
 	w.decisions = 0
 	if body := node.ChildByFieldName("body"); body != nil {
+		w.modFnStack = append(w.modFnStack, collectFnNames(body, w.src))
 		w.walkForCalls(body)
+		w.modFnStack = w.modFnStack[:len(w.modFnStack)-1]
 	}
 	w.out[ownerIdx].Props["cyclomatic"] = 1 + w.decisions
 	w.decisions = savedDecisions
@@ -544,8 +552,7 @@ func (w *astWalker) handleConstOrStatic(node *sitter.Node, symbolKind string) {
 		Relations: []facts.Relation{{Kind: facts.RelDeclares, Target: w.dir}},
 	}
 	w.out = append(w.out, f)
-	owner := &w.out[len(w.out)-1]
-	w.pushOwner(owner)
+	w.pushOwner(len(w.out) - 1)
 	if valueNode := node.ChildByFieldName("value"); valueNode != nil {
 		w.walkForCalls(valueNode)
 	}
@@ -712,25 +719,45 @@ func (w *astWalker) walkForCalls(node *sitter.Node) {
 // `identifier` immediately followed by a parenthesized token_tree sibling.
 func (w *astWalker) scanTokenTreeCalls(node *sitter.Node) {
 	n := node.ChildCount()
-	for i := uint(0); i+1 < n; i++ {
+	for i := uint(0); i < n; i++ {
 		c := node.Child(i)
 		if c.Kind() != "identifier" {
 			continue
 		}
-		next := node.Child(i + 1)
-		if next.Kind() != "token_tree" || next.ChildCount() == 0 || next.Child(0).Kind() != "(" {
-			continue
+		var next *sitter.Node
+		if i+1 < n {
+			next = node.Child(i + 1)
 		}
-		name := nodeText(c, w.src)
-		if isCapitalized(name) {
-			w.emitEdge(facts.RelInstantiates, name)
+		if next != nil && next.Kind() == "token_tree" && next.ChildCount() > 0 && next.Child(0).Kind() == "(" {
+			name := nodeText(c, w.src)
+			if isCapitalized(name) {
+				w.emitEdge(facts.RelInstantiates, name)
+				continue
+			}
+			if i > 0 && node.Child(i-1).Kind() == "." {
+				w.emitEdge(facts.RelCalls, name)
+				continue
+			}
+			if target := w.resolveCall(name); target != "" {
+				w.emitEdge(facts.RelCalls, target)
+			}
 			continue
 		}
-		if i > 0 && node.Child(i-1).Kind() == "." {
-			w.emitEdge(facts.RelCalls, name)
-			continue
+		// Not applied as a call: may still be a function passed by name as a
+		// value nested inside a macro's own argument, e.g. Box::new(f) inside
+		// vec![...]. Skip path segments (preceded/followed by "."/"::") and
+		// attribute-style `key = value` pairs, already handled by scanAttribute.
+		if i > 0 {
+			if pk := node.Child(i - 1).Kind(); pk == "." || pk == "::" {
+				continue
+			}
 		}
-		if target := w.resolveCall(name); target != "" {
+		if next != nil {
+			if nk := next.Kind(); nk == "::" || nk == "=" {
+				continue
+			}
+		}
+		if target := w.resolveValueReference(nodeText(c, w.src)); target != "" {
 			w.emitEdge(facts.RelCalls, target)
 		}
 	}
@@ -833,23 +860,28 @@ func (w *astWalker) emitEdge(kind, target string) {
 	owner.Relations = append(owner.Relations, facts.Relation{Kind: kind, Target: target})
 }
 
-// serdeAttrFnKeys: serde options whose value is a string naming a function,
-// e.g. #[serde(default = "some_fn")] — resolved by serde's derive macro.
-var serdeAttrFnKeys = map[string]bool{
+// 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.
+var attrFnRefKeys = map[string]bool{
 	"default": true, "skip_serializing_if": true,
 	"serialize_with": true, "deserialize_with": true, "with": true,
+	"value_parser": true,
 }
 
-// scanSerdeAttributeRefs walks a struct/enum body for #[serde(...)]
+// attrFnRefMacros: attribute macro names worth scanning for attrFnRefKeys.
+var attrFnRefMacros = map[string]bool{"serde": true, "arg": true}
+
+// scanAttributeFnRefs walks a struct/enum body for #[serde(...)]/#[arg(...)]
 // attributes referencing a function by name.
-func (w *astWalker) scanSerdeAttributeRefs(body *sitter.Node) {
+func (w *astWalker) scanAttributeFnRefs(body *sitter.Node) {
 	if body == nil {
 		return
 	}
 	var walk func(n *sitter.Node)
 	walk = func(n *sitter.Node) {
 		if n.Kind() == "attribute" {
-			w.scanSerdeAttribute(n)
+			w.scanAttribute(n)
 			return
 		}
 		for i := uint(0); i < uint(n.ChildCount()); i++ {
@@ -859,10 +891,10 @@ func (w *astWalker) scanSerdeAttributeRefs(body *sitter.Node) {
 	walk(body)
 }
 
-// scanSerdeAttribute scans one `serde(...)` attribute's token_tree for
-// `key = "value"` pairs keyed by serdeAttrFnKeys.
-func (w *astWalker) scanSerdeAttribute(attr *sitter.Node) {
-	if attr.NamedChildCount() == 0 || nodeText(attr.NamedChild(0), w.src) != "serde" {
+// scanAttribute scans one attribute's token_tree for `key = value` pairs
+// keyed by attrFnRefKeys, where value is a string literal or a bare path.
+func (w *astWalker) scanAttribute(attr *sitter.Node) {
+	if attr.NamedChildCount() == 0 || !attrFnRefMacros[nodeText(attr.NamedChild(0), w.src)] {
 		return
 	}
 	tree := findChildByKind(attr, "token_tree")
@@ -871,18 +903,21 @@ func (w *astWalker) scanSerdeAttribute(attr *sitter.Node) {
 	}
 	n := tree.ChildCount()
 	for i := uint(0); i+2 < n; i++ {
-		if !serdeAttrFnKeys[nodeText(tree.Child(i), w.src)] || tree.Child(i+1).Kind() != "=" {
+		if !attrFnRefKeys[nodeText(tree.Child(i), w.src)] || tree.Child(i+1).Kind() != "=" {
 			continue
 		}
-		lit := tree.Child(i + 2)
-		if lit.Kind() != "string_literal" {
-			continue
+		name := ""
+		switch v := tree.Child(i + 2); v.Kind() {
+		case "string_literal":
+			if content := findChildByKind(v, "string_content"); content != nil {
+				name = nodeText(content, w.src)
+			}
+		case "identifier", "scoped_identifier":
+			name = nodeText(v, w.src)
 		}
-		content := findChildByKind(lit, "string_content")
-		if content == nil {
+		if name == "" {
 			continue
 		}
-		name := nodeText(content, w.src)
 		if idx := strings.LastIndex(name, "::"); idx >= 0 {
 			name = name[idx+2:]
 		}
@@ -914,7 +949,7 @@ func (w *astWalker) resolveValueReference(name string) string {
 	if methods := w.currentMethods(); methods[name] {
 		return w.dir + "." + w.qualify(name)
 	}
-	if fns := w.currentModFns(); fns[name] {
+	if w.isKnownFn(name) {
 		return w.dir + "." + w.qualifyMod(name)
 	}
 	if target, ok := w.importMap[name]; ok {

internal/extractors/rustextractor/rust_ast_test.go

@@ -778,3 +778,54 @@ fn is_false(b: &bool) -> bool { !b }
 		t.Errorf("expected RelCalls -> is_false, got %+v", s.Relations)
 	}
 }
+
+func TestAST_ClapValueParserAttribute_ReferencesFunction(t *testing.T) {
+	ff := extractAST(t, `
+pub struct Args {
+    #[arg(value_parser = check_target)]
+    target: String,
+}
+fn check_target(s: &str) -> Result<String, String> { Ok(s.to_string()) }
+`)
+	s, ok := findFact(ff, "pkg.Args")
+	if !ok {
+		t.Fatal("expected fact for pkg.Args")
+	}
+	if !hasRelation(s, facts.RelCalls, "check_target") {
+		t.Errorf("expected RelCalls -> check_target, got %+v", s.Relations)
+	}
+}
+
+func TestAST_LocalFunctionPassedAsCallbackWithinSameBody(t *testing.T) {
+	ff := extractAST(t, `
+fn caller(a: Vec<Option<String>>) {
+    fn normalize_item(opt: &Option<String>) -> Option<String> { opt.clone() }
+    let normalized: Vec<Option<String>> = a.iter().map(normalize_item).collect();
+}
+`)
+	c, ok := findFact(ff, "pkg.caller")
+	if !ok {
+		t.Fatal("expected fact for pkg.caller")
+	}
+	if !hasRelation(c, facts.RelCalls, "pkg.normalize_item") {
+		t.Errorf("expected RelCalls -> pkg.normalize_item, got %+v", c.Relations)
+	}
+}
+
+func TestAST_FunctionReferenceNestedInsideMacroArgument(t *testing.T) {
+	ff := extractAST(t, `
+fn caller() {
+    let transforms: Vec<Box<dyn Fn(String) -> String>> = vec![
+        Box::new(handle_error),
+    ];
+}
+fn handle_error(s: String) -> String { s }
+`)
+	c, ok := findFact(ff, "pkg.caller")
+	if !ok {
+		t.Fatal("expected fact for pkg.caller")
+	}
+	if !hasRelation(c, facts.RelCalls, "pkg.handle_error") {
+		t.Errorf("expected RelCalls -> pkg.handle_error, got %+v", c.Relations)
+	}
+}