CALLS edges are emitted for calls inside statically-dead code (`if False:`, `if TYPE_CHECKING:`, `#if 0`)

[HouMinXi]

Summary

The graph indexes function calls that occur inside statically-unreachable code as ordinary live CALLS edges. Because the parse is structural (Tree-sitter, no reachability analysis and no C preprocessor evaluation), downstream consumers cannot distinguish a call that can execute from one that never will.

Reproduction (Python)

# consumer.py
from api import process_request

def live_caller():
    process_request()          # line 5

def dead_caller():
    if False:                  # statically dead
        process_request()      # line 10 -- never executes

code-review-graph build --skip-flows

Resulting edges (both present):

CALLS  consumer.py::dead_caller -> process_request   line 10
CALLS  consumer.py::live_caller -> process_request   line 5

The dead_caller edge should not be presented as a live call.

Reproduction (C/C++)

A call inside a #if 0 ... #endif block is likewise emitted as a live CALLS edge (observed on a real C++ project: a call inside a #if 0 block was indexed identically to the active code path).

Impact

Any consumer doing impact analysis / caller discovery over CALLS edges gets false positives from dead code: "symbol X is called at <dead site>", when that site can never run.

Suggestion

Either (a) skip emitting CALLS edges whose call expression is inside an obviously-dead construct, or (b) tag such edges (e.g. reachable=0 / a "dead-code" confidence_tier) so consumers can filter. The common cheap-to-detect idioms cover most of the value:

• Python: if False: / if 0: / if TYPE_CHECKING: ; code after an unconditional return/raise/break/continue
• C/C++: #if 0 ... #endif (and #ifdef of an undefined macro)

Full reachability is undecidable and not expected; handling these common static-dead idioms would remove the bulk of the false positives.

[itxaiohanglover]

I can take a look at this. My idea for a simple first pass:

1. In the Python parser, check if a call_expression is inside an if False: or if TYPE_CHECKING: block by walking up the Tree-sitter ancestor chain
2. Mark those edges with a confidence: 0.0 or a dead_code: true flag instead of filtering them out entirely (some users may still want to see them)
3. For C/C++, checking #if 0 is harder (preprocessor) — skip for now

This would be opt-in: edges are still created but flagged, so existing queries are unaffected.

Mind if I take this?

[HouMinXi]

Yes please, go ahead, and thanks for offering.

Flagging instead of dropping (your point 2) is what I was hoping for: impact-analysis consumers can filter the dead edges out, and anyone who wants the full structural view still has them.

One ask on the representation. Could the marker be its own queryable field rather than confidence: 0.0? A reachable: false (or a named dead-code tier) is something a consumer can filter on directly, whereas a 0.0 confidence is ambiguous: you can't tell "dead code" apart from "low confidence for some other reason." if TYPE_CHECKING: is the clearest example. Those calls aren't wrong, they just never run at runtime, so "unreachable" fits them better than "dead."

On scope, Python if False: / if TYPE_CHECKING: is a good first cut. if 0: is the same ancestor walk if you want it cheaply. The other common idiom is calls after an unconditional return / raise / break / continue, which is probably the most frequent source in real code, so it's worth getting to. C/C++ #if 0 is the hard one (preprocessor), so leaving it as a follow-up is fine.

Could we keep the issue open until the after-jump and C/C++ cases are covered, even if the if False: / TYPE_CHECKING: pass merges first? That way the parts your first PR doesn't cover stay tracked rather than getting lost.

[HouMinXi]

I've taken the implementation for this and opened #580 with the extra["reachable"] approach.

Semantics (locked for downstream compatibility):

• Dead-code CALLS edge: extra.reachable = false
• Live CALLS edge: reachable key absent (not true)
• Downstream filter: json_extract(extra, '$.reachable') IS NULL OR json_extract(extra, '$.reachable') != 0

v1 scope: Python if False: and if TYPE_CHECKING: via ancestor walk in _extract_calls. All Tree-sitter languages benefit. C #if 0 and bespoke-handler languages are deferred.

@itxaiohanglover -- would appreciate your review on the PR, especially the column semantics above so we agree before merge rather than after.