feat(rust): update cache version to v114 and enhance AST extraction with Drop and Future method overrides

Author: GertL

internal/cachecov/coverage_test.go

@@ -147,6 +147,7 @@ var versionCoverage = map[int][]string{
 	113: {"TestGolden", "TestOwnsFile", "TestAST_ImplTraitForType_EmitsImplements"}, // Rust extractor added: symbols, implements post-pass, dependency/calls/route facts, cache participation
 	114: {"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
 	115: {"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
+	116: {"TestAST_DropImplTagsOverride", "TestAST_FutureImplTagsOverride", "TestAST_InherentDropLikeMethod_NotTaggedOverride", "TestAST_OtherTraitMethodNamedDrop_NotTaggedOverride"}, // Rust: Drop::drop/Future::poll tagged override (compiler/runtime-invoked, never called by name)
 }
 
 func TestCacheVersionCoverage(t *testing.T) {

internal/engine/cache.go

@@ -448,7 +448,11 @@ import (
 // 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 = "v115"
+// v116: Rust tags Drop::drop and Future::poll methods with the override prop — they are
+// invoked exclusively by the compiler (scope exit) or the async runtime (.await), never
+// by their literal method name, so the dead-code detector now excludes them like any
+// other framework-dispatched override (mirrors Kotlin/Swift's `override` handling).
+const cacheVersion = "v116"
 
 // 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

@@ -87,6 +87,11 @@ type astWalker struct {
 	// emitEdge would otherwise silently drop for lack of an owner.
 	fileRefIdx int
 
+	// implTrait: the trait name of the impl block currently being walked
+	// ("" outside any impl, or for a plain inherent impl). Lets handleFunction
+	// recognize compilerOrRuntimeInvokedMethods (Drop::drop, Future::poll).
+	implTrait string
+
 	// 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
@@ -443,8 +448,9 @@ func (w *astWalker) handleImpl(node *sitter.Node) {
 	if typeName == "" {
 		return
 	}
+	traitName := ""
 	if traitNode := node.ChildByFieldName("trait"); traitNode != nil {
-		if traitName := simpleTypeName(traitNode, w.src); traitName != "" {
+		if traitName = simpleTypeName(traitNode, w.src); traitName != "" {
 			w.impls = append(w.impls, implPair{
 				typeName:  w.dir + "." + w.qualify(typeName),
 				traitName: traitName,
@@ -454,11 +460,14 @@ func (w *astWalker) handleImpl(node *sitter.Node) {
 
 	body := node.ChildByFieldName("body")
 	w.pushType(typeName, collectFnNames(body, w.src))
+	savedImplTrait := w.implTrait
+	w.implTrait = traitName
 	if body != nil {
 		for i := uint(0); i < uint(body.ChildCount()); i++ {
 			w.walkChild(body.Child(i))
 		}
 	}
+	w.implTrait = savedImplTrait
 	w.popType()
 }
 
@@ -492,6 +501,9 @@ func (w *astWalker) handleFunction(node *sitter.Node) {
 			f.Props["static"] = true
 		}
 	}
+	if compilerInvokedTraitMethods[w.implTrait][name] {
+		f.Props["override"] = true
+	}
 
 	w.out = append(w.out, f)
 	ownerIdx := len(w.out) - 1
@@ -1100,6 +1112,17 @@ var rustBuiltins = map[string]bool{
 	"format": true, "assert": true, "matches": true,
 }
 
+// compilerInvokedTraitMethods: trait methods invoked exclusively by the
+// compiler (Drop::drop, at scope exit — calling it directly is a compile
+// error) or the async runtime (Future::poll, driven by .await), never by
+// their literal method name in ordinary code. Unlike fmt/eq/hash/clone/
+// default — which sometimes genuinely are called by name — these have no
+// legitimate direct-call precedent, so they're always safe to exclude.
+var compilerInvokedTraitMethods = map[string]map[string]bool{
+	"Drop":   {"drop": true},
+	"Future": {"poll": true},
+}
+
 // hasSelfParam reports whether a `parameters` node's first parameter is
 // `self`/`&self`/`&mut self`, distinguishing a method from an associated
 // (static) function declared in the same impl/trait block.

internal/extractors/rustextractor/rust_ast_test.go

@@ -899,3 +899,73 @@ ffi_fn! {
 		t.Errorf("expected a KindFileRef -> pkg.with_cow, got %+v", refs)
 	}
 }
+
+func TestAST_DropImplTagsOverride(t *testing.T) {
+	ff := extractAST(t, `
+pub struct Guard;
+impl Drop for Guard {
+    fn drop(&mut self) {}
+}
+`)
+	f, ok := findFact(ff, "pkg.Guard.drop")
+	if !ok {
+		t.Fatal("expected fact for pkg.Guard.drop")
+	}
+	if f.Props["override"] != true {
+		t.Errorf("Drop::drop override = %v, want true", f.Props["override"])
+	}
+}
+
+func TestAST_FutureImplTagsOverride(t *testing.T) {
+	ff := extractAST(t, `
+pub struct MyFuture;
+impl Future for MyFuture {
+    type Output = ();
+    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<()> {
+        Poll::Ready(())
+    }
+}
+`)
+	f, ok := findFact(ff, "pkg.MyFuture.poll")
+	if !ok {
+		t.Fatal("expected fact for pkg.MyFuture.poll")
+	}
+	if f.Props["override"] != true {
+		t.Errorf("Future::poll override = %v, want true", f.Props["override"])
+	}
+}
+
+func TestAST_InherentDropLikeMethod_NotTaggedOverride(t *testing.T) {
+	ff := extractAST(t, `
+pub struct Cache;
+impl Cache {
+    fn drop(&mut self) {}
+}
+`)
+	f, ok := findFact(ff, "pkg.Cache.drop")
+	if !ok {
+		t.Fatal("expected fact for pkg.Cache.drop")
+	}
+	if f.Props["override"] == true {
+		t.Errorf("inherent (non-trait) drop method should not be tagged override, got %v", f.Props["override"])
+	}
+}
+
+func TestAST_OtherTraitMethodNamedDrop_NotTaggedOverride(t *testing.T) {
+	ff := extractAST(t, `
+trait Cleaner {
+    fn drop(&mut self);
+}
+pub struct Sweeper;
+impl Cleaner for Sweeper {
+    fn drop(&mut self) {}
+}
+`)
+	f, ok := findFact(ff, "pkg.Sweeper.drop")
+	if !ok {
+		t.Fatal("expected fact for pkg.Sweeper.drop")
+	}
+	if f.Props["override"] == true {
+		t.Errorf("a custom trait's drop method (not std::ops::Drop) should not be tagged override, got %v", f.Props["override"])
+	}
+}

pkg/mcputil/generated_path_test.go

@@ -17,6 +17,10 @@ func TestIsGeneratedPath(t *testing.T) {
 		"airflow/ui/openapi-gen/requests/client/utils.gen.ts",
 		"a/b/params.gen.tsx", "svc/api.pb.go", "svc/api_pb2.py",
 		"svc/api_pb2_grpc.py", "web/app.min.js", "web/app.min.css",
+		// Bare "gen" segment (prost-build and similar Rust/Go protobuf output).
+		"crates/proto-rust/src/gen/v1.public.core_types.rs",
+		"crates/dbt-telemetry/src/gen/v1.events.rs",
+		"pkg/gen/api.pb.rs",
 	}
 	for _, p := range generated {
 		if !IsGeneratedPath(p) {
@@ -28,7 +32,9 @@ func TestIsGeneratedPath(t *testing.T) {
 		"airflow/models/dagrun.py", "internal/perf/perf.go",
 		"src/components/Graph/reactflowUtils.ts",
 		// "generator" is not the exact segment "generated"; ".genesis.ts" is not ".gen.ts".
+		// "general"/"genetics" are not the exact segment "gen".
 		"pkg/generator/x.go", "src/genesis.ts", "app/vendored_helpers.py",
+		"internal/general/config.go", "src/genetics/model.py",
 		// Bare "env" is too common to treat as a venv; only .venv/venv/site-packages match.
 		"app/env/settings.py", "src/environments/prod.py",
 	}

pkg/mcputil/mcputil.go

@@ -104,7 +104,7 @@ func CapTokens(s string, maxTokens int, isJSON bool) string {
 func IsGeneratedPath(p string) bool {
 	for _, part := range strings.Split(p, "/") {
 		switch part {
-		case "build", "Pods", "node_modules", "kspCaches", "generated",
+		case "build", "Pods", "node_modules", "kspCaches", "generated", "gen",
 			"__pycache__", "vendor", "openapi-gen", "__generated__", "third_party",
 			// Python virtual environments and installed dependencies — never source.
 			".venv", "venv", "site-packages":
@@ -121,7 +121,7 @@ func IsGeneratedPath(p string) bool {
 	// protoc, `.min.js` is a minified bundle whose loop nesting is meaningless.
 	for _, suf := range []string{
 		".gen.ts", ".gen.tsx", ".gen.js", ".gen.go", ".generated.ts", ".generated.go",
-		".min.js", ".min.css", ".pb.go", ".pb.gw.go", ".g.dart",
+		".min.js", ".min.css", ".pb.go", ".pb.gw.go", ".pb.rs", ".g.dart",
 		"_pb2.py", "_pb2_grpc.py",
 	} {
 		if strings.HasSuffix(base, suf) {