feat(rust): update cache version to v113

Author: GertL

internal/cachecov/coverage_test.go

@@ -145,13 +145,7 @@ var versionCoverage = map[int][]string{
 	111: {"TestExtract_HTTPHandlerProp", "TestBindHTTPHandlers_BindsViaSignature", "TestBindHTTPHandlers_RejectsNonHandlerBySignature", "TestBindHTTPHandlers_AmbiguousMethodNameSkipped", "TestBindHTTPHandlers_MiddlewareNotBound", "TestBindHTTPHandlers_Idempotent", "TestBindHTTPHandlers_CrossRepoNotBound", "TestGolden"}, // Go emits http_handler on func(http.ResponseWriter, *http.Request); bindHTTPHandlers uses it to resolve a route's registration-site handler expression to the declaring symbol, rejecting same-named non-handlers (the wiring package's null-object stub) by SIGNATURE rather than by name, and skipping ambiguous method names outright (new/18) // 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)
 	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)
-	115: {"TestGolden", "TestOwnsFile", "TestAST_ImplTraitForType_EmitsImplements"}, // Rust extractor added: symbols, implements post-pass, dependency/calls/route facts, cache participation
-	116: {"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
-	117: {"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
-	118: {"TestAST_DropImplTagsOverride", "TestAST_FutureImplTagsOverride", "TestAST_InherentDropLikeMethod_NotTaggedOverride", "TestAST_OtherTraitMethodNamedDrop_NotTaggedOverride"}, // Rust: Drop::drop/Future::poll tagged override (compiler/runtime-invoked, never called by name)
-	119: {"TestGolden", "TestAST_ScopedAssociatedFnCall_InstantiatesType", "TestAST_ScopedAssociatedFnCall_SelfNotInstantiated"},                                                                                                                              // Rust: Type::assoc_fn() records RelInstantiates for Type
-	120: {"TestAST_BareScopedVariantValue_InstantiatesEnum", "TestAST_ScopedVariantInMatchPattern_InstantiatesEnum", "TestAST_ScopedMethodCall_NotTreatedAsVariant"},                                                                                          // Rust: Type::Variant records RelInstantiates for Type (bare value or match pattern)
-	121: {"TestAST_BareUnitStructValue_Instantiates", "TestAST_BareUnitStructValue_LetBinding_Instantiates", "TestAST_ScopedAssociatedFnCall_SelfNotInstantiated"},                                                                                          // Rust: bare capitalized identifier value instantiates it
+	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
 }
 
 func TestCacheVersionCoverage(t *testing.T) {

internal/engine/cache.go

@@ -434,45 +434,29 @@ import (
 // carries scanned_plugin=true (consumed by the enterprise dead-code detector as an
 // entry point). Both are new/changed facts, so cached Java snapshots must re-extract
 // (GAP-JV-08, new/60).
-// v115: 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). Rust is a new FileOwner, so its arrival also reshuffles which files count as
+// v114: 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; cyclomatic complexity; Axum route facts; and
+// RelCalls/RelInstantiates edges covering calls inside a macro invocation's token_tree
+// (bail!/format!/matches! arguments, and an ordinary call embedded in any attribute
+// macro, e.g. thiserror's #[error("{}", helper(x))]), a function passed by name as a
+// value (call argument, struct field, &f, nested inside a macro argument like
+// vec![Box::new(f)], or a local fn declared earlier in the same body), serde/clap/merge
+// attribute strings and scoped paths (default, skip_serializing_if, value_parser,
+// strategy), an unprefixed `use foo::bar;` where foo is a body-less `mod foo;` in the
+// same file/mod scope (classified internal instead of external), 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 — recorded on a file_ref
+// fact instead of dropped), a scoped associated-function call (Type::new(),
+// some_mod::Type::from(x)), Type::Variant (bare value or match pattern), and a bare
+// capitalized identifier used as a plain value (unit struct argument/let-binding) — the
+// last three all recorded as RelInstantiates for Type, the dominant Rust construction
+// idioms beyond a struct literal. Drop::drop and Future::poll are tagged override
+// (compiler/runtime-invoked, never called by name), mirroring Kotlin/Swift's `override`
+// 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.
-// v116: 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.
-// v117: 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.
-// v118: 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).
-// v119: Rust records a RelInstantiates edge for the leading type in a scoped associated-
-// function call (Type::new(), some_mod::Type::from(x)) — the most common Rust
-// constructor idiom, previously invisible to the graph since only a struct literal or a
-// bare capitalized tuple-call counted as "instantiated".
-// v120: Rust records Type::Variant (capitalized trailing segment) as instantiating Type,
-// whether it's a plain value (match-arm result) or inside a match pattern.
-// v121: Rust records a bare capitalized identifier used as a plain value (a unit struct
-// passed as an argument, a let-binding) as instantiating it — previously skipped since
-// it looked the same as an ordinary lowercase local/param.
-const cacheVersion = "v121"
+const cacheVersion = "v114"
 
 // 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