Fix(memorization) issue 710 py lsp memoization

[LA-10]

What does this PR do?

Fixes #710 index_repository hangs during the definitions pass on Python files with deeply chained method calls, consuming 800+ s and ~1.4 GB with no progress.

py_eval_expr_type (internal/cbm/lsp/py_lsp.c) recursively evaluates expression types with no memoization. Chained calls cause the same sub-chains to be re-evaluated at every level roughly O(2^N) in chain depth

Memoize py_eval_expr_type, keyed by node start byte. Each sub-expression is typed once, collapsing chain evaluation to O(depth). The original body is renamed _uncached and wrapped by a thin memoizing entry results identical, only redundant recomputation removed. Cache is arena-allocated per file (freed automatically).

Added pylsp_issue710_deep_call_chain_no_hang to tests/test_py_lsp.c a ~40-link chain that hangs on the old code and passes on the fix.

Checklist

• Every commit is signed off (git commit -s) — required, CI rejects
  unsigned commits (DCO, see CONTRIBUTING.md)
• Tests pass locally (make -f Makefile.cbm test)
• Lint passes (make -f Makefile.cbm lint-ci)
• New behavior is covered by a test (reproduce-first for bug fixes)

[DeusData]

Huge thanks for opening this PR and for the work you put into it.

The maintainer shop is currently full, so this may sit for a bit before it gets a proper review. We will come back to this as soon as possible with real feedback; I wanted to make sure it did not sit unacknowledged in the meantime.

[DeusData]

Thank you — your diagnosis is the correct one for #710, and we verified it independently: py_eval_expr_type evaluates each attribute receiver twice (container special-case + general attribute path), giving O(2^N) re-evaluation on chained calls; the recently-merged walker caps (#779) did not and could not address this. Memoization is the right generalized fix. One blocking correctness issue before merge:

• The cache key (node start byte) is not unique — every node shares its start byte with its leftmost descendants (a, a.b, a.b(), a.b().c() all collide). Insert is first-writer-wins, so the leftmost leaf's type permanently occupies the slot and composite results are silently dropped → wrong or missed CALLS edges on ordinary chained calls, repo-wide and silently. Please key on node identity (TSNode.id) or (start_byte, end_byte, symbol).
• Smaller: if arena alloc persistently fails, the insert probe loop can spin once the table is 100% full — a bounds check avoids a hang-path inside a hang fix.
• Test ask: add a heterogeneous-receiver chain (client.session().execute()-style) asserting the resolved QN — exactly the case the key collision breaks; your current fixture can't see it because G and G() evaluate to the same type.
  With those, this is the primary fix for Python parser hangs on deeply chained method calls during definitions pass #710 (and quite possibly py_lsp: py_eval_expr_type infinite recursion — Python missed in 9f981a1 depth-guard fix #720) and we'd like to land it first in the py-eval series. Thanks again for the rigorous write-up.

---

Update: to keep momentum on the bug backlog, we're going to carry the changes above over the line ourselves shortly — a distilled follow-up on current main implementing the notes in this thread, with you credited as Co-authored-by on the commit, and this PR closed referencing it. If you'd prefer to push the update yourself, just reply within the next couple of days and we'll gladly take yours instead. Thanks again for the contribution!

[DeusData]

Thank you — your diagnosis WAS the fix for #710: we independently verified the double receiver evaluation gives O(2^N) re-evaluation on chained calls, and memoization is the right cure. We carried it over the line as 90f59c5 (PR #809) with you credited as co-author, with one correction from the review: the cache key is node identity (TSNode.id) rather than start byte — leftmost descendants share start bytes, and a probe experiment confirmed the collision silently mis-resolves heterogeneous chains like client.session().execute(). The distill also adds a scope-generation flush (lambda re-walks under different bindings would otherwise serve stale types), the depth/steps guards from #758, and never-caches truncated results. #710 closes — it would be great if you could retest on main. Closing this in favor of the distill — thanks again for the rigorous write-up!

[LA-10]

Confirmed resolved on main (90f59c5). Built from source and re-ran the build_graph StateGraph chain repro through index_repository. On the pre-fix release binary the definitions pass pins a core and runs to timeout (killed at 6.4 CPU-s); on the fixed build the same input completes cleanly
pass=definitions returns in ~0.1s CPU and node/edge counts as expected. Verified on Intel macOS. Thanks for carrying it over!