fix(classifiers): detect transitively-unreachable dead code, not just fanIn===0

[carlos-alm]

Summary

• roles --role dead treated any inbound calls edge as sufficient evidence of liveness, without checking whether the caller itself is reachable from a confirmed-live root. A function called only by another unreachable function kept a non-dead role forever.
• Adds a worklist/BFS transitive-reachability pass (applyReachabilityDowngrade in src/graph/classifiers/roles.ts, mirrored as apply_reachability_downgrade in crates/codegraph-core/src/graph/classifiers/roles.rs) that runs after the existing per-node classification. It is strictly downgrading — never upgrades a verdict, never touches entry/test-only/hasActiveFileSiblings rescues/interface-type-members — it only reconsiders function/method nodes whose core/utility/adapter/leaf verdict came from direct fan-in (classifyByFanShape).
• Roots: function/method nodes on the genuinely public surface (explicit export keyword, or the SPECIFIC symbol named in a confirmed production-reachable reexport, or every symbol in a file reached via a genuine export * from — deliberately NOT the broader "some cross-file caller exists" signal, nor "shares a file with a named-reexported sibling", see Greptile fixes below) / framework-dispatched (route:/event:/command:) / Commander-dispatch, plus every calls-edge SOURCE that isn't itself a function/method (module-top-level constant declarations, bare file-scope assignments like Lua's require = tracedFn) and method-kind interface-dispatch implementations whose name matches a declared interface/type member (Visitor-pattern methods invoked only via generic property access) — none of these can ever be the target of a calls edge by construction, so they must count as unconditionally live.
• Deliberately does not promote function-kind logical-or-fallback rescues to roots — doing so would silently re-rescue genuinely-dead intermediate functions, defeating the fix for the common case (see code comments for the reasoning and a regression test guarding it).

Scope decision

Implemented for the full-classification path only (classifyNodeRolesFull / Rust do_classify_full). The incremental path cannot safely compute whole-graph reachability from a changed-files-scoped window — a node's only live path in can run through files entirely outside that window — without either reintroducing a full-graph scan on every incremental build (undermining the perf work that path was built around) or a real incremental-reachability-maintenance design (handles edge additions fine, edge removals need decremental reachability). Filed as a tracked follow-up: #2255.

Root-identification bugs found and fixed

Running codegraph roles --role dead -T on this repo's own src/ before/after (each fix re-validated the same way) surfaced real root-identification bugs, all fixed before landing:

