feat(rust): update cache version to v114 and enhance AST extraction for test functions and array literals

Author: GertL

internal/cachecov/coverage_test.go

@@ -146,6 +146,7 @@ var versionCoverage = map[int][]string{
 	112: {"TestStorage_TypeORMEntity", "TestStorage_DrizzleTable", "TestStorage_PrismaModels", "TestStorage_NoORMDependencyEmitsNothing", "TestIODirect_ORMCallSeedsPerformsIO", "TestGolden"}, // TypeScript emits storage facts for TypeORM @Entity / Drizzle pgTable / Prisma models (schema.prisma read off-glob); ORM query methods seed io_direct so performs_io propagates through a repository wrapper, making a per-iteration wrapper call a detectable N+1 (GAP-XL-04, new/26)
 	113: {"TestJavaSPIServiceFileRefs", "TestJavaRuleNodeProp", "TestGolden"}, // Java folds SPI service-file registrations (META-INF/services + META-INF/dubbo) as KindFileRef references so an impl loaded by name is not a false orphan, and emits scanned_plugin on @RuleNode classpath-scanned plugins (GAP-JV-08, new/60)
 	114: {"TestGolden", "TestOwnsFile", "TestAST_ImplTraitForType_EmitsImplements", "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", "TestAST_MergeStrategyAttribute_ReferencesScopedFunction", "TestExtract_UnprefixedUseOfSiblingFileSubmodule", "TestAST_ThiserrorAttributeCall_ReferencesFunction", "TestAST_MacroRulesBodyCall_EmitsFileRef", "TestAST_ItemLevelMacroInvocationCall_EmitsFileRef", "TestAST_DropImplTagsOverride", "TestAST_FutureImplTagsOverride", "TestAST_InherentDropLikeMethod_NotTaggedOverride", "TestAST_OtherTraitMethodNamedDrop_NotTaggedOverride", "TestAST_ScopedAssociatedFnCall_InstantiatesType", "TestAST_ScopedAssociatedFnCall_SelfNotInstantiated", "TestAST_BareScopedVariantValue_InstantiatesEnum", "TestAST_ScopedVariantInMatchPattern_InstantiatesEnum", "TestAST_ScopedMethodCall_NotTreatedAsVariant", "TestAST_BareUnitStructValue_Instantiates", "TestAST_BareUnitStructValue_LetBinding_Instantiates"}, // Rust extractor added: symbols, implements post-pass, dependency/calls/route facts, cache participation; macro-arg calls, function-as-value references, serde/clap/merge attribute refs, sibling-file submodule use-resolution, owner-less macro content via file_ref; Drop::drop/Future::poll tagged override; Type::assoc_fn()/Type::Variant/bare unit-struct value all record RelInstantiates for Type
+	115: {"TestAST_TestFnAtFileRoot_NoSymbolFact", "TestAST_TestFnAtFileRoot_CreditsProductionCall", "TestAST_FunctionPointerArrayLiteral_ReferencesEach", "TestAST_SchemarsSchemaWithAttribute_ReferencesFunction", "TestAST_SchemarsSchemaWithQualifiedPath_ReferencesFunction", "TestAST_SelfCallAcrossSeparateImplBlocks_NotDropped", "TestAST_SelfCallWithinSameImplBlock_StillQualified"}, // Rust: #[test] fn recognized wherever it lives; array-literal dispatch tables (&[f, g]); schemars schema_with attribute (bare and crate::-qualified); self.method() no longer dropped across separate impl blocks/trait defaults
 }
 
 func TestCacheVersionCoverage(t *testing.T) {

internal/engine/cache.go

@@ -456,7 +456,18 @@ import (
 // handling. 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.
-const cacheVersion = "v114"
+// v115: Rust recognizes a #[test]/#[tokio::test]/#[wasm_bindgen_test] fn wherever it
+// lives — a plain tests.rs file, an un-gated mod tests {} — not just inside a
+// #[cfg(test)] module; it gets no symbol fact, and its calls into production code are
+// credited via a file_ref/test_ref fact instead of counted as dead production code.
+// Also records a function referenced bare inside an array literal (a `&[f, g]`
+// dispatch table) as used, and resolves the schemars crate's
+// #[schemars(schema_with = "fn")] attribute string (bare or crate::-qualified)
+// like serde's default/skip_serializing_if. Fixes a latent bug where
+// self.method() was silently dropped (no edge at all) whenever method wasn't
+// a sibling of the immediately enclosing impl block — e.g. a type with
+// several impl blocks, or a trait's own default method.
+const cacheVersion = "v115"
 
 // 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

@@ -231,23 +231,48 @@ func (w *astWalker) isKnownSubmodule(name string) bool {
 // places a Rust test module can appear; impl/trait bodies never contain one.
 func (w *astWalker) walkItemsTrackingAttrs(parent *sitter.Node) {
 	sawCfgTest := false
+	sawTestAttr := false
 	for i := uint(0); i < uint(parent.ChildCount()); i++ {
 		c := parent.Child(i)
 		if c.Kind() == "attribute_item" {
-			if isCfgTestAttribute(nodeText(c, w.src)) {
+			text := nodeText(c, w.src)
+			if isCfgTestAttribute(text) {
 				sawCfgTest = true
 			}
+			if isTestAttribute(text) {
+				sawTestAttr = true
+			}
 			continue
 		}
-		if c.Kind() == "mod_item" && sawCfgTest {
+		switch {
+		case c.Kind() == "mod_item" && sawCfgTest:
 			w.enterTestMod(c)
-		} else {
+		case c.Kind() == "function_item" && sawTestAttr:
+			saved := w.inTestMod
+			w.inTestMod = true
+			w.walkTestItem(c)
+			w.inTestMod = saved
+		default:
 			w.walkChild(c)
 		}
 		sawCfgTest = false
+		sawTestAttr = false
 	}
 }
 
+// isTestAttribute reports whether an attribute_item marks its function as a
+// test (#[test], #[tokio::test], #[wasm_bindgen_test]) — catching a #[test]
+// fn wherever it lives (a plain tests.rs file, an un-gated mod tests {}),
+// not just inside a #[cfg(test)] module.
+func isTestAttribute(text string) bool {
+	inner := strings.TrimSuffix(strings.TrimPrefix(strings.TrimSpace(text), "#["), "]")
+	if i := strings.IndexAny(inner, "(["); i >= 0 {
+		inner = inner[:i]
+	}
+	inner = strings.TrimSpace(inner)
+	return inner == "test" || strings.HasSuffix(inner, "::test") || inner == "wasm_bindgen_test"
+}
+
 // isCfgTestAttribute reports whether an attribute_item's raw text is a
 // `#[cfg(test)]`-shaped gate. A coarse substring check (rather than requiring
 // an exact `cfg(test)` match) also catches compound forms like
@@ -753,7 +778,7 @@ func (w *astWalker) walkForCalls(node *sitter.Node) {
 		w.handleStructExpression(node)
 	case "token_tree":
 		w.scanTokenTreeCalls(node)
-	case "arguments":
+	case "arguments", "array_expression":
 		w.scanArgumentReferences(node)
 	case "field_initializer":
 		w.emitValueReference(node.ChildByFieldName("value"))
@@ -822,8 +847,9 @@ func (w *astWalker) scanTokenTreeCalls(node *sitter.Node) {
 	}
 }
 
-// scanArgumentReferences checks each argument for a function passed by name
-// (`.map_err(f)`), which produces no call_expression since `f` isn't applied.
+// scanArgumentReferences checks each element (a call argument or array
+// literal item) for a function passed by name (`.map_err(f)`, `&[f, g]`
+// dispatch tables), which produces no call_expression since it isn't applied.
 func (w *astWalker) scanArgumentReferences(node *sitter.Node) {
 	for i := uint(0); i < node.NamedChildCount(); i++ {
 		w.emitValueReference(node.NamedChild(i))
@@ -891,7 +917,11 @@ func (w *astWalker) handleCallExpression(node *sitter.Node) {
 	case calleeSelfRef:
 		if methods := w.currentMethods(); methods[name] {
 			w.emitEdge(facts.RelCalls, w.dir+"."+w.qualify(name))
+			break
 		}
+		// Not a sibling of this impl block (another impl block, a trait
+		// default) — still unambiguously a method call, so fall back.
+		w.emitEdge(facts.RelCalls, name)
 	case calleeOther:
 		// Receiver/path type is unknown without full type inference. Emitting
 		// the bare member name still lets short-name dead-code matching mark
@@ -951,11 +981,11 @@ func (w *astWalker) ensureFileRefFact() int {
 var attrFnRefKeys = map[string]bool{
 	"default": true, "skip_serializing_if": true,
 	"serialize_with": true, "deserialize_with": true, "with": true,
-	"value_parser": true, "strategy": true,
+	"value_parser": true, "strategy": true, "schema_with": true,
 }
 
 // attrFnRefMacros: attribute macro names worth scanning for attrFnRefKeys.
-var attrFnRefMacros = map[string]bool{"serde": true, "arg": true, "merge": true}
+var attrFnRefMacros = map[string]bool{"serde": true, "arg": true, "merge": true, "schemars": true}
 
 // scanAttributeFnRefs walks a struct/enum body for #[serde(...)]/#[arg(...)]
 // attributes referencing a function by name.
@@ -1003,6 +1033,9 @@ func (w *astWalker) scanAttribute(attr *sitter.Node) {
 		case "string_literal":
 			if content := findChildByKind(v, "string_content"); content != nil {
 				name = nodeText(content, w.src)
+				if idx := strings.LastIndex(name, "::"); idx >= 0 {
+					name = name[idx+2:]
+				}
 			}
 		case "identifier":
 			// A scoped path (mod::path::fn) is flattened into separate

internal/extractors/rustextractor/rust_ast_test.go

@@ -1094,3 +1094,127 @@ fn make() {
 		t.Errorf("expected RelInstantiates -> SqlCommentSanitizer, got %+v", f.Relations)
 	}
 }
+
+func TestAST_TestFnAtFileRoot_NoSymbolFact(t *testing.T) {
+	ff := extractAST(t, `
+use super::*;
+
+#[test]
+fn approvals_reviewer_serializes_auto_review() {
+    assert_eq!(1, 1);
+}
+`)
+	if _, ok := findFact(ff, "pkg.approvals_reviewer_serializes_auto_review"); ok {
+		t.Error("a #[test] fn at file scope (e.g. a plain tests.rs) should not become a production symbol fact")
+	}
+}
+
+func TestAST_TestFnAtFileRoot_CreditsProductionCall(t *testing.T) {
+	ff := extractAST(t, `
+fn helper() {}
+
+#[test]
+fn calls_helper() {
+    helper();
+}
+`)
+	if _, ok := findFact(ff, "pkg.calls_helper"); ok {
+		t.Error("a #[test] fn should not become a symbol fact")
+	}
+	refs := findFactsByKind(ff, facts.KindTestRef)
+	if len(refs) != 1 || !hasRelation(refs[0], facts.RelCalls, "pkg.helper") {
+		t.Errorf("expected a KindTestRef -> pkg.helper, got %+v", refs)
+	}
+}
+
+func TestAST_FunctionPointerArrayLiteral_ReferencesEach(t *testing.T) {
+	ff := extractAST(t, `
+type Pass = fn(&mut Value);
+const PASSES: &[Pass] = &[strip_a, drop_b];
+fn strip_a(v: &mut Value) {}
+fn drop_b(v: &mut Value) {}
+`)
+	c, ok := findFact(ff, "pkg.PASSES")
+	if !ok {
+		t.Fatal("expected fact for pkg.PASSES")
+	}
+	for _, want := range []string{"pkg.strip_a", "pkg.drop_b"} {
+		if !hasRelation(c, facts.RelCalls, want) {
+			t.Errorf("expected RelCalls -> %s, got %+v", want, c.Relations)
+		}
+	}
+}
+
+func TestAST_SchemarsSchemaWithAttribute_ReferencesFunction(t *testing.T) {
+	ff := extractAST(t, `
+pub struct Event {
+    #[schemars(schema_with = "event_name_schema")]
+    name: String,
+}
+fn event_name_schema(g: &mut SchemaGenerator) -> Schema { todo!() }
+`)
+	s, ok := findFact(ff, "pkg.Event")
+	if !ok {
+		t.Fatal("expected fact for pkg.Event")
+	}
+	if !hasRelation(s, facts.RelCalls, "event_name_schema") {
+		t.Errorf("expected RelCalls -> event_name_schema, got %+v", s.Relations)
+	}
+}
+
+func TestAST_SchemarsSchemaWithQualifiedPath_ReferencesFunction(t *testing.T) {
+	ff := extractAST(t, `
+pub struct Features {
+    #[schemars(schema_with = "crate::schema::features_schema")]
+    flags: Vec<String>,
+}
+fn features_schema(g: &mut SchemaGenerator) -> Schema { todo!() }
+`)
+	s, ok := findFact(ff, "pkg.Features")
+	if !ok {
+		t.Fatal("expected fact for pkg.Features")
+	}
+	if !hasRelation(s, facts.RelCalls, "features_schema") {
+		t.Errorf("expected RelCalls -> features_schema, got %+v", s.Relations)
+	}
+}
+
+func TestAST_SelfCallAcrossSeparateImplBlocks_NotDropped(t *testing.T) {
+	ff := extractAST(t, `
+pub struct Foo;
+impl Foo {
+    fn helper(&self) {}
+}
+impl Foo {
+    fn caller(&self) {
+        self.helper();
+    }
+}
+`)
+	f, ok := findFact(ff, "pkg.Foo.caller")
+	if !ok {
+		t.Fatal("expected fact for pkg.Foo.caller")
+	}
+	if !hasRelation(f, facts.RelCalls, "helper") {
+		t.Errorf("expected RelCalls -> helper, got %+v", f.Relations)
+	}
+}
+
+func TestAST_SelfCallWithinSameImplBlock_StillQualified(t *testing.T) {
+	ff := extractAST(t, `
+pub struct Foo;
+impl Foo {
+    fn helper(&self) {}
+    fn caller(&self) {
+        self.helper();
+    }
+}
+`)
+	f, ok := findFact(ff, "pkg.Foo.caller")
+	if !ok {
+		t.Fatal("expected fact for pkg.Foo.caller")
+	}
+	if !hasRelation(f, facts.RelCalls, "pkg.Foo.helper") {
+		t.Errorf("expected qualified RelCalls -> pkg.Foo.helper, got %+v", f.Relations)
+	}
+}