[soasme]

Summary

Python-to-Python calls no longer recurse in C. A function body that holds a call and cannot suspend compiles to machine steps (Node.flat). When such a body calls another such function, the call pushes a Call on the context's call stack and the same run_machine loop goes on. A return pops the call and dispatches the caller's next step. Deep recursion is now bounded by the recursion limit alone: tests/api runs a 50,000-deep recursion in a 64 KiB C stack.

Calls that C makes still enter a new run_machine and keep the C stack guard. These come from the walker, special methods, host callbacks and trace functions.

• Call steps: a call is BC_CALLF when its arguments are operators of literals and names, computed in place, or BC_CALLN when its arguments are on the stack. Keyword calls stay on BC_CALL. All three run out of line, so generators, which share the loop, keep their registers.
• Statements on the machine: if and return are machine steps inside such bodies. A for whose only call is its iterable stays a walker statement. The statements after a body's last call form one walker step (BC_BLOCK).
• Frame switch: each call keeps its caller's machine, so a switch waits on one load.
• Generators: a generator's call steps never enter a flat call.
• Fixes found on the way:
  • a with body whose __exit__ raised lost its error context;
  • entering and ending a finally reset the frame's line to the try's line;
  • annotation and type-alias value functions stay on the walker.
• Model: the new tests/tla/SpyCalls models the call stack:
  • C nesting counts host calls only;
  • frames stay within the recursion limit;
  • each environment is released once, even when a trace function reuses a popped slot;
  • storage is trimmed after the outermost call.

Performance

M2, cycles averaged over 8 code layouts, main → this branch:

Program	Instructions	Cycles
fib	-12.9%	-2.2%
classes	+1.2%	+2.0%
generators	+1.7%	-0.1%
nbody	-0.1%	+0.3%
loop, sort, strings, dicts, bigint, startup	within 0.5%	within 1% (wall)

classes is still 2% slower on the M2. On Linux clang, callgrind counts about 1% fewer instructions on classes than main, so the gap comes from Apple clang's code generation. It is still open.

Test plan

• make test: green, spec 419/419
• make test-tla in a Linux container: every model passes, SpyCalls included
• make coverage: every engine line runs (spy.c 25916/25916)
• tools/run_workflow.py: test job with clang and gcc (sanitize included)
• tools/run_workflow.py: packages and archive

🤖 Generated with Claude Code

https://claude.ai/code/session_01Bq79MgongGBn3NvB5dYBoj