fix(python): suppress bare calls shadowed by an enclosing parameter

[DeusData]

Distilled from #1386 with Co-authored-by: credit to @Joseph-MingEn, who identified this defect class. The mechanism differs from theirs — see below.

The gap

After #1903 landed Python member-call suppression, this still resolves wrongly:

def _run_with_heavy_slot(run):
    return run()          # suffix_matches onto SatoriLive.run

#1903 structurally cannot catch it — there is no receiver, so its guard never fires. #1647's cross-language suffix guard only fires when caller and target languages differ, and both are Python here. So the class survives everything currently on main.

Keyed on local binding, not on a name list

#1386 keyed this on {get, run, execute}. That is a claim about spellings, not about whether the resolver knew anything — and it would age invisibly: nothing fails when the generic-name distribution shifts, the graph just quietly loses different edges. It is also open-ended (why not start, send, handle, process?) and corpus-dependent.

This keys on the fact that decides the question: the callee identifier is bound as a parameter of an enclosing function, so it shadows any project function and short-name resolution is fabricated by construction. No list, decidable outright, and it covers handler(), callback(), fn() and every Callable-parameter shape.

Parameters only, deliberately. A parameter is in scope for the entire body regardless of position, and Python forbids global on a parameter (SyntaxError: name is parameter and global), so no flow analysis is needed. Local assignments are flow- and binding-form-sensitive across for, with…as, except…as, :=, unpacking, nested def/class, import, plus global/nonlocal — a partial version would be incomplete invisibly, which is the failure mode the name list was rejected for. That wants a real scope analyser and its own evidence.

Enclosing scopes are covered to any depth — def outer(run): def inner(): return run(), a common decorator/callback shape, is caught — and depth costs nothing, for the reason set out below. The one knowingly over-flagged shape (global run in a nested function whose outer scope has a run parameter) is documented in the helper rather than left silent.

A new field rather than overloading is_method

callee_is_locally_bound is a distinct field on CBMCall. is_method means "member call with unresolved receiver" and is read by the pxc synthetic-carrier dedup key (pass_lsp_cross.c:801/:815); overloading it for bare calls would corrupt that key and make the field's documented contract untrue.

One drop-list, shared

The weak-strategy list (suffix_match / unique_name / field_type_hint / fuzzy) is now a single weak_short_name_strategy() used by both the member guard and this one. Two copies would have let the guards silently disagree about what "weak" means. weak_call_guards_share_one_drop_list pins that agreement across 15 strategies — and it fired correctly during revert-check.

Python-gated, wired at both pass_calls.c and pass_parallel.c with textually identical gates. ArkTS preserved in both member gates.

Evidence — three revert-check rounds, each isolating one claim

round	break	result
A	disable the pass_parallel.c gate only	exactly 1 failure — the ≥50-file test; the sequential test still passed. Proves the parallel test genuinely exercises pass_parallel.c rather than falling back to the sequential path
B	under-suppress (flag + guard)	exactly 5 failures, all this change's — extraction flag, both registry drops, both pipeline negatives
C	over-suppress (guard ignores the binding)	exactly 3 failures — the registry keep-assertion and both pipeline positive controls

Round C is the one that matters. It proves the positive controls are not vacuous: uses_free_function → compute_widget_total is a cross-file bare call with no import, so it resolves by a weak strategy this guard can drop — and an over-suppressing guard does drop it. #1386's positive asserted a same_module edge that no guard touches for any input, so it would have passed even if the change dropped every other Python edge. Both pipeline tests also carry ASSERT_GTE(CALLS, 1) anti-vacuity.

The extraction test pins all 7 parameter binding forms (bare, typed, default, keyword-only, *args, **kwargs, lambda, closure) plus 3 negatives (unbound, imported, nested def), each asserted to appear exactly once.

Verification

pipeline registry parallel extraction complexity lsp_resolution_probe → 805 passed, 0 failed. Built in a fresh worktree with no prior build/, so no stale-binary exposure. All 6 new tests confirmed by name in output, and RUN_TESTs verified inside SUITE(pipeline) rather than the pipeline_semantic_manifest_repro decoy that has swallowed tests before.

Cost is O(1) per bare call, plus O(params) once when a def or lambda scope opens — never corpus-coupled, so no complexity-guard interaction. CBMCall is not serialized, so no cache or index-format bump.

How the lookup got to O(1) — two corrections worth reading

The first cut answered "is this callee a parameter of an enclosing scope?" by ascending the tree per call, which is the obvious implementation and the wrong one.

Correction 1 — the ascent was a hang, not a slowdown. ts_node_parent() is not O(1): it restarts at the tree root and descends to find the parent, so each hop costs O(depth), a parent chain is O(depth²) per call, and since every level of f(f(f(...))) is itself a bare call, the file-wide cost is O(depth³). stack_overflow_b's 30,000-deep fixture went to rc=124 at 900s with zero tests completed, on all seven CI legs. A hop-count cap alone was measured and rejected: with a 64-hop cap the suite still timed out, because 64 × O(30,000) × 30,000 is ~5.7e10. When the cost is per hop, bounding the number of hops cannot fix it.

Correction 2 — the cheap ascent still needed a cap, and the cap failed open. Ascending with the unified walk's own cursor makes each hop genuinely O(1), which fixed the hang (900s → 46s). But the walk is still O(depth) per call, so it needed a 64-ancestor bound — and past that bound the guard stopped suppressing. Deep-but-ordinary code silently kept the fabricated edges this PR exists to remove, and no test failed when it did.

The fix is to stop recomputing. The unified walk binds a def's or lambda's parameters when it opens that scope and unwinds them when it closes, so the guard is a map lookup. This is the lesson CBMWalkScope already records one struct away: carry walk state, never recompute it per node.

• CBMParamSlot is a name → active-count map, not a set: def outer(run): def inner(run): binds one name twice, and leaving the inner scope must not unbind the outer.
• Bindings are pushed at the end of push_boundary_scopes, after every scope push for that node, so they land in the frame just pushed — covering function_definition (via push_function_scope) and lambda (via push_lexical_boundary) alike — and pop_expired_scopes unwinds to the frame's entry height.
• Allocation failure sets py_param_tracking_failed and the lookup answers false thereafter: a lost suppression, never a lost edge.

The repo's other binding table cannot serve this, and it is worth recording why: CBMLexicalBinding is qsort-ed in cbm_finalize_lexical_usages after the walk and its active_end stays 0 until then, so its binary search is invalid from handle_calls, which runs mid-walk and before handle_usages.

With no cap there is nothing left to fail open, so the test that pinned the cap's contract is replaced by extract_python_bare_call_flag_is_depth_independent. It keeps the shallow and 200-ancestor cases — the deep one now asserts the call is flagged, so reintroducing a cap fails it — and adds an unwind case: handler as both a parameter and a module-level def, asserting the two shadowed calls are flagged and the sibling call after that scope closed is not. A binding outliving its frame would destroy that true edge, the one direction this guard must never fail in.

Re-verified on the final tree: extraction 327 passed, pipeline registry parallel complexity 407 passed, stack_overflow_b 6 passed in 38s (46s with the cursor ascent, 900s rc=124 before it) with lsp_python_deep_nesting_no_crash green, and make lint-ci (cppcheck + clang-format) clean.