1. Interface/type method-signature members (e.g. NativeDatabase.countNodes in src/types.ts) get 'leaf' unconditionally from isTypeDeclarationMember, independent of fanIn — indistinguishable from classifyByFanShape's 'leaf' by role string alone. Fixed by explicitly excluding type-declaration members from the downgrade pass.
2. method-kind interface-dispatch implementations (e.g. enterNode/exitNode in src/ast-analysis/visitors/*.ts, dispatched via if (v.enterNode) v.enterNode(...)) can never be the target of a calls edge by construction, so they could never be BFS-reachable — wrongly starving their own callees. Fixed by adding isInterfaceDispatchMethodRoot.
3. (Greptile review) isLiveRoot used the broad isExported flag, which also fires when some caller in a different file calls a symbol regardless of whether that caller is itself reachable — letting a cross-file dead call chain evade the whole check. Fixed with a narrower isPublicSurface (explicit export / confirmed reexport chain only).
4. (Greptile review) isInterfaceDispatchMethodRoot promoted any method with fanIn===0, fanOut>0, and an active file sibling — indistinguishable from an ordinary dead class method that happens to call a helper. Fixed by requiring the method's bare name to match an actual declared interface/type member somewhere in the codebase.
5. (Greptile review) publicSurfaceIds reused the pre-existing whole-file reexport query, which treats ANY reexports edge (named or wildcard) as "every symbol in the target file is exported". Fixed by using the symbol-level reexports edge a named reexport already gets, falling back to whole-file marking only for a genuine export * from (reexports-wildcard). Caught a real live instance in this repo's own self-build (src/extractors/groovy.ts's AST-node-dispatch handlers).

Re-validating after fixes 3-5 surfaced two further narrow, out-of-scope gaps — filed as #2259 and #2260 rather than solved inline.

Before/after on this repo's own self-build (src/, -T)

	origin/main	this PR
dead-entry	61	61
dead-ffi	17	60
dead-leaf	91	91
dead-unresolved	464	615
total	633	827

+194 delta. Diffed the actual symbol lists (not just totals) at every step of the fix, not just the final one: the large majority are pre-existing hand-authored parser/resolution test fixtures under tests/benchmarks/** / tests/fixtures/** that -T's filename-only heuristic doesn't exclude (tracked as #2256) — these grew once the cross-file-root fix (#3 above) closed a loophole those fixtures relied on especially heavily (they're full of cross-file call-resolution test cases with no genuine exported entry point). The remaining real src/ findings are the already-tracked #2257 (2 cases), #2259 (1 case, 4 downstream nodes), and #2260 (1 case, 4 downstream nodes — caught and fixed by review round 3, then re-surfaced as a distinct root cause once the reexport-scoping bug was corrected).

Testing

• npm run lint — clean
• npm test — 271 files / 4395 tests pass (added TS unit + integration tests for the reachability pass, including regression tests for all three Greptile findings, + updated pre-existing fixtures whose only "root" was one of the now-narrower signals, to keep testing what they originally intended)
• cargo test -p codegraph-core --lib — 741 tests pass (mirrored Rust unit tests using an in-memory NativeDatabase)
• Verified against the issue's own repro shape (an equivalent one, since the literal snippet in the issue doesn't create a separate node for the nested arrow-function closure — codegraph attributes its call to the enclosing named function by design) with both engines
• codegraph diff-impact --staged -T: small, expected blast radius scoped to the classifier module

Follow-up issues filed

• roles --role dead: incremental classification doesn't get the #2032 transitive-reachability fix #2255 — incremental-path reachability parity (design + perf work needed)
• roles --role dead -T: hand-authored test fixture directories aren't excluded, causing reachability noise #2256 — -T doesn't exclude tests/benchmarks/**/fixtures/** / tests/fixtures/** fixture directories
• Function-value logical-or-fallback references lack a real calls edge, unlike object-literal value-refs (#1771) #2257 — function-value logical-or-fallback references still lack a real calls edge (mirrors Dispatch-table function references (resolve: fn) inconsistently flagged dead-unresolved depending on unrelated fanOut #1771/roles --role dead: object-literal property-value references count as liveness without checking if the property is ever invoked (false negative) #1895 for a different value-ref shape)
• Method-kind event-callback registrations (EventEmitter-style) aren't recognized as reachability roots #2259 — method-kind EventEmitter-style callback registrations aren't recognized as reachability roots (surfaced while fixing Greptile's review findings)
• Computed-property (bracket-access) dispatch-table lookups lack a real calls edge, unlike dot-property value-refs #2260 — computed/bracket-access dispatch-table lookups (table[key](...)) still lack a real calls edge, unlike dot-property value-refs (surfaced while fixing the reexport-scoping bug)

Closes #2032

[greptile-apps]

Greptile Summary

The PR changes full role classification to downgrade functions and methods that have direct fan-in but are unreachable from confirmed-live roots.

• Adds matching TypeScript and Rust reachability traversals over calls edges.
• Narrows root selection to explicit exports and production-reachable named or wildcard reexports.
• Preserves interface-dispatch, framework-entry, and non-callable-source roots.
• Adds unit and integration coverage for unreachable chains and the previously reported root-selection defects.

Confidence Score: 5/5

The PR appears safe to merge.

No blocking failure remains in the current fixes for the previously reported threads.

Important Files Changed

Filename	Overview
src/graph/classifiers/roles.ts	Adds the TypeScript reachability pass and narrowed root rules; the fixes for the prior classifier threads are present.
src/features/structure.ts	Builds the narrowed public-surface set and supplies full call adjacency to full classification.
crates/codegraph-core/src/graph/classifiers/roles.rs	Mirrors the TypeScript reachability and public-surface behavior in the native classifier.
tests/graph/classifiers/roles.test.ts	Covers reachability behavior and the previously reported cross-file and ordinary-method cases.
tests/integration/roles.test.ts	Exercises named and wildcard reexport classification through persisted graph data.

Flowchart

%%{init: {'theme': 'neutral'}}%%
flowchart TD
  A[Classify nodes by fan shape] --> B[Collect confirmed-live roots]
  B --> C[Traverse calls edges]
  C --> D{Fan-shape function or method reachable?}
  D -->|Yes| E[Keep existing role]
  D -->|No| F[Downgrade to dead sub-role]

Loading

_{Reviews (3): Last reviewed commit: "fix(classifiers): scope reexport-derived..." | Re-trigger Greptile}

[greptile-apps]

Cross-file references become roots

When an unexported function is called across files only by an unreachable function, the existing cross-file-reference heuristic sets isExported, and isLiveRoot consequently seeds the callee as a BFS root. The callee and its descendants retain live fan-shape roles instead of being classified as dead, so cross-file dead call chains remain undetected.

Knowledge Base Used:

• Graph Model & Algorithms
• Rust Native Core and the Native/WASM Bridge

[carlos-alm]

Valid, fixed in 7360d4f. Added a narrower isPublicSurface field (explicit export keyword + confirmed production-reachable reexport chains only), and switched isLiveRoot to check that instead of the broad isExported (which also fires from an unverified cross-file caller). Mirrored in the Rust classifier. Added regression tests in both engines confirming a symbol reachable only through an unreachable cross-file caller now correctly stays dead.

[greptile-apps]

Ordinary methods become live roots

When an unused class method calls a helper and shares its file with another called symbol, it satisfies this predicate because class methods use kind: 'method', receive hasActiveFileSiblings, and are not type-declaration members. The method is therefore treated as an interface-dispatch root, causing helpers reachable only through that dead method to retain live roles.

Knowledge Base Used:

• Graph Model & Algorithms
• Rust Native Core and the Native/WASM Bridge

[carlos-alm]

Valid, fixed in 7360d4f. isInterfaceDispatchMethodRoot now additionally requires the candidate method's bare name to match an actual interface/type declaration member somewhere in the codebase (e.g. enterNode against interface Visitor { enterNode?(...): ...; } in src/types.ts), not just the fanIn=0/fanOut>0/hasActiveFileSiblings shape alone. An unrelated dead class method now needs a coincidental name collision with some interface's member to slip through, instead of qualifying by default. Mirrored in Rust. Added regression tests in both engines for both the still-correct Visitor-pattern case and the now-fixed ordinary-dead-method case. (Re-validating against this repo's own self-build surfaced one further narrow gap this uncovers — genuine EventEmitter-style method callbacks with no matching interface declaration — filed as #2259 rather than trying to solve it inline.)

[github-actions]

Codegraph Impact Analysis

9 functions changed → 9 callers affected across 4 files

• buildClassifierInput in src/features/structure.ts:678 (5 transitive callers)
• classifyNodeRolesFull in src/features/structure.ts:839 (5 transitive callers)
• classifyNodeRolesIncremental in src/features/structure.ts:1179 (5 transitive callers)
• isLiveRoot in src/graph/classifiers/roles.ts:416 (4 transitive callers)
• computeReachableIds in src/graph/classifiers/roles.ts:437 (4 transitive callers)
• computeInterfaceMemberBareNames in src/graph/classifiers/roles.ts:480 (4 transitive callers)
• isInterfaceDispatchMethodRoot in src/graph/classifiers/roles.ts:528 (4 transitive callers)
• applyReachabilityDowngrade in src/graph/classifiers/roles.ts:607 (4 transitive callers)
• classifyRoles in src/graph/classifiers/roles.ts:662 (5 transitive callers)

[carlos-alm]

@greptileai

[greptile-apps]

Private reexport targets become roots

When a production-reachable barrel names one export from a module that also contains private functions, reexportExported includes every eligible symbol in that module and this loop adds them all to publicSurfaceIds. Those private functions become unconditional BFS roots, causing unreachable call chains beneath them to retain live roles instead of being classified as dead.

Knowledge Base Used:

• Graph Model & Algorithms
• Rust Native Core and the Native/WASM Bridge

[carlos-alm]

Valid, fixed in d08ffe7. publicSurfaceIds no longer reuses the whole-file reexportExported query. Named reexports already get their own symbol-level 'reexports' edge (target = the specific symbol, not the file) — now used directly; whole-file marking is scoped to a genuine export * from (kind 'reexports-wildcard') only. The pre-existing exportedIds/entry-classification query (#837) is untouched. Mirrored in Rust. Added regression tests in both engines (a named-reexport fixture where a private sibling reachable only through an unreachable caller correctly stays dead despite sharing a file with the re-exported symbol) — validating against this repo's own self-build actually caught a real live instance of exactly this bug (src/extractors/groovy.ts's AST-dispatch-table handlers), now fixed; filed #2260 for the underlying computed-dispatch-table extraction gap that instance also exposed.

[carlos-alm]

@greptileai