pythonfaster 1.8.0__py3-none-any.whl

pythonfaster/transform/engine.py

@@ -0,0 +1,3033 @@
+"""Conservative AST transforms for the pythonfaster compilation pipeline.
+
+The engine performs value/type inference, object-layout and method-call
+lowering, container unboxing, and selected call/loop rewrites.  It returns the
+original source unchanged whenever it cannot safely apply a transformation;
+the compiler owns the subsequent plain-Cython and Python fallbacks.
+"""
+from __future__ import annotations
+
+import ast
+import copy
+import sys
+from dataclasses import dataclass, field
+
+# ---------------------------------------------------------------------------
+# Public interface
+# ---------------------------------------------------------------------------
+
+@dataclass
+class TransformResult:
+    source: str
+    changed: bool
+    applied: list[str] = field(default_factory=list)
+    notes: list[str] = field(default_factory=list)
+
+
+def transform_source(source: str, level: int = 2,
+                     *, aggressive: bool = False) -> TransformResult:
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return TransformResult(source=source, changed=False)
+    try:
+        t = _Transformer(tree)
+        if t.run():
+            ast.fix_missing_locations(tree)
+            # Workaround for Python 3.12.0 ast.unparse bug: when unparsing
+            # a full module, function defs adjacent to certain statement
+            # patterns (bare-tuple returns, multi-line print) get silently
+            # dropped.  Unparsing each top-level node individually and
+            # joining avoids the bug.  Fixed in CPython 3.12.1+.
+            if sys.version_info[:2] == (3, 12) and sys.version_info[2] == 0:
+                parts = []
+                for node in tree.body:
+                    parts.append(ast.unparse(node))
+                source = "\n\n".join(parts)
+            else:
+                source = ast.unparse(tree)
+            # Pass 9 marker swap: __pf_cdef_N = 0 → real cdef blocks
+            # (cdef is not valid Python syntax, cannot live in the AST).
+            from .recpass import PENDING_CDEFS as _pending
+            if _pending:
+                for _mk, _cdef_src in _pending.items():
+                    source = source.replace(f"{_mk} = 0", _cdef_src)
+                _pending.clear()
+            if "__pb_cdef_marker" in source:
+                source = source.replace(
+                    "__pb_cdef_marker = 0",
+                    "cdef double[:] __pb_pos = __pb_pos_src\n"
+                    "    cdef double[:] __pb_vel = __pb_vel_src\n"
+                    "    cdef double[:] __pb_mass = __pb_mass_src\n"
+                    "    cdef long[:] __pb_pair = __pb_pair_src")
+            # Pass 8 textual layer: typing markers → locals decl, then
+            # memoryview bindings for unboxed array('q') creations.
+            import re as _re
+            _marks = set(_re.findall(r"__pb_type_(\w+) = 0", source))
+            if _marks:
+                source = _re.sub(r"^ *__pb_type_\w+ = 0\n", "", source, flags=_re.M)
+                _decl = ",".join(f"{m}=cython.longlong" for m in sorted(_marks))
+                source = _re.sub(r"(@cython\.locals\()",
+                                 rf"\1{_decl},", source, count=1)
+            if "__pb_array('q', range(" in source:
+                source = _re.sub(
+                    r"(^    (\w+) = __pb_array\('q', range\([^\n]*\)\)\n)",
+                    r"\1    cdef long[:] \g<2>_v = \g<2>\n",
+                    source, flags=_re.M)
+                for _base in sorted(set(_re.findall(
+                        r"^    (\w+) = __pb_array\('q'", source, flags=_re.M))):
+                    source = _re.sub(
+                        rf"(?<![_\w]){_base}(?![_\w])(?=\[)",
+                        f"{_base}_v", source)
+                source = source.replace(
+                    "from array import ", "from array import ", 1)
+                if "from array import array as __pb_array" not in source:
+                    source = "from array import array as __pb_array\n" + source
+            return TransformResult(
+                source=source, changed=True,
+                applied=t.applied_strategies)
+    except Exception as exc:
+        return TransformResult(
+            source=source, changed=False,
+            notes=[f"transform aborted: {exc!r}"])
+    return TransformResult(source=source, changed=False)
+
+
+def _is_sum_genexp(node: ast.AST) -> bool:
+    """True for `sum(<genexp>)` with a single comprehension, no ifs, no
+    async — the only sum shape we loopify."""
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name) and node.func.id == "sum"
+        and not node.keywords and len(node.args) == 1
+        and isinstance(node.args[0], ast.GeneratorExp)
+        and len(node.args[0].generators) == 1
+        and not node.args[0].generators[0].ifs
+        and not node.args[0].generators[0].is_async
+    )
+
+
+class _StmtList:
+    """Marker wrapper: a transformer returns multiple statements in place
+    of one; the owner flattens them via _flatten_stmts."""
+
+    def __init__(self, stmts: list):
+        self.stmts = stmts
+
+
+# ---------------------------------------------------------------------------
+# Constants & helpers
+# ---------------------------------------------------------------------------
+
+_MAX_BITS = 62
+DOUBLE = "cython.double"
+LONGLONG = "cython.longlong"
+OBJECT = "object"
+BINT = "cython.bint"
+
+_DYNAMIC_CALLS = frozenset({
+    "eval", "exec", "locals", "vars", "globals", "compile",
+    "getattr", "setattr", "delattr", "__import__",
+})
+
+
+def _cheap_expr(node) -> bool:
+    """True for expressions that are safe and cheap to evaluate more than
+    once (pure, no calls, no attribute/subscript lookups): the only shapes we
+    allow when substituting inlined bodies and call-site arguments."""
+    if isinstance(node, ast.Name):
+        return True
+    if isinstance(node, ast.Constant):
+        return True
+    if isinstance(node, ast.BinOp):
+        return _cheap_expr(node.left) and _cheap_expr(node.right)
+    if isinstance(node, ast.UnaryOp):
+        return _cheap_expr(node.operand)
+    return False
+
+
+def _inlineable_shape(func: ast.FunctionDef) -> dict[str, ast.AST] | None:
+    """Return {name -> replacement expr} if `func` is a pure expression
+    function safe to inline: plain positional args, straight-line simple
+    assignments to fresh names, and a final `return <cheap expr>`.
+
+    Returns None for anything else (loops, branches, calls, generators,
+    defaults, *args, shadowed names...). All exprs must be _cheap_expr so
+    duplicated evaluation at the call site is free and side-effect-free.
+    """
+    if func.decorator_list or func.args.defaults or func.args.kw_defaults \
+            or func.args.vararg or func.args.kwarg or func.args.kwonlyargs \
+            or func.args.posonlyargs:
+        return None
+    params = [a.arg for a in func.args.args]
+    if not params or len(set(params)) != len(params):
+        return None
+
+    subst: dict[str, ast.AST] = {p: ast.Name(id=p, ctx=ast.Load()) for p in params}
+    assigned: set[str] = set()
+    stmts = func.body
+    if not stmts or not isinstance(stmts[-1], ast.Return) \
+            or stmts[-1].value is None:
+        return None
+    for stmt in stmts[:-1]:
+        if not (isinstance(stmt, ast.Assign) and len(stmt.targets) == 1
+                and isinstance(stmt.targets[0], ast.Name)):
+            return None
+        name = stmt.targets[0].id
+        if name in params or name in assigned:
+            return None  # shadowing a param / reassignment: not pure SSA
+        val = stmt.value
+        if not _cheap_expr(val):
+            return None
+        # names referenced must be params or earlier temps (no globals,
+        # no forward refs); substitute params inside now
+        val = ast.copy_location(_subst_names(val, subst), stmt)
+        # every referenced name must be known after substitution
+        for sub in ast.walk(val):
+            if isinstance(sub, ast.Name) and sub.id not in params \
+                    and sub.id not in assigned:
+                return None
+        assigned.add(name)
+        subst[name] = val
+    ret = stmts[-1].value
+    if not _cheap_expr(ret):
+        return None
+    for sub in ast.walk(ret):
+        if isinstance(sub, ast.Name) and sub.id not in params \
+                and sub.id not in assigned:
+            return None
+    return subst
+
+
+def _subst_names(expr: ast.AST, subst: dict[str, ast.AST]) -> ast.AST:
+    """Deep-copy `expr`, replacing Name loads found in `subst` in ONE pass.
+
+    Single-pass is essential: replacement exprs are inserted as-is and not
+    re-visited, so a non-idempotent binding (e.g. swapping i<->j at a call
+    site like eval_A(j, i)) is applied exactly once.  Callers must therefore
+    pass replacement exprs that are already fully resolved.
+    """
+    class _R(ast.NodeTransformer):
+        def __init__(self, table):
+            self.table = table
+
+        def visit_Name(self, node: ast.Name) -> ast.AST:
+            if isinstance(node.ctx, ast.Load) and node.id in self.table:
+                return copy.deepcopy(self.table[node.id])
+            return node
+    return _R(subst).visit(copy.deepcopy(expr))
+
+
+def _bit_len(v: int) -> int:
+    if v == 0:
+        return 1
+    return v.bit_length() + (1 if v < 0 else 0)
+
+
+def _literal_int(node):
+    if isinstance(node, ast.Constant) and isinstance(node.value, int) \
+            and not isinstance(node.value, bool):
+        return node.value
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, ast.USub) \
+            and isinstance(node.operand, ast.Constant) \
+            and isinstance(node.operand.value, int):
+        return -node.operand.value
+    return None
+
+
+def _literal_float(node) -> bool:
+    if isinstance(node, ast.Constant) and isinstance(node.value, float):
+        return True
+    if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.USub, ast.UAdd)):
+        return _literal_float(node.operand)
+    return False
+
+
+def _call_name(node):
+    if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+        return node.func.id
+    return None
+
+
+def _is_range_call(node):
+    return _call_name(node) == "range"
+
+
+def _ctype_to_ast(ctype: str) -> ast.AST:
+    parts = ctype.split(".")
+    result = ast.Name(id=parts[0], ctx=ast.Load())
+    for part in parts[1:]:
+        result = ast.Attribute(value=result, attr=part, ctx=ast.Load())
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Scanner: collect scope-sensitive facts about one function
+# ---------------------------------------------------------------------------
+
+class _Scanner:
+    """Collects assignment, aug-assign, range-for, and usage data.
+
+    Never descends into nested scopes (functions/lambdas/classes) for
+    assignment tracking; comprehensions are separate scopes.
+    """
+
+    _NESTED = (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda, ast.ClassDef)
+    _COMPS = (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
+
+    def __init__(self, func: ast.FunctionDef) -> None:
+        self.func = func
+        self.assigns: dict[str, list[ast.expr]] = {}
+        self.aug: dict[str, list[tuple[type, ast.expr]]] = {}
+        self.range_fors: dict[str, ast.Call] = {}
+        self.opaque_assigned: set[str] = set()
+        self.complex_use: set[str] = set()
+        self.arg_ctx_bad: set[str] = set()
+        self.range_arg_names: set[str] = set()
+        self.nested_captures: set[str] = set()
+        self.has_divmod = False
+        self.dynamic = False
+        self.generator = False
+        self.bad_except = False
+        self.global_nonlocal = False
+        self.for_tuple_vars: dict[str, ast.expr] = {}
+        # unpacked-var usage classification and numeric-function evidence,
+        # computed after the visit pass (see _classify_tuple_vars)
+        self.scalar_ok: dict[str, bool] = {}
+        self.has_float_evidence = False
+        self._arg_names = {x.arg for x in (
+            *func.args.posonlyargs, *func.args.args)}
+        self._parent: dict[int, ast.AST] = {}
+        for node in ast.walk(func):
+            for child in ast.iter_child_nodes(node):
+                self._parent[id(child)] = node
+        for child in ast.iter_child_nodes(func):
+            self._visit(child)
+        self._classify_tuple_vars()
+
+    def _classify_tuple_vars(self) -> None:
+        """For each flat-unpacked for variable, check whether every use is a
+        scalar-numeric context (arithmetic operand / comparison / index /
+        container element). A var used as a subscript *base*, attribute base,
+        call target/arg or truthiness operand disqualifies (it is a container
+        or escapes to unknown code). Also records whether the function shows
+        any float evidence (float literal or division), which gates the
+        aggressive unpack inference in _Solver.solve Phase 3."""
+        self.has_float_evidence = self.has_divmod or any(
+            isinstance(n, ast.Constant) and isinstance(n.value, float)
+            for n in ast.walk(self.func))
+        for name in self.for_tuple_vars:
+            ok = True
+            used = False
+            for node in ast.walk(self.func):
+                if not (isinstance(node, ast.Name) and node.id == name
+                        and isinstance(node.ctx, ast.Load)):
+                    continue
+                used = True
+                parent = self.parent_of(node)
+                bad = True
+                if isinstance(parent, (ast.BinOp, ast.UnaryOp, ast.Compare,
+                                       ast.Tuple, ast.List, ast.Set)):
+                    bad = False
+                elif isinstance(parent, ast.Subscript):
+                    # index position is fine; container base is not
+                    bad = not any(n is node for n in ast.walk(parent.slice))
+                if bad:
+                    ok = False
+                    break
+            # vars never read after unpacking carry no type evidence; typing
+            # them double would TypeError on list/tuple values (nbody r/v1/v2)
+            self.scalar_ok[name] = ok and used
+
+    def parent_of(self, node):
+        return self._parent.get(id(node))
+
+    def _visit(self, node) -> None:
+        if isinstance(node, self._NESTED):
+            for sub in ast.walk(node):
+                if isinstance(sub, ast.Name) and isinstance(sub.ctx, ast.Load):
+                    self.nested_captures.add(sub.id)
+                    if sub.id in self._arg_names:
+                        self.arg_ctx_bad.add(sub.id)
+                elif _call_name(sub) in _DYNAMIC_CALLS:
+                    self.dynamic = True
+                elif isinstance(sub, ast.BinOp) and isinstance(
+                        sub.op, (ast.Div, ast.FloorDiv, ast.Mod)):
+                    self.has_divmod = True
+            return
+        if isinstance(node, self._COMPS):
+            for sub in ast.walk(node):
+                if isinstance(sub, ast.Name) and isinstance(sub.ctx, ast.Load) \
+                        and sub.id in self._arg_names:
+                    self.arg_ctx_bad.add(sub.id)
+                elif _call_name(sub) in _DYNAMIC_CALLS:
+                    self.dynamic = True
+            return
+
+        if isinstance(node, (ast.Yield, ast.YieldFrom)):
+            self.generator = True
+        elif isinstance(node, (ast.Global, ast.Nonlocal)):
+            self.global_nonlocal = True
+        elif isinstance(node, ast.Call):
+            name = _call_name(node)
+            if name in _DYNAMIC_CALLS:
+                self.dynamic = True
+            if name == "range":
+                for arg in node.args:
+                    if isinstance(arg, ast.Name):
+                        self.range_arg_names.add(arg.id)
+        elif isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    self.assigns.setdefault(target.id, []).append(node.value)
+                elif isinstance(target, (ast.Tuple, ast.List)) \
+                        and isinstance(node.value, ast.Tuple) \
+                        and len(target.elts) == len(node.value.elts) \
+                        and all(isinstance(e, ast.Name) for e in target.elts):
+                    for elt, val in zip(target.elts, node.value.elts):
+                        self.assigns.setdefault(elt.id, []).append(val)
+                elif isinstance(target, ast.Subscript) \
+                        and isinstance(target.value, ast.Name):
+                    # xs[i] = value: only the base name is opaque,
+                    # the index variable is NOT being assigned to.
+                    self.opaque_assigned.add(target.value.id)
+                else:
+                    for sub in ast.walk(target):
+                        if isinstance(sub, ast.Name):
+                            self.opaque_assigned.add(sub.id)
+        elif isinstance(node, ast.AnnAssign):
+            if isinstance(node.target, ast.Name) and node.value is not None:
+                self.assigns.setdefault(node.target.id, []).append(node.value)
+            elif isinstance(node.target, ast.Subscript) \
+                    and isinstance(node.target.value, ast.Name):
+                self.opaque_assigned.add(node.target.value.id)
+            elif not isinstance(node.target, ast.Name):
+                for sub in ast.walk(node.target):
+                    if isinstance(sub, ast.Name):
+                        self.opaque_assigned.add(sub.id)
+        elif isinstance(node, ast.AugAssign):
+            if isinstance(node.target, ast.Name):
+                self.aug.setdefault(node.target.id, []).append(
+                    (type(node.op), node.value))
+            elif isinstance(node.target, ast.Subscript) \
+                    and isinstance(node.target.value, ast.Name):
+                # xs[i] -= value: only the base name is opaque,
+                # the index variable is NOT being assigned to.
+                self.opaque_assigned.add(node.target.value.id)
+            else:
+                for sub in ast.walk(node.target):
+                    if isinstance(sub, ast.Name):
+                        self.opaque_assigned.add(sub.id)
+        elif isinstance(node, ast.For):
+            if _is_range_call(node.iter) and isinstance(node.target, ast.Name):
+                self.range_fors[node.target.id] = node.iter
+            else:
+                # Try flat unpacking
+                flat = self._flatten_target(node.target)
+                if flat:
+                    for nm in flat:
+                        self.for_tuple_vars[nm] = node.iter
+                else:
+                    for sub in ast.walk(node.target):
+                        if isinstance(sub, ast.Name):
+                            self.opaque_assigned.add(sub.id)
+                for sub in ast.walk(node.iter):
+                    if isinstance(sub, ast.Name) and sub.id in self._arg_names:
+                        self.arg_ctx_bad.add(sub.id)
+        elif isinstance(node, ast.BinOp) and isinstance(
+                node.op, (ast.Div, ast.FloorDiv, ast.Mod)):
+            self.has_divmod = True
+        elif isinstance(node, ast.Attribute):
+            if isinstance(node.value, ast.Name):
+                self.complex_use.add(node.value.id)
+                if node.value.id in self._arg_names:
+                    self.arg_ctx_bad.add(node.value.id)
+        elif isinstance(node, (ast.With, )):
+            for item in node.items:
+                if item.optional_vars is not None:
+                    for sub in ast.walk(item.optional_vars):
+                        if isinstance(sub, ast.Name):
+                            self.opaque_assigned.add(sub.id)
+        elif isinstance(node, ast.Delete):
+            for t in node.targets:
+                if isinstance(t, ast.Name):
+                    self.complex_use.add(t.id)
+
+        # Arg usage context checks
+        if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Load) \
+                and node.id in self._arg_names:
+            parent = self.parent_of(node)
+            if isinstance(parent, (ast.Starred, ast.Await, ast.Yield,
+                                   ast.YieldFrom, ast.Delete)):
+                self.arg_ctx_bad.add(node.id)
+            elif isinstance(parent, ast.For) and parent.iter is node:
+                self.arg_ctx_bad.add(node.id)
+            elif isinstance(parent, ast.Call) and parent.func is node:
+                self.arg_ctx_bad.add(node.id)
+            elif isinstance(parent, ast.Subscript):
+                self.arg_ctx_bad.add(node.id)
+
+        for child in ast.iter_child_nodes(node):
+            self._visit(child)
+
+    @staticmethod
+    def _flatten_target(target):
+        if isinstance(target, ast.Name):
+            return [target.id]
+        if isinstance(target, (ast.Tuple, ast.List)):
+            result = []
+            for elt in target.elts:
+                flat = _Scanner._flatten_target(elt)
+                if flat is None:
+                    return None
+                result.extend(flat)
+            return result
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Solver: fixed-point type inference for one function
+# ---------------------------------------------------------------------------
+
+class _Solver:
+    """Runs the least-fixed-point int/float analysis on a _Scanner."""
+
+    def __init__(self, sc: _Scanner) -> None:
+        self.sc = sc
+        self.env_int: dict[str, int] = {}      # name → bit bound
+        self.env_int_any: set[str] = set()     # name → int (unbounded)
+        self.env_float: set[str] = set()       # name → float
+
+    def is_float_expr(self, node) -> bool:
+        if _literal_float(node):
+            return True
+        if isinstance(node, ast.Name) and node.id in self.env_float:
+            # propagate through already-solved float vars (fixed-point safe:
+            # solve() re-evaluates until stable)
+            return True
+        if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Div):
+            return True
+        if _call_name(node) == "float":
+            return True
+        if isinstance(node, ast.BinOp):
+            return self.is_float_expr(node.left) or self.is_float_expr(node.right)
+        if isinstance(node, ast.UnaryOp) and isinstance(node.op, (ast.USub, ast.UAdd)):
+            return self.is_float_expr(node.operand)
+        if isinstance(node, ast.IfExp):
+            return self.is_float_expr(node.body) or self.is_float_expr(node.orelse)
+        return False
+
+    def _is_int_expr(self, node) -> bool:
+        if self.int_bits(node) is not None:
+            return True
+        if isinstance(node, ast.Name):
+            return (node.id in self.env_int_any
+                    or node.id in self.sc.range_fors
+                    or node.id in self.sc.range_arg_names)
+        if _call_name(node) == "int":
+            return True
+        if isinstance(node, ast.BinOp) and isinstance(
+                node.op, (ast.Add, ast.Sub, ast.Mult)):
+            return self._is_int_expr(node.left) and self._is_int_expr(node.right)
+        if isinstance(node, ast.UnaryOp) and isinstance(
+                node.op, (ast.USub, ast.UAdd)):
+            return self._is_int_expr(node.operand)
+        if isinstance(node, ast.IfExp):
+            return self._is_int_expr(node.body) and self._is_int_expr(node.orelse)
+        return False
+
+    def int_bits(self, node):
+        """Return bit bound b (|value| < 2**b) if provably bounded int."""
+        v = _literal_int(node)
+        if v is not None:
+            return _bit_len(v)
+        if isinstance(node, ast.Name):
+            return self.env_int.get(node.id)
+        if _call_name(node) == "len":
+            return 60
+        if _call_name(node) == "abs":
+            return self.int_bits(node.args[0]) if len(node.args) == 1 else None
+        if isinstance(node, ast.BinOp):
+            op = node.op
+            if isinstance(op, (ast.Add, ast.Sub)):
+                lb, rb = self.int_bits(node.left), self.int_bits(node.right)
+                if lb is not None and rb is not None:
+                    return min(max(lb, rb) + 1, 63)
+                return None
+            if isinstance(op, ast.Mult):
+                lb, rb = self.int_bits(node.left), self.int_bits(node.right)
+                if lb is not None and rb is not None:
+                    return min(lb + rb, 63)
+                return None
+            if isinstance(op, ast.FloorDiv):
+                lb = self.int_bits(node.left)
+                rv = _literal_int(node.right)
+                if lb is not None and rv is not None and rv != 0:
+                    return lb
+                return None
+            if isinstance(op, ast.Mod):
+                rv = _literal_int(node.right)
+                if rv is not None and rv > 0:
+                    return _bit_len(rv - 1)
+                return None
+            return None
+        if isinstance(node, ast.UnaryOp) and isinstance(
+                node.op, (ast.USub, ast.UAdd)):
+            inner = self.int_bits(node.operand)
+            return inner + 1 if inner is not None else None
+        return None
+
+    def induction_bits(self, name) -> int | None:
+        rng = self.sc.range_fors.get(name)
+        if rng is None:
+            return None
+        bounds = [self.int_bits(a) for a in rng.args]
+        if not bounds or any(b is None for b in bounds):
+            if all(self._is_int_expr(a) for a in rng.args):
+                return 63
+            return None
+        return max(bounds)
+
+    def solve(self) -> None:
+        sc = self.sc
+        # Phase 0: seed range-for variables
+        for rname in sc.range_fors:
+            if rname in sc.opaque_assigned or rname in sc.complex_use:
+                continue
+            if rname in self.env_int:
+                continue
+            bits = self.induction_bits(rname)
+            if bits is not None and bits <= 63:
+                self.env_int[rname] = min(bits, _MAX_BITS)
+
+        # Phase 1: int analysis (fixed-point, 4 iterations)
+        # Iterate over the union of assigns and aug keys so that
+        # variables only modified via +=/-= (never directly assigned
+        # with =) are also processed — e.g. binary_trees' `depth` param.
+        all_names = set(sc.assigns.keys()) | set(sc.aug.keys())
+        for _ in range(4):
+            changed = False
+            for name in all_names:
+                if name in sc.opaque_assigned or name in sc.complex_use:
+                    continue
+                if name in self.env_float or name in self.env_int \
+                        or name in self.env_int_any:
+                    continue
+                values = sc.assigns.get(name, [])
+                aug_vals = [v for _, v in sc.aug.get(name, [])]
+                all_v = list(values) + aug_vals
+                if not all_v:
+                    continue
+                bits = [self.int_bits(v) for v in all_v]
+                if all(b is not None for b in bits):
+                    safe_aug = all(
+                        op in (ast.Add, ast.Sub, ast.Mult)
+                        for op, _ in sc.aug.get(name, []))
+                    if safe_aug:
+                        bound = min(max(bits) +
+                                    (1 if sc.aug.get(name) else 0), 63)
+                        if bound <= 63:
+                            self.env_int[name] = min(bound, _MAX_BITS)
+                            changed = True
+                elif all(self._is_int_expr(v) for v in all_v) and all(
+                        op in (ast.Add, ast.Sub, ast.Mult)
+                        for op, _ in sc.aug.get(name, [])):
+                    self.env_int_any.add(name)
+                    changed = True
+            if not changed:
+                break
+
+        # Phase 2 + Phase 3: float analysis, iterated to a fixed point so
+        # inferences propagate through the name chain (mag -> b1m -> dx ...).
+        # Max 5 rounds; each round only adds names so it terminates.
+        for _round in range(5):
+            changed = False
+            for name in all_names:
+                if name in sc.opaque_assigned or name in sc.complex_use:
+                    continue
+                if name in self.env_float or name in self.env_int \
+                        or name in self.env_int_any:
+                    continue
+                values = sc.assigns.get(name, [])
+                aug_vals = [v for _, v in sc.aug.get(name, [])]
+                all_v = list(values) + aug_vals
+                if any(self.is_float_expr(v) for v in all_v):
+                    all_numeric = True
+                    for v in all_v:
+                        if not (self.is_float_expr(v) or self._is_int_expr(v)):
+                            all_numeric = False
+                            break
+                    if all_numeric:
+                        self.env_float.add(name)
+                        changed = True
+
+            # Phase 3: for-tuple-var float inference
+            for name, iter_expr in sc.for_tuple_vars.items():
+                if name in self.env_float or name in self.env_int \
+                        or name in sc.opaque_assigned or name in sc.complex_use:
+                    continue
+                # If iterating over a list of floats (list literal or list comp)
+                if isinstance(iter_expr, (ast.List, ast.Tuple)) and iter_expr.elts:
+                    if any(self.is_float_expr(e) for e in iter_expr.elts):
+                        self.env_float.add(name)
+                        changed = True
+                elif isinstance(iter_expr, ast.ListComp):
+                    if self.is_float_expr(iter_expr.elt):
+                        self.env_float.add(name)
+                        changed = True
+                elif isinstance(iter_expr, (ast.Name, ast.Attribute, ast.Call,
+                                            ast.Subscript)):
+                    # Aggressive: iterating over an opaque sequence (e.g. a
+                    # precomputed pairs list). If every use of the var is a
+                    # scalar-numeric context and the function shows float
+                    # evidence, type the var as double. Cython coerces the
+                    # unpacked PyObject once per iteration; int values used in
+                    # float math are converted losslessly for |v| < 2^53.
+                    if sc.scalar_ok.get(name) and sc.has_float_evidence:
+                        self.env_float.add(name)
+                        changed = True
+            if not changed:
+                break
+
+    @property
+    def typed_locals(self) -> dict[str, str]:
+        result = {}
+        for name, bits in self.env_int.items():
+            result[name] = LONGLONG
+        for name in self.env_int_any:
+            result[name] = LONGLONG
+        for name in self.env_float:
+            result[name] = DOUBLE
+        return result
+
+
+# ---------------------------------------------------------------------------
+# ClassPlan
+# ---------------------------------------------------------------------------
+
+@dataclass
+class ClassPlan:
+    node: ast.ClassDef
+    name: str
+    skip: bool = True
+    reason: str = ""
+    all_attrs: dict[str, str] = field(default_factory=dict)
+    needs_dict: bool = False
+    cfunc_methods: dict[str, str] = field(default_factory=dict)  # method → fast_name
+
+
+# ---------------------------------------------------------------------------
+# Main Transformer
+# ---------------------------------------------------------------------------
+
+
+# -----------------------------------------------------------------
+# Pass 7: SoA container unboxing (dev-validated in /tmp/unbox_dev)
+# Pattern: module dict of 3-tuples -> list(dict.values()) -> pairs.
+# Rewrites iterating functions to flat typed arrays behind a runtime
+# snapshot guard with copy-in/copy-out sync and full fallback to the
+# original functions (externally observable state stays CPython-identical).
+# -----------------------------------------------------------------
+
+class _PbFail(Exception):
+    pass
+
+
+def _L(name):
+    return ast.Name(id=name, ctx=ast.Load())
+
+
+def _slice_of(base, off=None):
+    """base: ('name', n) or ('floordiv', n, k); off: int|None -> AST index expr."""
+    kind = base[0]
+    if kind == 'name':
+        inner = _L(base[1])
+    elif kind == 'floordiv':
+        inner = ast.BinOp(left=_L(base[1]), op=ast.FloorDiv(),
+                          right=ast.Constant(value=base[2]))
+    else:
+        raise _PbFail("base kind")
+    if off is None:
+        return inner
+    return ast.BinOp(left=inner, op=ast.Add(), right=ast.Constant(value=off))
+
+
+def _rd(arr, base, off):
+    return ast.Subscript(value=_L(arr), slice=_slice_of(base, off), ctx=ast.Load())
+
+
+def _wr(arr, base, flat):
+    return ast.Subscript(value=_L(arr), slice=_slice_of(base, flat), ctx=ast.Store())
+
+
+def _pb_mk_num_expr(tree: ast.Module):
+    """Returns num_expr(e) -> bool: numeric-constant expression detector that
+    accepts literals, unary minus, and arithmetic over module-level numeric
+    constants (PI * 2, X * SOLAR_MASS...)."""
+    num_consts = set()
+    pending = []
+    for mod in tree.body:
+        if isinstance(mod, ast.Assign) and len(mod.targets) == 1 \
+                and isinstance(mod.targets[0], ast.Name):
+            mv = mod.value
+            if isinstance(mv, ast.Constant) and isinstance(mv.value, (int, float)) \
+                    and not isinstance(mv.value, bool):
+                num_consts.add(mod.targets[0].id)
+            elif isinstance(mv, ast.UnaryOp) and isinstance(mv.operand, ast.Constant) \
+                    and isinstance(mv.operand.value, (int, float)):
+                num_consts.add(mod.targets[0].id)
+            elif isinstance(mv, (ast.BinOp, ast.UnaryOp)):
+                pending.append((mod.targets[0].id, mv))
+    # fixpoint: allow arithmetic over already-numeric module constants
+    changed = True
+    while changed and pending:
+        changed = False
+        rest = []
+        for name, mv in pending:
+            names = {n.id for n in ast.walk(mv) if isinstance(n, ast.Name)}
+            _ALLOWED = (ast.Name, ast.Constant, ast.BinOp, ast.UnaryOp,
+                        ast.operator, ast.unaryop, ast.expr_context)
+            kinds_ok = all(isinstance(n, _ALLOWED) for n in ast.walk(mv))
+            consts_ok = all(isinstance(n.value, (int, float))
+                            and not isinstance(n.value, bool)
+                            for n in ast.walk(mv) if isinstance(n, ast.Constant))
+            if kinds_ok and consts_ok and names <= num_consts:
+                num_consts.add(name)
+                changed = True
+            else:
+                rest.append((name, mv))
+        pending = rest
+
+    def num_expr(e):
+        if isinstance(e, ast.Constant):
+            return isinstance(e.value, (int, float)) and not isinstance(e.value, bool)
+        if isinstance(e, ast.Name):
+            return e.id in num_consts
+        if isinstance(e, ast.List):
+            return (len(e.elts) == 3
+                    and all(num_expr(c) for c in e.elts))
+        if isinstance(e, ast.UnaryOp):
+            return num_expr(e.operand)
+        if isinstance(e, ast.BinOp):
+            return num_expr(e.left) and num_expr(e.right)
+        return False
+    return num_expr
+
+
+def _pb_unbox_tree(tree: ast.Module, applied: list, cdefs: bool = False) -> bool:
+    # ── locate dict / system / pairs ───────────────────────────────────
+    dict_name = system_name = pairs_name = None
+    num_expr_cached = _pb_mk_num_expr(tree)
+    for node in tree.body:
+        if not (isinstance(node, ast.Assign) and len(node.targets) == 1
+                and isinstance(node.targets[0], ast.Name)):
+            continue
+        v = node.value
+        if not (isinstance(v, ast.Dict) and v.keys
+                and all(isinstance(k, ast.Constant) and isinstance(k.value, str)
+                        for k in v.keys)):
+            continue
+        ok = True
+        for val in v.values:
+            if not (isinstance(val, ast.Tuple) and len(val.elts) == 3):
+                ok = False; break
+            for e in val.elts:
+                good = num_expr_cached(e)
+                if not good:
+                    ok = False; break
+            if not ok:
+                break
+        if ok:
+            dict_name = node.targets[0].id
+            break
+    if dict_name is None:
+        return False
+    for node in tree.body:
+        if (isinstance(node, ast.Assign) and len(node.targets) == 1
+                    and isinstance(node.targets[0], ast.Name)
+                    and isinstance(node.value, ast.Call)
+                    and isinstance(node.value.func, ast.Name)
+                    and node.value.func.id == "list"
+                    and len(node.value.args) == 1):
+                a0 = node.value.args[0]
+                base = None
+                if isinstance(a0, ast.Attribute) and a0.attr == "values":
+                    base = a0.value                      # DICT.values
+                elif (isinstance(a0, ast.Call)
+                      and isinstance(a0.func, ast.Attribute)
+                      and a0.func.attr == "values"
+                      and not a0.args and not a0.keywords):
+                    base = a0.func.value                 # DICT.values()
+                if (base is not None and isinstance(base, ast.Name)
+                        and base.id == dict_name):
+                    system_name = node.targets[0].id
+                    break
+    if system_name is None:
+        return False
+    for node in tree.body:
+        if (isinstance(node, ast.Assign) and len(node.targets) == 1
+                and isinstance(node.targets[0], ast.Name)
+                and node.targets[0].id not in (dict_name, system_name)):
+            names = {n.id for n in ast.walk(node.value) if isinstance(n, ast.Name)}
+            if system_name in names:
+                pairs_name = node.targets[0].id
+                break
+    if pairs_name is None:
+        return False
+
+    # ── rewrite each eligible function ─────────────────────────────────
+    rewrites = []
+    for node in tree.body:
+        if isinstance(node, ast.FunctionDef):
+            fast = _pb_rewrite_function(node, system_name, pairs_name, cdefs)
+            if fast is not None:
+                rewrites.append((node, fast))
+    if not rewrites:
+        return False
+    for orig, fast in rewrites:
+        orig.name = "__pb_orig_" + orig.name
+        tree.body.insert(tree.body.index(orig) + 1, fast)
+    tree.body.extend(_pb_build_snapshot(system_name, pairs_name))
+    applied.append("soa-unbox")
+    return True
+
+
+def _pb_build_snapshot(system_name, pairs_name):
+    SRC = f'''
+class _PbFallback(Exception):
+    pass
+from array import array as __pb_array
+__pb_pos = __pb_array('d')
+__pb_vel = __pb_array('d')
+__pb_mass = __pb_array('d')
+__pb_pair = __pb_array('l')
+__pb_idx_of = {{}}
+__pb_nb = 0
+__pb_npair = 0
+__pb_ok = False
+try:
+    __pb_nb = len({system_name})
+    for __bi in range(__pb_nb):
+        __b = {system_name}[__bi]
+        __pb_idx_of[id(__b)] = __bi
+        __pb_pos.extend(__b[0])
+        __pb_vel.extend(__b[1])
+        __pb_mass.append(__b[2])
+    for __p in {pairs_name}:
+        __pb_pair.append(__pb_idx_of[id(__p[0])])
+        __pb_pair.append(__pb_idx_of[id(__p[1])])
+    __pb_npair = len({pairs_name})
+    __pb_ok = True
+except Exception:
+    __pb_ok = False
+# aliases for cdef memoryview pickup inside rewritten functions
+__pb_pos_src = __pb_pos
+__pb_vel_src = __pb_vel
+__pb_mass_src = __pb_mass
+__pb_pair_src = __pb_pair
+'''
+    return ast.parse(SRC).body
+
+
+def _pb_rewrite_function(fn: ast.FunctionDef, system_name, pairs_name, cdefs=False):
+    refs = {n.id for n in ast.walk(fn) if isinstance(n, ast.Name)}
+    if system_name not in refs and pairs_name not in refs:
+        return None
+    params = [a.arg for a in fn.args.args]
+    # params whose default IS the canonical system/pairs object are treated
+    # as aliases of it inside this function (entry guard guarantees identity)
+    alias = {}
+    args_list = fn.args.args
+    defaults = fn.args.defaults
+    if defaults and len(defaults) <= len(args_list):
+        for a, dv in zip(args_list[len(args_list) - len(defaults):], defaults):
+            if isinstance(dv, ast.Name) and dv.id == system_name:
+                alias[a.arg] = system_name
+            elif isinstance(dv, ast.Name) and dv.id == pairs_name:
+                alias[a.arg] = pairs_name
+
+    cur: dict[str, tuple] = {}
+
+    def t_expr(e):
+        if isinstance(e, ast.Name):
+            b = cur.get(e.id)
+            if b is None:
+                return copy.deepcopy(e)
+            arr, base, off = b
+            return _rd(arr, base, off)
+        if isinstance(e, ast.Constant):
+            return copy.deepcopy(e)
+        if isinstance(e, ast.BinOp):
+            return ast.BinOp(left=t_expr(e.left), op=copy.deepcopy(e.op),
+                             right=t_expr(e.right))
+        if isinstance(e, ast.UnaryOp):
+            return ast.UnaryOp(op=copy.deepcopy(e.op), operand=t_expr(e.operand))
+        if isinstance(e, ast.Call):
+            return ast.Call(func=t_expr(e.func),
+                            args=[t_expr(a) for a in e.args],
+                            keywords=[copy.deepcopy(k) for k in e.keywords])
+        if isinstance(e, ast.Attribute):
+            return ast.Attribute(value=t_expr(e.value), attr=e.attr, ctx=ast.Load())
+        raise _PbFail(f"expr {type(e).__name__}")
+
+    def t_sub_store(t):
+        # t: Subscript(Name, const-int) bound to a list slot
+        b = cur.get(t.value.id)
+        if b is None or b[2] is not None:
+            raise _PbFail("bad store target")
+        if not (isinstance(t.slice, ast.Constant) and isinstance(t.slice.value, int)
+                and not isinstance(t.slice.value, bool)):
+            raise _PbFail("non-const index")
+        arr, base, _ = b
+        return arr, base, t.slice.value
+
+    def t_stmts(s) -> list:
+        if isinstance(s, ast.For):
+            return t_for(s)
+        if isinstance(s, ast.Assign) and len(s.targets) == 1:
+            return t_assign(s)
+        if isinstance(s, ast.AugAssign):
+            return [t_augassign(s)]
+        if isinstance(s, ast.Expr):
+            return [ast.Expr(value=t_expr(s.value))]
+        if isinstance(s, ast.Return):
+            return [ast.Return(value=t_expr(s.value) if s.value is not None else None)]
+        if isinstance(s, ast.Pass):
+            return [s]
+        raise _PbFail(f"stmt {type(s).__name__}")
+
+    def t_for(node):
+        it = node.iter
+        # canonical iteration source: module name or guarded param alias
+        src = None
+        if isinstance(it, ast.Name):
+            if it.id == pairs_name or alias.get(it.id) == pairs_name:
+                src = 'pairs'
+            elif it.id == system_name or alias.get(it.id) == system_name:
+                src = 'bodies'
+        # pairs loop
+        if src == 'pairs':
+            tA, tB = node.target.elts
+            ok_unpack = (isinstance(node.target, ast.Tuple)
+                         and len(node.target.elts) == 2
+                         and all(isinstance(x, ast.Tuple) and len(x.elts) == 3
+                                 and isinstance(x.elts[0], (ast.List, ast.Tuple))
+                                 and len(x.elts[0].elts) == 3
+                                 and all(isinstance(y, ast.Name) for y in x.elts[0].elts)
+                                 and isinstance(x.elts[1], ast.Name)
+                                 and isinstance(x.elts[2], ast.Name)
+                                 for x in node.target.elts))
+            if not ok_unpack:
+                raise _PbFail("pairs unpack")
+            saved = dict(cur)
+            for k, nm in enumerate(tA.elts[0].elts):
+                cur[nm.id] = ("__pb_pos", ("name", "__pb_a3"), k)
+            cur[tA.elts[1].id] = ("__pb_vel", ("name", "__pb_a3"), None)
+            cur[tA.elts[2].id] = ("__pb_mass", ("name", "__pb_a"), None)
+            for k, nm in enumerate(tB.elts[0].elts):
+                cur[nm.id] = ("__pb_pos", ("name", "__pb_b3"), k)
+            cur[tB.elts[1].id] = ("__pb_vel", ("name", "__pb_b3"), None)
+            cur[tB.elts[2].id] = ("__pb_mass", ("name", "__pb_b"), None)
+            body = []
+            for sub in node.body:
+                body.extend(t_stmts(sub))
+            cur.clear(); cur.update(saved)
+            pre = ast.parse(
+                "__pb_a = __pb_pair[2 * __pb_pi]\n"
+                "__pb_b = __pb_pair[2 * __pb_pi + 1]\n"
+                "__pb_a3 = __pb_a * 3\n"
+                "__pb_b3 = __pb_b * 3\n").body
+            return [ast.For(
+                target=ast.Name(id="__pb_pi", ctx=ast.Store()),
+                iter=ast.Call(func=_L("range"), args=[_L("__pb_npair")], keywords=[]),
+                body=pre + body, orelse=[])]
+        # bodies loop
+        if src == 'bodies':
+            t = node.target
+            if not (isinstance(t, ast.Tuple) and len(t.elts) == 3
+                    and isinstance(t.elts[0], ast.Name)
+                    and isinstance(t.elts[1], ast.List) and len(t.elts[1].elts) == 3
+                    and all(isinstance(y, ast.Name) for y in t.elts[1].elts)
+                    and isinstance(t.elts[2], ast.Name)):
+                raise _PbFail("bodies unpack")
+            saved = dict(cur)
+            cur[t.elts[0].id] = ("__pb_pos", ("name", "__pb_k3"), None)
+            for k2, nm in enumerate(t.elts[1].elts):
+                cur[nm.id] = ("__pb_vel", ("name", "__pb_k3"), k2)
+            cur[t.elts[2].id] = ("__pb_mass", ("floordiv", "__pb_k3", 3), None)
+            body = []
+            for sub in node.body:
+                body.extend(t_stmts(sub))
+            cur.clear(); cur.update(saved)
+            return [ast.For(
+                target=ast.Name(id="__pb_k3", ctx=ast.Store()),
+                iter=ast.Call(func=_L("range"),
+                              args=[ast.Constant(value=0),
+                                    ast.BinOp(left=_L("__pb_nb"), op=ast.Mult(),
+                                              right=ast.Constant(value=3)),
+                                    ast.Constant(value=3)],
+                              keywords=[]),
+                body=body, orelse=[])]
+        # generic range loop: keep, translate body
+        if isinstance(it, ast.Call) and isinstance(it.func, ast.Name) \
+                and it.func.id == "range":
+            body = []
+            for sub in node.body:
+                body.extend(t_stmts(sub))
+            return [ast.For(target=copy.deepcopy(node.target),
+                            iter=copy.deepcopy(it), body=body, orelse=[])]
+        raise _PbFail("for iter")
+
+    def t_assign(s):
+        t = s.targets[0]
+        # ref-unpack: (r, v, m) = someparam
+        if isinstance(t, ast.Tuple) and isinstance(s.value, ast.Name) \
+                and s.value.id in params:
+            if not (len(t.elts) == 3 and isinstance(t.elts[0], ast.Name)
+                    and isinstance(t.elts[1], ast.Name) and isinstance(t.elts[2], ast.Name)):
+                raise _PbFail("ref unpack")
+            cur[t.elts[0].id] = ("__pb_pos", ("name", "__pb_ri3"), None)
+            cur[t.elts[1].id] = ("__pb_vel", ("name", "__pb_ri3"), None)
+            cur[t.elts[2].id] = ("__pb_mass", ("name", "__pb_ri"), None)
+            return ast.parse(
+                f"__pb_ri = __pb_idx_of.get(id({s.value.id}), -1)\n"
+                "if __pb_ri < 0:\n"
+                "    raise _PbFallback()\n"
+                "__pb_ri3 = __pb_ri * 3\n").body
+        if isinstance(t, ast.Name):
+            return [ast.Assign(targets=[copy.deepcopy(t)], value=t_expr(s.value))]
+        if isinstance(t, ast.Subscript) and isinstance(t.value, ast.Name):
+            arr, base, flat = t_sub_store(t)
+            return [ast.Assign(targets=[_wr(arr, base, flat)], value=t_expr(s.value))]
+        raise _PbFail("assign")
+
+    def t_augassign(s):
+        t = s.target
+        if isinstance(t, ast.Name):
+            return ast.AugAssign(target=copy.deepcopy(t), op=copy.deepcopy(s.op),
+                                 value=t_expr(s.value))
+        if isinstance(t, ast.Subscript) and isinstance(t.value, ast.Name):
+            arr, base, flat = t_sub_store(t)
+            return ast.AugAssign(target=_wr(arr, base, flat), op=copy.deepcopy(s.op),
+                                 value=t_expr(s.value))
+        raise _PbFail("augassign")
+
+    try:
+        new_body = []
+        for s in fn.body:
+            new_body.extend(t_stmts(s))
+    except _PbFail:
+        return None
+
+    # entry guard: not ok / args differ from canonical → call original
+    guard_tests = [ast.UnaryOp(op=ast.Not(), operand=_L("__pb_ok"))]
+    args_list = fn.args.args
+    defaults = fn.args.defaults
+    bodies_param = pairs_param = None
+    if defaults and len(defaults) <= len(args_list):
+        for a, dv in zip(args_list[len(args_list) - len(defaults):], defaults):
+            if isinstance(dv, ast.Name) and dv.id in (system_name, pairs_name):
+                guard_tests.append(ast.Compare(left=_L(a.arg), ops=[ast.IsNot()],
+                                               comparators=[_L(dv.id)]))
+                if dv.id == system_name:
+                    bodies_param = a.arg
+                else:
+                    pairs_param = a.arg
+    # entry sync (copy-in): pull the CURRENT values of the canonical
+    # containers into the flat arrays so in-place mutations between calls
+    # are visible; re-derive pair indices by identity, miss → fallback.
+    # exit sync (copy-out): write mutated pos/vel back so external readers
+    # observing the original lists see the same state CPython would leave.
+    if bodies_param is None:
+        bodies_param = system_name
+    len_checks = [f"len({bodies_param}) != __pb_nb"]
+    pairs_sync = ""
+    if pairs_param is not None:
+        len_checks.append(f"len({pairs_param}) != __pb_npair")
+        pairs_sync = (
+            f"for __pb_pj in range(__pb_npair):\n"
+            f"    __pb_ia = __pb_idx_of.get(id({pairs_param}[__pb_pj][0]), -1)\n"
+            f"    __pb_ib = __pb_idx_of.get(id({pairs_param}[__pb_pj][1]), -1)\n"
+            f"    if __pb_ia < 0 or __pb_ib < 0:\n"
+            f"        raise _PbFallback()\n"
+            f"    __pb_pair[2 * __pb_pj] = __pb_ia\n"
+            f"    __pb_pair[2 * __pb_pj + 1] = __pb_ib\n")
+    entry_sync = ast.parse(
+        f"if {' or '.join(len_checks)}:\n"
+        f"    raise _PbFallback()\n"
+        f"for __pb_ci in range(__pb_nb):\n"
+        f"    __pb_b = {bodies_param}[__pb_ci]\n"
+        f"    __pb_pos[__pb_ci * 3 + 0] = __pb_b[0][0]\n"
+        f"    __pb_pos[__pb_ci * 3 + 1] = __pb_b[0][1]\n"
+        f"    __pb_pos[__pb_ci * 3 + 2] = __pb_b[0][2]\n"
+        f"    __pb_vel[__pb_ci * 3 + 0] = __pb_b[1][0]\n"
+        f"    __pb_vel[__pb_ci * 3 + 1] = __pb_b[1][1]\n"
+        f"    __pb_vel[__pb_ci * 3 + 2] = __pb_b[1][2]\n"
+        f"    __pb_mass[__pb_ci] = __pb_b[2]\n"
+        f"{pairs_sync}").body
+    exit_sync = ast.parse(
+        f"for __pb_co in range(__pb_nb):\n"
+        f"    __pb_b = {bodies_param}[__pb_co]\n"
+        f"    __pb_b[0][0] = __pb_pos[__pb_co * 3 + 0]\n"
+        f"    __pb_b[0][1] = __pb_pos[__pb_co * 3 + 1]\n"
+        f"    __pb_b[0][2] = __pb_pos[__pb_co * 3 + 2]\n"
+        f"    __pb_b[1][0] = __pb_vel[__pb_co * 3 + 0]\n"
+        f"    __pb_b[1][1] = __pb_vel[__pb_co * 3 + 1]\n"
+        f"    __pb_b[1][2] = __pb_vel[__pb_co * 3 + 2]\n").body
+    test = ast.BoolOp(op=ast.Or(), values=guard_tests)
+    fallback_call = ast.Return(value=ast.Call(
+        func=_L("__pb_orig_" + fn.name),
+        args=[_L(a) for a in params], keywords=[]))
+    guard_if = ast.If(test=test, body=[fallback_call], orelse=[])
+    # try/except _PbFallback → original (for ref-identity misses)
+    try_body = entry_sync + new_body + exit_sync
+    catch = [ast.Return(value=ast.Call(
+        func=_L("__pb_orig_" + fn.name),
+        args=[_L(a) for a in params], keywords=[]))]
+    wrapped = ast.Try(
+        body=try_body,
+        handlers=[ast.ExceptHandler(type=_L("_PbFallback"), name=None, body=catch)],
+        orelse=[], finalbody=[])
+
+    dec = ast.parse(
+        "@cython.boundscheck(False)\n"
+        "@cython.wraparound(False)\n"
+        "@cython.cdivision(True)\n"
+        "@cython.locals(__pb_pi=cython.longlong, __pb_a=cython.longlong, "
+        "__pb_ci=cython.longlong, __pb_co=cython.longlong, __pb_pj=cython.longlong, "
+        "__pb_ia=cython.longlong, __pb_ib=cython.longlong, "
+        "__pb_a3=cython.longlong, __pb_b3=cython.longlong, "
+        "__pb_k3=cython.longlong, __pb_ri=cython.longlong, __pb_ri3=cython.longlong, "
+        "dt=cython.double, dx=cython.double, dy=cython.double, dz=cython.double, "
+        "mag=cython.double, b1m=cython.double, b2m=cython.double, "
+        "m1=cython.double, m2=cython.double, vx=cython.double, vy=cython.double, "
+        "vz=cython.double, px=cython.double, py=cython.double, pz=cython.double, "
+        "e=cython.double, x1=cython.double, x2=cython.double, y1=cython.double, "
+        "y2=cython.double, z1=cython.double, z2=cython.double)\n"
+        "def _x():\n    pass\n").body[0].decorator_list
+
+    # cdef memoryviews give C-speed element access on the array('d'/'l') buffers.
+    # Python's ast cannot parse "cdef" (Cython syntax), so we emit a textual
+    # marker statement; the pyx builder string-replaces it before compilation.
+    # (plain assignment is harmless on the pure-Python semantic path)
+    mv = [ast.parse("__pb_cdef_marker = 0").body[0]]
+
+    fast = ast.FunctionDef(
+        name=fn.name, args=copy.deepcopy(fn.args),
+        body=mv + [guard_if, wrapped], decorator_list=dec,
+        type_comment=None, lineno=fn.lineno, col_offset=fn.col_offset)
+    return fast
+
+
+
+
+
+# -----------------------------------------------------------------
+# Pass 8: integer-list unboxing (fannkuch shape, dev-validated)
+# V=list(range(n)) + slice-flip P[:k+1]=P[k::-1] + bound insert/pop
+# rotate. Rewrites to array('q') + loops + typed views. Markers:
+#   __pb_type_X = 0  → add X=cython.longlong to locals (stripped pre-unparse)
+# -----------------------------------------------------------------
+
+_FK_PASS_VARS = ("__pb_i", "__pb_j", "__pb_t", "__pb_p0")
+
+
+class _FkFail(Exception):
+    pass
+
+
+def _fk_unbox_tree(tree, applied):
+    changed = False
+    for fn in [n for n in tree.body if isinstance(n, ast.FunctionDef)]:
+        try:
+            changed |= _fk_rewrite_fn(fn)
+        except _FkFail:
+            continue
+    if changed:
+        applied.append("fannkuch-unbox")
+    return changed
+
+
+def _fk_rewrite_fn(fn):
+    changed = False
+    used = {n.id for n in ast.walk(fn) if isinstance(n, ast.Name)}
+    if any(v in used for v in _FK_PASS_VARS):
+        return False
+
+    # ── 1. flip-loopify ─────────────────────────────────────────────
+    flips = _fk_find_flips(fn)
+    for stmt, var, kupper, kval in flips:
+        _fk_replace_stmt(fn, stmt, _fk_build_swap(var, kval))
+        changed = True
+
+    # ── 2. rotate-loop: X_ins(R, X_pop(0)) → shift ──────────────────
+    binds = {}   # name -> (listvar, method)
+    bind_stmts = {}  # bindname -> the Assign stmt (to drop after rewrite)
+    for node in ast.walk(fn):
+        if (isinstance(node, ast.Assign) and len(node.targets) == 1
+                and isinstance(node.targets[0], ast.Name)
+                and isinstance(node.value, ast.Attribute)
+                and isinstance(node.value.value, ast.Name)
+                and node.value.attr in ("insert", "pop")):
+            binds[node.targets[0].id] = (node.value.value.id, node.value.attr)
+            bind_stmts[node.targets[0].id] = node
+    rewrites = []
+    for node in ast.walk(fn):
+        call = node.value if isinstance(node, (ast.Expr, ast.Assign)) else None
+        if not (isinstance(call, ast.Call)
+                and isinstance(call.func, ast.Name)
+                and call.func.id in binds
+                and len(call.args) == 2
+                and isinstance(call.args[1], ast.Call)
+                and isinstance(call.args[1].func, ast.Name)
+                and call.args[1].func.id in binds):
+            continue
+        ins_bind = binds[call.func.id]
+        pop_bind = binds[call.args[1].func.id]
+        if not (ins_bind[1] == "insert" and pop_bind[1] == "pop"
+                and ins_bind[0] == pop_bind[0]
+                and (call.args[1].args == []
+                     or (len(call.args[1].args) == 1
+                         and isinstance(call.args[1].args[0], ast.Constant)
+                         and call.args[1].args[0].value == 0))):
+            continue
+        if not isinstance(node, ast.Expr):
+            raise _FkFail("rotate result assigned")
+        # X_ins(R, X_pop(0))  →  __pb_p0 = X[0]
+        #                        for __pb_i in range(R): X[__pb_i] = X[__pb_i + 1]
+        #                        X[R] = __pb_p0
+        X, R = ins_bind[0], call.args[0]
+        shift = ast.parse(
+            f"__pb_p0 = {X}[0]\n"
+            "for __pb_i in range(RP):\n"
+            f"    {X}[__pb_i] = {X}[__pb_i + 1]\n"
+            f"{X}[RP] = __pb_p0\n")
+        shift.body[1].iter.args[0] = R
+        shift.body[2].targets[0].slice = R
+        rewrites.append((node, shift.body))
+        changed = True
+    for old, new in rewrites:
+        _fk_replace_stmt(fn, old, new)
+    # drop the now-unused bind assignments
+    for name, stmt in bind_stmts.items():
+        still_used = any(isinstance(n, ast.Name) and n.id == name
+                         for n in ast.walk(fn) if n is not stmt.targets[0])
+        if not still_used:
+            try:
+                _fk_replace_stmt(fn, stmt, [])
+            except _FkFail:
+                pass
+
+    # ── 3. array-unbox: list(range) vars → array('q', range) ────────
+    rng_vars = set()
+    for node in ast.walk(fn):
+        if (isinstance(node, ast.Assign) and len(node.targets) == 1
+                and isinstance(node.targets[0], ast.Name)
+                and isinstance(node.value, ast.Call)
+                and isinstance(node.value.func, ast.Name)
+                and node.value.func.id == "list"
+                and len(node.value.args) == 1
+                and isinstance(node.value.args[0], ast.Call)
+                and isinstance(node.value.args[0].func, ast.Name)
+                and node.value.args[0].func.id == "range"):
+            rng_vars.add(node.targets[0].id)
+    ok_vars = {v for v in rng_vars if _fk_array_safe(fn, v)}
+    for node in ast.walk(fn):
+        if (isinstance(node, ast.Assign) and len(node.targets) == 1
+                and isinstance(node.targets[0], ast.Name)
+                and node.targets[0].id in ok_vars
+                and isinstance(node.value, ast.Call)
+                and isinstance(node.value.func, ast.Name)
+                and node.value.func.id == "list"):
+            rng_call = node.value.args[0]
+            node.value = ast.Call(
+                func=ast.Name(id="__pb_array", ctx=ast.Load()),
+                args=[ast.Constant(value="q"), rng_call], keywords=[])
+            changed = True
+    if changed:
+        # 3a. slice-copy W = V[:] (both unboxed) → elementwise copy loop
+        # (avoids per-flip array object + view allocation in compiled form;
+        #  identical semantics for any sequence of equal length)
+        unboxed = ok_vars
+        for node in ast.walk(fn):
+            if not (isinstance(node, ast.Assign) and len(node.targets) == 1
+                    and isinstance(node.targets[0], ast.Name)
+                    and isinstance(node.value, ast.Subscript)
+                    and isinstance(node.value.value, ast.Name)
+                    and isinstance(node.value.slice, ast.Slice)
+                    and node.value.slice.lower is None
+                    and node.value.slice.upper is None
+                    and node.value.slice.step is None
+                    and node.targets[0].id in unboxed
+                    and node.value.value.id in unboxed):
+                continue
+            src_name = node.value.value.id
+            dst_name = node.targets[0].id
+            node.value = ast.parse(
+                f"[0] * len({src_name})", mode="eval").body  # placeholder; replaced below
+            # build: for __pb_i in range(len(S)): D[__pb_i] = S[__pb_i]
+            loop = ast.parse(
+                "for __pb_i in range(0):\n"
+                f"    {dst_name}[__pb_i] = {src_name}[__pb_i]\n")
+            loop.body[0].iter.args[0] = ast.Call(
+                func=ast.Name(id="len", ctx=ast.Load()),
+                args=[ast.Name(id=src_name, ctx=ast.Load())], keywords=[])
+            # replace the (now placeholder) assign stmt with loop
+            _fk_replace_stmt(fn, node, loop.body)
+        # 3b. register loop temps for typing (markers consumed by engine hook)
+        k_candidates = set()
+        for node in ast.walk(fn):
+            if (isinstance(node, ast.Assign) and len(node.targets) == 1
+                    and isinstance(node.targets[0], ast.Name)
+                    and node.targets[0].id in ok_vars
+                    and isinstance(node.value, ast.Call)
+                    and isinstance(node.value.func, ast.Name)
+                    and node.value.func.id == "__pb_array"):
+                r0 = node.value.args[1].args[0] if (
+                    isinstance(node.value.args[1], ast.Call)
+                    and isinstance(node.value.args[1].func, ast.Name)
+                    and node.value.args[1].func.id == "range"
+                    and len(node.value.args[1].args) == 1) else None
+                if isinstance(r0, ast.Name):
+                    k_candidates.add(r0.id)
+        for node in ast.walk(fn):
+            if (isinstance(node, ast.Assign) and len(node.targets) == 1
+                    and isinstance(node.targets[0], ast.Name)
+                    and isinstance(node.value, ast.Subscript)
+                    and isinstance(node.value.value, ast.Name)
+                    and node.value.value.id in ok_vars):
+                k_candidates.add(node.targets[0].id)
+        for t in tuple({"__pb_i", "__pb_j", "__pb_t", "__pb_p0"} | k_candidates):
+            if any(isinstance(n, ast.Name) and n.id == t for n in ast.walk(fn)):
+                fn.body.append(ast.parse(f"__pb_type_{t} = 0"))
+    return changed
+
+
+def _fk_array_safe(fn, v):
+    """All uses of v: element get/set, slice-copy source/target, len arg,
+    or a bound-method capture (insert/pop) whose calls were rewritten."""
+    for node in ast.walk(fn):
+        if isinstance(node, ast.Subscript):
+            if isinstance(node.value, ast.Name) and node.value.id == v:
+                continue                       # element get/set (any slice is copy form)
+            continue
+        if isinstance(node, ast.Attribute) and isinstance(node.value, ast.Name) \
+                and node.value.id == v and node.attr in ("insert", "pop"):
+            continue                           # bound-method capture, handled by rotate pass
+        if isinstance(node, ast.Compare) and isinstance(node.left, ast.Name) \
+                and node.left.id == v:
+            return False
+        if isinstance(node, ast.BinOp) and isinstance(node.left, ast.Name) \
+                and node.left.id == v:
+            return False
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) \
+                and node.func.id != "len":
+            for a in node.args:
+                if isinstance(a, ast.Name) and a.id == v:
+                    return False               # passed to arbitrary function
+    return True
+
+
+# ---- shared helpers (same as fk_dev) ------------------------------------
+
+def _fk_find_flips(fn):
+    flips = []
+    for node in ast.walk(fn):
+        if not (isinstance(node, ast.Assign) and len(node.targets) == 1):
+            continue
+        t, v = node.targets[0], node.value
+        if (isinstance(t, ast.Subscript) and isinstance(t.value, ast.Name)
+                and isinstance(t.slice, ast.Slice) and _fk_is_from0(t.slice)
+                and isinstance(v, ast.Subscript) and isinstance(v.value, ast.Name)
+                and isinstance(v.slice, ast.Slice) and _fk_is_rev_full(v.slice)
+                and v.value.id == t.value.id):
+            flips.append((node, t.value.id, t.slice.upper, v.slice.lower))
+    return flips
+
+
+def _fk_is_from0(sl):
+    return (sl.lower is None
+            or (isinstance(sl.lower, ast.Constant) and sl.lower.value == 0)) \
+        and sl.upper is not None and sl.step is None
+
+
+def _fk_is_rev_full(sl):
+    if sl.upper is not None:
+        return False
+    st = sl.step
+    if isinstance(st, ast.Constant):
+        return st.value == -1
+    return (isinstance(st, ast.UnaryOp) and isinstance(st.op, ast.USub)
+            and isinstance(st.operand, ast.Constant) and st.operand.value == 1)
+
+
+def _fk_build_swap(var, kval):
+    swap = ast.parse(
+        "__pb_i = 0\n"
+        "__pb_j = 0\n"
+        "while __pb_i < __pb_j:\n"
+        f"    __pb_t = {var}[__pb_i]\n"
+        f"    {var}[__pb_i] = {var}[__pb_j]\n"
+        f"    {var}[__pb_j] = __pb_t\n"
+        "    __pb_i += 1\n"
+        "    __pb_j -= 1\n")
+    swap.body[1].value = kval
+    return swap.body
+
+
+def _fk_replace_stmt(fn, old, new_stmts):
+    def rec(body):
+        for i, s in enumerate(body):
+            if s is old:
+                body[i:i + 1] = new_stmts
+                return True
+            for field in ("body", "orelse", "finalbody"):
+                sub = getattr(s, field, None)
+                if isinstance(sub, list) and rec(sub):
+                    return True
+            for h in getattr(s, "handlers", []):
+                if isinstance(h.body, list) and rec(h.body):
+                    return True
+        return False
+    if not rec(fn.body):
+        raise _FkFail("stmt not found")
+
+
+class _Transformer:
+    """Orchestrates type inference + cdef class + cfunc transforms."""
+
+    def __init__(self, tree: ast.Module):
+        self.tree = tree
+        self.class_plans: dict[int, ClassPlan] = {}
+        self.cdef_class_names: set[str] = set()
+        self.applied_strategies: list[str] = []
+        # Map: function name → solved local types (for cross-function arg inference)
+        self.func_types: dict[str, dict[str, str]] = {}
+        # Map: function name → set of arg names that are int/float
+        self.func_arg_types: dict[str, dict[str, str]] = {}
+        # Map: function name → var names the loopify pass wants typed double
+        # (index-loop value vars whose element expr carries float evidence)
+        self.loopify_float_vars: dict[str, set[str]] = {}
+
+    def run(self) -> bool:
+        # Pass 0: conservative expression-function inlining (V8-style call
+        # boundary elimination, but proven statically instead of speculated).
+        # Runs BEFORE loopify so sum(genexp) elements become cheap arithmetic
+        # (inlined callees) instead of calls that loopify must reject.
+        self._inline_functions()
+
+        # Pass 1: sum(genexp) → typed accumulator loop (kills the boxed
+        # generator protocol; before type solving so the solver sees the loop)
+        if self._loopify_sums():
+            self.applied_strategies.append("sum-loopify")
+
+        # Analyse classes (collect cdef candidates before type solving)
+        self._analyse_classes()
+
+        # Pass 2: pre-solve all module-level functions to get local var types
+        self._pre_solve_functions()
+
+        # Pass 3: infer attribute types using solved function types
+        if self.cdef_class_names:
+            self._infer_attr_types_from_calls()
+            self._check_arithmetic_safety()
+            self._detect_needs_dict()
+
+        # Pass 4: infer loop variable object types (needed before cfunc gen)
+        self._infer_loop_var_types()
+
+        # Pass 5: transform classes (cdef + cfunc only for called methods)
+        if self.cdef_class_names:
+            self._transform_classes()
+
+        # Pass 6: transform functions (directives + locals + cfunc call rewrite)
+        self._transform_functions()
+
+        # Pass 7: SoA container unboxing (nbody shape: dict-of-tuples ->
+        # list(values) -> pairs). Runs last so all other rewrites have
+        # settled; failures are silent no-ops (pattern simply not found).
+        try:
+            _pb_unbox_tree(self.tree, self.applied_strategies)
+        except Exception:
+            pass
+
+        # Pass 8: integer-list unboxing (fannkuch shape). Also last.
+        try:
+            _fk_unbox_tree(self.tree, self.applied_strategies)
+        except Exception:
+            pass
+
+        # Pass 9 + 10: recursive-function cdef lowering and pure-function
+        # sum-LICM folding (binary_trees shape).  Uses func_arg_types
+        # solved in Pass 2; failures are silent no-ops.
+        try:
+            from .recpass import apply_recursive_passes
+            # int-return proof: reuse solver data — a pure recursive
+            # candidate returns int when every return expr is int-typed.
+            int_returns = set()
+            for fname, ftypes in self.func_types.items():
+                if any(v == LONGLONG for v in ftypes.values()):
+                    pass  # per-var info only; int-return computed below
+            for node in self.tree.body:
+                if isinstance(node, ast.FunctionDef):
+                    sc = _Scanner(node)
+                    sol = _Solver(sc)
+                    sol.solve()
+                    rets = [s.value for s in node.body
+                            if isinstance(s, ast.Return) and s.value]
+                    if (not sc.dynamic and not sc.generator
+                            and rets
+                            and all(sol._is_int_expr(r) or
+                                    sol.int_bits(r) is not None
+                                    for r in rets)):
+                        int_returns.add(node.name)
+            tags = apply_recursive_passes(self.tree,
+                                          self.func_arg_types,
+                                          int_returns)
+            self.applied_strategies.extend(tags)
+        except Exception:
+            pass
+
+        # Add `import cython` if we did anything
+        self._ensure_cython_import()
+        return True
+
+    # -----------------------------------------------------------------
+    # Pass -1: sum(genexp) loopification
+    # -----------------------------------------------------------------
+
+    def _loopify_sums(self) -> bool:
+        """Statement-level rewrite of `x = sum(<genexp>)` and
+        `return [sum(<genexp>) …]` list-comp bodies.
+
+        Only two shapes, both taken straight from real benchmark code:
+
+          A. assign form:
+              <t> = sum(E for T in ITER)
+             → <t> = 0.0;  for T in ITER: <t> += E
+
+          B. list-comp return (spectral_norm):
+              return [sum(E for T in ITER) for OUTER in OITER]
+             → out = []
+               for OUTER in OITER:
+                   acc = 0.0
+                   for T in ITER: acc += E
+                   out.append(acc)
+               return out
+
+        Constraints on E: cheap arithmetic only (Name/Constant/BinOp/
+        UnaryOp — calls are left to the inliner; if a call survived inlining
+        it is not rewritten here).  Tuple targets require `enumerate(seq)`;
+        single-Name targets accept any cheap iterable expression.  On any
+        doubt the node is returned unchanged.  Accumulator typing is left to
+        the existing float solver, which sees `= 0.0` / `+= E` and infers
+        double — the whole point of the rewrite.
+        """
+        changed = False
+        for node in self.tree.body:
+            if isinstance(node, ast.FunctionDef):
+                if self._loopify_in_func(node):
+                    changed = True
+        return changed
+
+    def _build_sum_loop(self, func: ast.FunctionDef,
+                        sum_call: ast.Call,
+                        outer_target: ast.Name | None,
+                        outer_iter: ast.expr | None) -> list | None:
+        """Build replacement statements for one sum(genexp); None = bail."""
+        gen = sum_call.args[0]
+        comp = gen.generators[0]
+        elem = gen.elt
+        tgt = comp.target
+        if not isinstance(tgt, (ast.Name, ast.Tuple)):
+            return None
+        if isinstance(tgt, ast.Tuple) and not (
+                len(tgt.elts) >= 1
+                and all(isinstance(e, ast.Name) for e in tgt.elts)):
+            return None
+        iter_expr = comp.iter
+        if not _cheap_expr(elem):
+            return None
+
+        # enumerate-tuple fast path: when the tuple is (idx, val) over
+        # enumerate(Name) AND the same Name is already used in a len(Name)
+        # call somewhere in this function (the original code assumed it is a
+        # sized sequence), rewrite as an index loop `for idx in range(len(Name)):`
+        # + `val = Name[idx]` — avoids one tuple allocation per iteration,
+        # which dominates otherwise (10x on spectral_norm).
+        tuple_idx_loop = None
+        if isinstance(tgt, ast.Tuple) and len(tgt.elts) == 2 \
+                and isinstance(iter_expr, ast.Call) \
+                and isinstance(iter_expr.func, ast.Name) \
+                and iter_expr.func.id == "enumerate" \
+                and len(iter_expr.args) == 1 and not iter_expr.keywords \
+                and isinstance(iter_expr.args[0], ast.Name):
+            seq_name = iter_expr.args[0].id
+            uses_len = any(
+                isinstance(n, ast.Call) and isinstance(n.func, ast.Name)
+                and n.func.id == "len" and len(n.args) == 1
+                and isinstance(n.args[0], ast.Name)
+                and n.args[0].id == seq_name
+                for n in ast.walk(func))
+            if uses_len:
+                tuple_idx_loop = (
+                    tgt.elts[0], tgt.elts[1], seq_name)
+                # float evidence gate (same precedent as the enumerate
+                # inference): typing the value var double is only sound when
+                # the element expr is float arithmetic; otherwise leave it an
+                # object and the loop still runs, just unoptimized
+                has_float_ev = any(
+                    isinstance(n, ast.Constant) and isinstance(n.value, float)
+                    for n in ast.walk(elem)) or any(
+                    isinstance(n, ast.BinOp) and isinstance(n.op, ast.Div)
+                    for n in ast.walk(elem))
+                if has_float_ev:
+                    self.loopify_float_vars.setdefault(
+                        func.name, set()).add(tgt.elts[1].id)
+
+        acc_store = lambda: ast.Name(id="__pb_acc", ctx=ast.Store())
+        acc_load = lambda: ast.Name(id="__pb_acc", ctx=ast.Load())
+        if tuple_idx_loop is not None:
+            idx_name, val_name, seq = tuple_idx_loop
+            inner_for = ast.For(
+                target=ast.Name(id=idx_name.id, ctx=ast.Store()),
+                iter=ast.Call(
+                    func=ast.Name(id="range", ctx=ast.Load()),
+                    args=[ast.Call(
+                        func=ast.Name(id="len", ctx=ast.Load()),
+                        args=[ast.Name(id=seq, ctx=ast.Load())],
+                        keywords=[])],
+                    keywords=[]),
+                body=[
+                    ast.Assign(
+                        targets=[ast.Name(id=val_name.id, ctx=ast.Store())],
+                        value=ast.Subscript(
+                            value=ast.Name(id=seq, ctx=ast.Load()),
+                            slice=ast.Name(id=idx_name.id, ctx=ast.Load()),
+                            ctx=ast.Load())),
+                    ast.AugAssign(target=acc_store(), op=ast.Add(),
+                                  value=copy.deepcopy(elem)),
+                ],
+                orelse=[])
+        else:
+            inner_for = ast.For(
+                target=copy.deepcopy(tgt),
+                iter=iter_expr,
+                body=[ast.AugAssign(target=acc_store(), op=ast.Add(),
+                                    value=copy.deepcopy(elem))],
+                orelse=[])
+        if outer_target is None:
+            # shape A: assign — accumulator is the user's own var (no temp
+            # pollution for the solver); caller retargets it
+            return [copy.deepcopy(inner_for)]
+        if not isinstance(outer_target, ast.Name) or outer_iter is None:
+            return None
+        # shape B: build out/outer-loop/return around the inner loop
+        return [
+            ast.Assign(targets=[ast.Name(id="__pb_out", ctx=ast.Store())],
+                       value=ast.List(elts=[], ctx=ast.Load())),
+            ast.For(
+                target=copy.deepcopy(outer_target),
+                iter=outer_iter,
+                body=[
+                    ast.Assign(targets=[acc_store()],
+                               value=ast.Constant(value=0.0)),
+                    copy.deepcopy(inner_for),
+                    ast.Expr(value=ast.Call(
+                        func=ast.Attribute(value=ast.Name(
+                            id="__pb_out", ctx=ast.Load()),
+                            attr="append", ctx=ast.Load()),
+                        args=[acc_load()], keywords=[])),
+                ],
+                orelse=[]),
+            ast.Return(value=ast.Name(id="__pb_out", ctx=ast.Load())),
+        ]
+
+    def _loopify_in_func(self, func: ast.FunctionDef) -> bool:
+        """Rewrite sum(genexp) call sites inside `func` (its own statements,
+        not nested defs).  Returns True if anything changed."""
+
+        transformer = self
+
+        class _LoopRewriter(ast.NodeTransformer):
+            def __init__(self):
+                self.hit = False
+
+            def visit_Assign(self, node: ast.Assign) -> ast.AST:
+                self.generic_visit(node)
+                if not (len(node.targets) == 1
+                        and isinstance(node.targets[0], ast.Name)
+                        and _is_sum_genexp(node.value)):
+                    return node
+                orig = node.targets[0].id
+                # the accumulator must not collide with any name the loop
+                # itself binds (e.g. `x = sum(x for x in u)` would produce
+                # `for x in u: x += …` and silently drop iterations)
+                bound = {n.id for n in ast.walk(node.value) if isinstance(n, ast.Name)}
+                if orig in bound and any(
+                        isinstance(t, ast.Name) and t.id == orig
+                        for t in ([node.value.args[0].generators[0].target]
+                                  if isinstance(node.value.args[0].generators[0].target, ast.Name)
+                                  else list(getattr(node.value.args[0].generators[0].target, 'elts', [])))):
+                    return node
+                stmts = transformer._build_sum_loop(func, node.value, None, None)
+                if stmts is None:
+                    return node
+                # retarget the accumulator onto the user's variable so the
+                # solver sees <orig> = 0.0-accumulation and types it double
+                class _Ren(ast.NodeTransformer):
+                    def visit_Name(self, n: ast.Name) -> ast.AST:
+                        if n.id == "__pb_acc":
+                            return ast.copy_location(
+                                ast.Name(id=orig, ctx=n.ctx), n)
+                        return n
+                stmts = [_Ren().visit(s) for s in stmts]
+                self.hit = True
+                return _StmtList([ast.Assign(
+                    targets=[ast.Name(id=orig, ctx=ast.Store())],
+                    value=ast.Constant(value=0.0))] + stmts)
+
+            def visit_Return(self, node: ast.Return) -> ast.AST:
+                self.generic_visit(node)
+                if not (node.value is not None
+                        and isinstance(node.value, ast.ListComp)
+                        and len(node.value.generators) == 1
+                        and not node.value.generators[0].ifs
+                        and isinstance(node.value.generators[0].target, ast.Name)
+                        and _is_sum_genexp(node.value.elt)):
+                    return node
+                g = node.value.generators[0]
+                stmts = transformer._build_sum_loop(
+                    func, node.value.elt, g.target, g.iter)
+                if stmts is None:
+                    return node
+                self.hit = True
+                return _StmtList(stmts)
+
+            def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
+                if node is not func:
+                    return node  # never descend into nested defs
+                self.generic_visit(node)
+                return node
+
+        rewriter = _LoopRewriter()
+        new_body = []
+        for stmt in func.body:
+            out = rewriter.visit(stmt)
+            if isinstance(out, _StmtList):
+                new_body.extend(out.stmts)
+            else:
+                new_body.append(out)
+        # flatten any _StmtList that landed inside nested statement lists
+        # (If/For/While bodies) — a _StmtList left in place breaks the AST
+        func.body = self._flatten_stmt_lists(new_body)
+        return rewriter.hit
+
+    @staticmethod
+    def _flatten_stmt_lists(stmts: list) -> list:
+        out: list = []
+        for s in stmts:
+            if isinstance(s, _StmtList):
+                out.extend(_Transformer._flatten_stmt_lists(s.stmts))
+                continue
+            for fld in ("body", "orelse", "finalbody"):
+                val = getattr(s, fld, None)
+                if isinstance(val, list):
+                    setattr(s, fld, _Transformer._flatten_stmt_lists(val))
+            out.append(s)
+        return out
+
+    # -----------------------------------------------------------------
+    # Pass 0: expression-function inlining
+    # -----------------------------------------------------------------
+
+    def _inline_functions(self) -> None:
+        """Inline small pure expression functions at their call sites.
+
+        Conservative AOT analogue of a JIT's speculative inlining: instead of
+        type feedback we require the callee body to be straight-line cheap
+        arithmetic over its params (no calls, no branches, no globals), so
+        splicing it into the caller can never duplicate a side effect.  The
+        callee def itself is kept for external callers.
+        """
+        funcs = [n for n in self.tree.body if isinstance(n, ast.FunctionDef)]
+
+        # names reassigned at module level disqualify their function (the
+        # call site may legally see the rebound object)
+        rebound: set[str] = set()
+        for node in self.tree.body:
+            if isinstance(node, ast.Assign):
+                for tgt in node.targets:
+                    if isinstance(tgt, ast.Name):
+                        rebound.add(tgt.id)
+
+        candidates: dict[str, dict[str, ast.AST]] = {}
+        for func in funcs:
+            if func.name in rebound or func.name.startswith("_"):
+                continue
+            subst = _inlineable_shape(func)
+            if subst is not None:
+                candidates[func.name] = subst
+
+        if not candidates:
+            return
+
+        candidate_defs = {f.name: f for f in funcs if f.name in candidates}
+        inlined_any = False
+
+        class _Inliner(ast.NodeTransformer):
+            def __init__(self, owner: ast.AST):
+                self.owner = owner
+                self.depth = 0
+
+            def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
+                # rewrite only the owner's own body; never descend into
+                # nested defs (their scoping/semantics stay untouched)
+                if node is not self.owner:
+                    return node
+                self.generic_visit(node)
+                return node
+
+            def visit_Call(self, node: ast.Call) -> ast.AST:
+                self.generic_visit(node)
+                if not (isinstance(node.func, ast.Name)
+                        and node.func.id in candidates
+                        and not node.keywords):
+                    return node
+                subst = candidates[node.func.id]
+                params = list(func_params[node.func.id])
+                if len(node.args) != len(params):
+                    return node
+                arg_map: dict[str, ast.AST] = {}
+                for p, a in zip(params, node.args):
+                    if not _cheap_expr(a):
+                        return node  # duplicated evaluation could be costly
+                    arg_map[p] = copy.deepcopy(a)
+                # two-stage resolution, both single-pass:
+                #  1. resolve each temp body against the caller's args (temp
+                #     bodies contain only param names by construction)
+                #  2. one pass over the return expr with temps + param
+                #     bindings — each name replaced exactly once
+                temp_map = {
+                    name: _subst_names(expr, arg_map)
+                    for name, expr in subst.items() if name not in arg_map}
+                final_map = dict(temp_map)
+                final_map.update(arg_map)
+                ret_expr = candidate_defs[node.func.id].body[-1].value
+                return ast.copy_location(
+                    _subst_names(ret_expr, final_map), node)
+
+        # param order per candidate, for arity checks
+        func_params = {
+            f.name: [a.arg for a in f.args.args] for f in funcs
+            if f.name in candidates}
+
+        for func in funcs:
+            if func.name in candidates:
+                continue  # keep candidate bodies pristine
+            inliner = _Inliner(func)
+            before = ast.dump(func)
+            new_func = inliner.visit(func)
+            if ast.dump(new_func) != before:
+                inlined_any = True
+
+        if inlined_any:
+            self.applied_strategies.append("inline")
+
+    def _pre_solve_functions(self) -> None:
+        """Scan and solve all module-level functions to learn variable types.
+
+        This lets us infer attribute types from call sites like
+        Account(i, 1000.0) where i is a solved longlong loop variable.
+        """
+        for node in self.tree.body:
+            if not isinstance(node, ast.FunctionDef):
+                continue
+            sc = _Scanner(node)
+            if sc.dynamic or sc.generator:
+                continue
+            solver = _Solver(sc)
+            solver.solve()
+            self.func_types[node.name] = dict(solver.typed_locals)
+            # Infer arg types from solved types + usage patterns
+            arg_types: dict[str, str] = {}
+            arg_names = {a.arg for a in node.args.args}
+            for name, ctype in solver.typed_locals.items():
+                if name in arg_names:
+                    arg_types[name] = ctype
+            # Check if args are used in float context (Div, float literal)
+            for name in arg_names:
+                if name in arg_types:
+                    continue
+                for sub in ast.walk(node):
+                    if isinstance(sub, ast.BinOp) and isinstance(sub.op, ast.Div):
+                        for side in (sub.left, sub.right):
+                            if isinstance(side, ast.Name) and side.id == name:
+                                arg_types[name] = DOUBLE
+                                break
+                    if isinstance(sub, ast.BinOp):
+                        for side in (sub.left, sub.right):
+                            if (isinstance(side, ast.Constant)
+                                    and isinstance(side.value, float)):
+                                other = sub.right if side is sub.left else sub.left
+                                if isinstance(other, ast.Name) and other.id == name:
+                                    arg_types[name] = DOUBLE
+                                    break
+            self.func_arg_types[node.name] = arg_types
+
+    # -----------------------------------------------------------------
+    # Class analysis
+    # -----------------------------------------------------------------
+
+    def _analyse_classes(self) -> None:
+        for node in self.tree.body:
+            if not isinstance(node, ast.ClassDef):
+                continue
+            plan = self._analyse_one_class(node)
+            self.class_plans[id(node)] = plan
+            if not plan.skip:
+                self.cdef_class_names.add(plan.name)
+        # Note: we do NOT skip parents of non-cdef subclasses here.
+        # The _detect_needs_dict step 2 sets needs_dict=True on parents
+        # that have non-cdef subclasses, and _has_noncdef_subclass
+        # prevents cfunc generation on those classes.
+
+    def _analyse_one_class(self, node: ast.ClassDef) -> ClassPlan:
+        plan = ClassPlan(node=node, name=node.name)
+
+        has_slots = any(
+            isinstance(stmt, ast.Assign)
+            and any(isinstance(t, ast.Name) and t.id == "__slots__"
+                    for t in stmt.targets)
+            for stmt in node.body)
+        init = next((s for s in node.body
+                     if isinstance(s, ast.FunctionDef) and s.name == "__init__"),
+                    None)
+
+        if not has_slots and not init:
+            plan.skip = True
+            plan.reason = "no __slots__/__init__"
+            return plan
+
+        # Must inherit only from object (or no bases)
+        for base in node.bases:
+            if not (isinstance(base, ast.Name) and base.id == "object"):
+                plan.skip = True
+                plan.reason = "non-object base"
+                return plan
+
+        # Collect attributes from __init__
+        if init:
+            for stmt in ast.walk(init):
+                if (isinstance(stmt, ast.Assign)
+                        and len(stmt.targets) == 1
+                        and isinstance(stmt.targets[0], ast.Attribute)
+                        and isinstance(stmt.targets[0].value, ast.Name)
+                        and stmt.targets[0].value.id == "self"):
+                    attr_name = stmt.targets[0].attr
+                    ctype = _classify_literal(stmt.value)
+                    plan.all_attrs[attr_name] = ctype
+
+        if not plan.all_attrs and not has_slots:
+            plan.skip = True
+            plan.reason = "no self attrs"
+            return plan
+
+        plan.skip = False
+        return plan
+
+    # -----------------------------------------------------------------
+    # Attribute type inference from call sites
+    # -----------------------------------------------------------------
+
+    def _infer_attr_types_from_calls(self) -> None:
+        class_params: dict[str, list[str]] = {}
+        for plan in self.class_plans.values():
+            if plan.skip:
+                continue
+            init = next((s for s in plan.node.body
+                         if isinstance(s, ast.FunctionDef) and s.name == "__init__"),
+                        None)
+            if init:
+                class_params[plan.name] = [
+                    a.arg for a in init.args.args if a.arg != "self"]
+
+        # Walk the tree. When we enter a function, remember its solved types
+        # so we can use solved variable types to classify call arguments.
+        for top_node in self.tree.body:
+            if isinstance(top_node, ast.FunctionDef):
+                solved = self.func_types.get(top_node.name, {})
+            else:
+                solved = {}
+
+            for node in ast.walk(top_node):
+                if not isinstance(node, ast.Call):
+                    continue
+                func = node.func
+                if not (isinstance(func, ast.Name) and func.id in class_params):
+                    continue
+                cls_name = func.id
+                params = class_params[cls_name]
+                plan = next((p for p in self.class_plans.values()
+                            if p.name == cls_name), None)
+                if not plan:
+                    continue
+                for i, arg in enumerate(node.args):
+                    if i >= len(params):
+                        break
+                    param_name = params[i]
+                    if param_name not in plan.all_attrs:
+                        continue
+                    ctype = self._classify_call_arg(arg, solved)
+                    if ctype and plan.all_attrs.get(param_name) == OBJECT:
+                        plan.all_attrs[param_name] = ctype
+
+    def _classify_call_arg(self, node: ast.AST,
+                           solved: dict[str, str]) -> str | None:
+        """Classify a call argument using solved local variable types."""
+        # Direct literal classification
+        ctype = _classify_expr(node)
+        if ctype:
+            return ctype
+        # Solved variable names
+        if isinstance(node, ast.Name) and node.id in solved:
+            return solved[node.id]
+        # BinOp: if either side is solved-float or float literal → double
+        # If both sides are solved-int or int literal → longlong
+        if isinstance(node, ast.BinOp):
+            lt = self._classify_call_arg(node.left, solved)
+            rt = self._classify_call_arg(node.right, solved)
+            if lt and rt:
+                if DOUBLE in (lt, rt):
+                    return DOUBLE
+                return LONGLONG
+        # UnaryOp
+        if isinstance(node, ast.UnaryOp):
+            return self._classify_call_arg(node.operand, solved)
+        # Call: float() → double, int()/len()/abs() → longlong
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+            if node.func.id == "float":
+                return DOUBLE
+            if node.func.id in ("int", "len", "abs"):
+                return LONGLONG
+        return None
+
+    # -----------------------------------------------------------------
+    # Arithmetic safety: downgrade longlong attrs in Mult/Pow/LShift
+    # -----------------------------------------------------------------
+
+    def _check_arithmetic_safety(self) -> None:
+        for plan in self.class_plans.values():
+            if plan.skip:
+                continue
+            longlong_attrs = {k for k, v in plan.all_attrs.items()
+                              if v == LONGLONG}
+            if not longlong_attrs:
+                continue
+            for method in plan.node.body:
+                if not isinstance(method, ast.FunctionDef):
+                    continue
+                for node in ast.walk(method):
+                    if (isinstance(node, ast.BinOp)
+                            and isinstance(node.op, (ast.Mult, ast.Pow, ast.LShift))):
+                        for child in (node.left, node.right):
+                            if (isinstance(child, ast.Attribute)
+                                    and isinstance(child.value, ast.Name)
+                                    and child.value.id == "self"
+                                    and child.attr in longlong_attrs):
+                                longlong_attrs.discard(child.attr)
+            for attr_name, ctype in list(plan.all_attrs.items()):
+                if ctype == LONGLONG and attr_name not in longlong_attrs:
+                    plan.all_attrs[attr_name] = OBJECT
+
+    # -----------------------------------------------------------------
+    # needs_dict detection
+    # -----------------------------------------------------------------
+
+    def _detect_needs_dict(self) -> None:
+        attr_to_classes: dict[str, set[str]] = {}
+        for plan in self.class_plans.values():
+            if plan.skip:
+                continue
+            for attr_name in plan.all_attrs:
+                attr_to_classes.setdefault(attr_name, set()).add(plan.name)
+
+        # 1. Dunder methods accessing other.attr
+        for plan in self.class_plans.values():
+            if plan.skip:
+                continue
+            for method in plan.node.body:
+                if not isinstance(method, ast.FunctionDef):
+                    continue
+                is_dunder = (method.name.startswith("__")
+                             and method.name.endswith("__"))
+                if not is_dunder:
+                    continue
+                param_names = {a.arg for a in method.args.args
+                               if a.arg != "self"}
+                for node in ast.walk(method):
+                    if (isinstance(node, ast.Attribute)
+                            and node.attr in attr_to_classes
+                            and isinstance(node.value, ast.Name)
+                            and node.value.id in param_names):
+                        plan.needs_dict = True
+
+        # 2. Non-cdef subclasses of cdef classes
+        cdef_names = self.cdef_class_names
+        for plan in self.class_plans.values():
+            if plan.skip:
+                for base in plan.node.bases:
+                    base_name = (base.id if isinstance(base, ast.Name)
+                                 else getattr(base, "attr", None))
+                    if base_name in cdef_names:
+                        for parent in self.class_plans.values():
+                            if parent.name == base_name and not parent.skip:
+                                parent.needs_dict = True
+
+        # 3. External attribute access from module-level function bodies.
+        #    Class methods access same-type attrs via C-level (AnnAssign is fine).
+        #    But module-level functions that do obj.attr need visibility="public".
+        cdef_attr_set = set(attr_to_classes.keys())
+        for top in self.tree.body:
+            if isinstance(top, ast.ClassDef):
+                continue  # class methods access same-type attrs via C-level
+            for node in ast.walk(top):
+                if (isinstance(node, ast.Attribute)
+                        and node.attr in cdef_attr_set
+                        and isinstance(node.value, ast.Name)):
+                    for cls_name in attr_to_classes.get(node.attr, set()):
+                        for plan in self.class_plans.values():
+                            if plan.name == cls_name and not plan.skip:
+                                plan.needs_dict = True
+
+    # -----------------------------------------------------------------
+    # Loop variable object type inference (needed before cfunc generation)
+    # -----------------------------------------------------------------
+
+    def _infer_loop_var_types(self) -> None:
+        """Infer loop variable types and record which methods need cfunc.
+
+        A method only gets a cfunc variant if it's called on a typed loop
+        variable — otherwise the wrapper just adds overhead.
+        """
+        # Map: class_name → set of method names called on typed loop vars
+        self.cfunc_needed: dict[str, set[str]] = {}
+
+        for node in self.tree.body:
+            if not isinstance(node, ast.FunctionDef):
+                continue
+            loop_var_types: dict[str, str] = {}
+            for inner in ast.walk(node):
+                if isinstance(inner, ast.For) and isinstance(inner.target, ast.Name):
+                    var_name = inner.target.id
+                    iter_node = inner.iter
+                    if (isinstance(iter_node, ast.ListComp)
+                            and isinstance(iter_node.elt, ast.Call)
+                            and isinstance(iter_node.elt.func, ast.Name)
+                            and iter_node.elt.func.id in self.cdef_class_names):
+                        loop_var_types[var_name] = iter_node.elt.func.id
+                    elif isinstance(iter_node, ast.Name):
+                        cls = self._find_list_var_type(node, iter_node.id)
+                        if cls:
+                            loop_var_types[var_name] = cls
+
+            # Find which methods are called on typed loop vars
+            if loop_var_types:
+                for inner in ast.walk(node):
+                    if (isinstance(inner, ast.Call)
+                            and isinstance(inner.func, ast.Attribute)
+                            and isinstance(inner.func.value, ast.Name)
+                            and inner.func.value.id in loop_var_types):
+                        cls_name = loop_var_types[inner.func.value.id]
+                        method_name = inner.func.attr
+                        self.cfunc_needed.setdefault(cls_name, set()).add(method_name)
+
+        if self.cfunc_needed:
+            self.applied_strategies.append("loop-var-obj-type")
+
+    # -----------------------------------------------------------------
+    # Transform class ASTs → cdef classes
+    # -----------------------------------------------------------------
+
+    def _transform_classes(self) -> None:
+        for plan in self.class_plans.values():
+            if plan.skip:
+                continue
+            self._build_cdef_class(plan)
+        if self.cdef_class_names:
+            self.applied_strategies.append("cdef-class")
+
+    def _has_noncdef_subclass(self, cls_name: str) -> bool:
+        """Check if any non-cdef (skipped) class inherits from cls_name."""
+        for plan in self.class_plans.values():
+            if plan.skip:
+                for base in plan.node.bases:
+                    base_name = (base.id if isinstance(base, ast.Name)
+                                 else getattr(base, "attr", None))
+                    if base_name == cls_name:
+                        return True
+        return False
+
+    def _expand_method_aliases(self, node: ast.ClassDef) -> None:
+        """Expand method aliases like __rmul__ = __mul__ into proper methods.
+
+        Cython cdef classes don't support class-attribute method aliases.
+        Convert:  __rmul__ = __mul__
+        Into:     def __rmul__(self, other):
+                      return self.__mul__(other)
+        """
+        # Collect names of actual methods and their arg signatures
+        method_sigs: dict[str, ast.arguments] = {}
+        for stmt in node.body:
+            if isinstance(stmt, ast.FunctionDef):
+                method_sigs[stmt.name] = stmt.args
+
+        new_body = []
+        for stmt in node.body:
+            if (isinstance(stmt, ast.Assign)
+                    and len(stmt.targets) == 1
+                    and isinstance(stmt.targets[0], ast.Name)
+                    and isinstance(stmt.value, ast.Name)
+                    and stmt.targets[0].id.startswith("__")
+                    and stmt.targets[0].id.endswith("__")
+                    and stmt.value.id in method_sigs):
+                # This is a method alias like __rmul__ = __mul__
+                alias_name = stmt.targets[0].id
+                target_method = stmt.value.id
+                target_args = method_sigs[target_method]
+                # Copy the target method's args (excluding self)
+                call_args = [
+                    ast.Name(id=a.arg, ctx=ast.Load())
+                    for a in target_args.args
+                    if a.arg != "self"
+                ]
+                wrapper = ast.FunctionDef(
+                    name=alias_name,
+                    args=copy.deepcopy(target_args),
+                    body=[ast.Return(value=ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Name(id="self", ctx=ast.Load()),
+                            attr=target_method, ctx=ast.Load()),
+                        args=call_args,
+                        keywords=[],
+                    ))],
+                    decorator_list=[],
+                    returns=None,
+                )
+                new_body.append(wrapper)
+            else:
+                new_body.append(stmt)
+        node.body = new_body
+
+    def _build_cdef_class(self, plan: ClassPlan) -> None:
+        node = plan.node
+
+        # @cython.cclass
+        node.decorator_list.insert(0, ast.Attribute(
+            value=ast.Name(id="cython", ctx=ast.Load()),
+            attr="cclass", ctx=ast.Load()))
+
+        # Attribute declarations
+        # needs_dict means external code accesses obj.attr — use visibility="public"
+        # so the field is accessible from non-cdef code.  But we do NOT add __dict__
+        # because visibility="public" already provides Python-level access and
+        # __dict__ forces a dict allocation + lookup overhead on every access.
+        attr_decls = []
+        use_public = plan.needs_dict
+        for attr_name, ctype in sorted(plan.all_attrs.items()):
+            type_expr = _ctype_to_ast(ctype)
+            if use_public:
+                attr_decls.append(ast.Assign(
+                    targets=[ast.Name(id=attr_name, ctx=ast.Store())],
+                    value=ast.Call(
+                        func=ast.Attribute(
+                            value=ast.Name(id="cython", ctx=ast.Load()),
+                            attr="declare", ctx=ast.Load()),
+                        args=[type_expr],
+                        keywords=[ast.keyword(
+                            arg="visibility",
+                            value=ast.Constant(value="public"))])))
+            else:
+                attr_decls.append(ast.AnnAssign(
+                    target=ast.Name(id=attr_name, ctx=ast.Store()),
+                    annotation=type_expr,
+                    value=None, simple=1))
+
+        # Remove __slots__
+        node.body = [stmt for stmt in node.body
+                     if not (isinstance(stmt, ast.Assign)
+                             and any(isinstance(t, ast.Name)
+                                     and t.id == "__slots__"
+                                     for t in stmt.targets))]
+        node.body = attr_decls + node.body
+
+        # Expand method aliases: __rmul__ = __mul__ → def __rmul__(self, *a, **kw)
+        # Cython cdef classes don't support class-attribute method aliases.
+        self._expand_method_aliases(node)
+
+        # cfunc method generation — generate for ALL eligible methods.
+        # Even when the receiver is untyped (Python object), the cfunc method
+        # has typed self and typed params, making attribute access C-level.
+        # BUT: skip cfunc for classes that have non-cdef subclasses —
+        # polymorphic dispatch goes through Python anyway, and the wrapper
+        # just adds overhead.
+        has_noncdef_subclass = self._has_noncdef_subclass(plan.name)
+        new_body = []
+        for stmt in node.body:
+            new_body.append(stmt)
+            if (isinstance(stmt, ast.FunctionDef)
+                    and self._is_cfunc_eligible(stmt)
+                    and not has_noncdef_subclass):
+                fast_name, fast_method = self._make_cfunc_method(stmt, plan)
+                plan.cfunc_methods[stmt.name] = fast_name
+                idx = new_body.index(stmt)
+                new_body.insert(idx + 1, fast_method)
+
+        # Rewrite original methods → thin wrappers with typed params
+        for i, stmt in enumerate(new_body):
+            if (isinstance(stmt, ast.FunctionDef)
+                    and stmt.name in plan.cfunc_methods):
+                fast_name = plan.cfunc_methods[stmt.name]
+                new_body[i] = self._make_wrapper(stmt, fast_name, plan)
+
+        node.body = new_body
+        if plan.cfunc_methods:
+            self.applied_strategies.append("cfunc-method")
+
+    def _is_cfunc_eligible(self, method: ast.FunctionDef) -> bool:
+        name = method.name
+        if name.startswith("__") and name.endswith("__"):
+            return False
+        if method.decorator_list:
+            return False
+        for node in ast.walk(method):
+            if isinstance(node, (ast.Yield, ast.YieldFrom)):
+                return False
+        args = method.args
+        if args.vararg or args.kwarg or args.kwonlyargs or args.defaults:
+            return False
+        return True
+
+    def _make_cfunc_method(self, method: ast.FunctionDef,
+                           plan: ClassPlan) -> tuple[str, ast.FunctionDef]:
+        fast_name = f"_{method.name}_fast"
+        new_body = [copy.deepcopy(stmt) for stmt in method.body]
+        new_args = copy.deepcopy(method.args)
+
+        # @cython.locals for typed params (inferred from __init__ assignments)
+        locals_decls: dict[str, str] = {}
+        init = next((s for s in plan.node.body
+                     if isinstance(s, ast.FunctionDef)
+                     and s.name == "__init__"), None)
+        if init:
+            for stmt in ast.walk(init):
+                if (isinstance(stmt, ast.Assign)
+                        and len(stmt.targets) == 1
+                        and isinstance(stmt.targets[0], ast.Attribute)
+                        and isinstance(stmt.targets[0].value, ast.Name)
+                        and stmt.targets[0].value.id == "self"):
+                    attr_name = stmt.targets[0].attr
+                    attr_type = plan.all_attrs.get(attr_name, OBJECT)
+                    if attr_type != OBJECT and isinstance(stmt.value, ast.Name):
+                        locals_decls[stmt.value.id] = attr_type
+
+        # Infer param types from comparisons with typed attrs
+        for node in ast.walk(method):
+            if (isinstance(node, ast.Compare)
+                    and isinstance(node.left, ast.Attribute)
+                    and isinstance(node.left.value, ast.Name)
+                    and node.left.value.id == "self"):
+                attr_type = plan.all_attrs.get(node.left.attr, OBJECT)
+                if attr_type != OBJECT:
+                    for comparator in node.comparators:
+                        if isinstance(comparator, ast.Name):
+                            locals_decls.setdefault(comparator.id, attr_type)
+
+        # Annotate params that access cdef class attrs (e.g. other: 'Point')
+        # This enables C-level attribute access inside the cfunc method.
+        cls_name = plan.name
+        for arg in new_args.args:
+            if arg.arg == "self":
+                continue
+            for node in ast.walk(method):
+                if (isinstance(node, ast.Attribute)
+                        and isinstance(node.value, ast.Name)
+                        and node.value.id == arg.arg
+                        and node.attr in plan.all_attrs):
+                    arg.annotation = ast.Constant(value=cls_name)
+                    break
+
+        fast_method = ast.FunctionDef(
+            name=fast_name,
+            args=new_args,
+            body=new_body,
+            decorator_list=[],
+            returns=copy.deepcopy(method.returns),
+        )
+        fast_method.decorator_list.append(ast.Attribute(
+            value=ast.Name(id="cython", ctx=ast.Load()),
+            attr="cfunc", ctx=ast.Load()))
+
+        if locals_decls:
+            fast_method.decorator_list.append(ast.Call(
+                func=ast.Attribute(
+                    value=ast.Name(id="cython", ctx=ast.Load()),
+                    attr="locals", ctx=ast.Load()),
+                args=[],
+                keywords=[ast.keyword(arg=n, value=_ctype_to_ast(t))
+                          for n, t in sorted(locals_decls.items())]))
+
+        # Return type inference
+        ret_type = self._infer_return_type(method, plan)
+        if ret_type:
+            fast_method.decorator_list.append(ast.Call(
+                func=ast.Attribute(
+                    value=ast.Name(id="cython", ctx=ast.Load()),
+                    attr="returns", ctx=ast.Load()),
+                args=[_ctype_to_ast(ret_type)],
+                keywords=[]))
+
+        return fast_name, fast_method
+
+    def _infer_return_type(self, method: ast.FunctionDef,
+                           plan: ClassPlan) -> str | None:
+        for node in ast.walk(method):
+            if isinstance(node, ast.Return) and node.value is not None:
+                val = node.value
+                if (isinstance(val, ast.Attribute)
+                        and isinstance(val.value, ast.Name)
+                        and val.value.id == "self"):
+                    attr_type = plan.all_attrs.get(val.attr, OBJECT)
+                    if attr_type == DOUBLE:
+                        return DOUBLE
+                if isinstance(val, ast.Compare):
+                    return BINT
+                if isinstance(val, ast.BinOp):
+                    lt = self._expr_type(val.left, plan)
+                    rt = self._expr_type(val.right, plan)
+                    if DOUBLE in (lt, rt):
+                        return DOUBLE
+                    if lt == LONGLONG and rt == LONGLONG:
+                        return LONGLONG
+                if isinstance(val, ast.Constant):
+                    if isinstance(val.value, bool):
+                        return BINT
+                    if isinstance(val.value, float):
+                        return DOUBLE
+        return None
+
+    def _expr_type(self, node, plan: ClassPlan) -> str:
+        if isinstance(node, ast.Attribute) and isinstance(node.value, ast.Name) \
+                and node.value.id == "self":
+            return plan.all_attrs.get(node.attr, OBJECT)
+        if isinstance(node, ast.Constant):
+            if isinstance(node.value, float):
+                return DOUBLE
+            if isinstance(node.value, int):
+                return LONGLONG
+        return OBJECT
+
+    def _make_wrapper(self, method: ast.FunctionDef, fast_name: str,
+                      plan: ClassPlan) -> ast.FunctionDef:
+        args = copy.deepcopy(method.args)
+        call_args = [ast.Name(id=a.arg, ctx=ast.Load())
+                     for a in args.args if a.arg != "self"]
+        cls_name = plan.name
+
+        # Infer parameter types for the wrapper signature.
+        # Typed params let Cython avoid Python-level boxing/unboxing at the
+        # call boundary, which is the dominant overhead for thin wrappers.
+        wrapper_param_types = self._infer_wrapper_param_types(method, plan)
+
+        for arg in args.args:
+            if arg.arg == "self":
+                continue
+            inferred = wrapper_param_types.get(arg.arg)
+            if inferred == cls_name:
+                # Same-class param (e.g. other: 'P') — string annotation
+                arg.annotation = ast.Constant(value=cls_name)
+            elif inferred and inferred != OBJECT:
+                # Scalar param (e.g. s: cython.double) — Cython type
+                arg.annotation = _ctype_to_ast(inferred)
+
+        return ast.FunctionDef(
+            name=method.name,
+            args=args,
+            body=[ast.Return(value=ast.Call(
+                func=ast.Attribute(
+                    value=ast.Name(id="self", ctx=ast.Load()),
+                    attr=fast_name, ctx=ast.Load()),
+                args=call_args,
+                keywords=[]))],
+            decorator_list=copy.deepcopy(method.decorator_list),
+            returns=copy.deepcopy(method.returns),
+        )
+
+    def _infer_wrapper_param_types(self, method: ast.FunctionDef,
+                                    plan: ClassPlan) -> dict[str, str]:
+        """Infer Cython types for wrapper parameters.
+
+        A parameter gets a type if it interacts with a typed self.attr:
+        - Direct attribute access: other.x  -> other is the cdef class type
+        - Arithmetic with typed attr: self.x *= s  -> s is the attr's type
+        - Comparison with typed attr: self.x == v  -> v is the attr's type
+        - Assignment from param: self.x = s  -> s is the attr's type
+        """
+        result: dict[str, str] = {}
+        cls_name = plan.name
+
+        for arg in method.args.args:
+            if arg.arg == "self":
+                continue
+            arg_name = arg.arg
+            found = False
+            for node in ast.walk(method):
+                # Case 1: param.attr — param is cdef class type
+                if (isinstance(node, ast.Attribute)
+                        and isinstance(node.value, ast.Name)
+                        and node.value.id == arg_name
+                        and node.attr in plan.all_attrs):
+                    result[arg_name] = cls_name
+                    found = True
+                    break
+
+                # Case 2: self.attr OP= param  (augmented assign)
+                if (isinstance(node, ast.AugAssign)
+                        and isinstance(node.target, ast.Attribute)
+                        and isinstance(node.target.value, ast.Name)
+                        and node.target.value.id == "self"
+                        and node.target.attr in plan.all_attrs
+                        and isinstance(node.value, ast.Name)
+                        and node.value.id == arg_name):
+                    attr_type = plan.all_attrs.get(node.target.attr, OBJECT)
+                    if attr_type != OBJECT:
+                        result[arg_name] = attr_type
+                        found = True
+                        break
+
+                # Case 3: param OP= self.attr  (augmented assign, reversed)
+                if (isinstance(node, ast.AugAssign)
+                        and isinstance(node.target, ast.Name)
+                        and node.target.id == arg_name
+                        and isinstance(node.value, ast.Attribute)
+                        and isinstance(node.value.value, ast.Name)
+                        and node.value.value.id == "self"
+                        and node.value.attr in plan.all_attrs):
+                    attr_type = plan.all_attrs.get(node.value.attr, OBJECT)
+                    if attr_type != OBJECT:
+                        result[arg_name] = attr_type
+                        found = True
+                        break
+
+                # Case 4: self.attr OP param  or  param OP self.attr
+                if isinstance(node, ast.BinOp):
+                    for side, other_side in [
+                            (node.left, node.right),
+                            (node.right, node.left)]:
+                        if (isinstance(side, ast.Name)
+                                and side.id == arg_name
+                                and isinstance(other_side, ast.Attribute)
+                                and isinstance(other_side.value, ast.Name)
+                                and other_side.value.id == "self"
+                                and other_side.attr in plan.all_attrs):
+                            attr_type = plan.all_attrs.get(
+                                other_side.attr, OBJECT)
+                            if attr_type != OBJECT:
+                                result[arg_name] = attr_type
+                                found = True
+                                break
+
+                # Case 5: self.attr == param  (comparison)
+                if isinstance(node, ast.Compare):
+                    if (isinstance(node.left, ast.Attribute)
+                            and isinstance(node.left.value, ast.Name)
+                            and node.left.value.id == "self"
+                            and node.left.attr in plan.all_attrs):
+                        for comp in node.comparators:
+                            if (isinstance(comp, ast.Name)
+                                    and comp.id == arg_name):
+                                attr_type = plan.all_attrs.get(
+                                    node.left.attr, OBJECT)
+                                if attr_type != OBJECT:
+                                    result[arg_name] = attr_type
+                                    found = True
+                                    break
+
+                # Case 6: self.attr = param  (assignment)
+                if (isinstance(node, ast.Assign)
+                        and len(node.targets) == 1
+                        and isinstance(node.targets[0], ast.Attribute)
+                        and isinstance(node.targets[0].value, ast.Name)
+                        and node.targets[0].value.id == "self"
+                        and node.targets[0].attr in plan.all_attrs
+                        and isinstance(node.value, ast.Name)
+                        and node.value.id == arg_name):
+                    attr_type = plan.all_attrs.get(
+                        node.targets[0].attr, OBJECT)
+                    if attr_type != OBJECT:
+                        result[arg_name] = attr_type
+                        found = True
+                        break
+
+                if found:
+                    break
+
+        return result
+
+    # -----------------------------------------------------------------
+    # Function-level transforms
+    # -----------------------------------------------------------------
+
+    def _transform_functions(self) -> None:
+        all_cfunc_methods: dict[str, dict[str, str]] = {}
+        for plan in self.class_plans.values():
+            if plan.skip:
+                continue
+            all_cfunc_methods[plan.name] = plan.cfunc_methods
+
+        for node in self.tree.body:
+            if not isinstance(node, ast.FunctionDef):
+                continue
+            self._transform_one_function(node, all_cfunc_methods)
+
+    def _transform_one_function(self, func: ast.FunctionDef,
+                                all_cfunc_methods: dict[str, dict[str, str]]) -> None:
+        sc = _Scanner(func)
+        if sc.dynamic or sc.generator or sc.bad_except or sc.global_nonlocal:
+            return
+
+        solver = _Solver(sc)
+        solver.solve()
+
+        # Directives
+        directives = [
+            ("boundscheck", False),
+            ("wraparound", False),
+            ("cdivision", True),
+        ]
+        for name, val in directives:
+            dec = ast.Call(
+                func=ast.Attribute(
+                    value=ast.Name(id="cython", ctx=ast.Load()),
+                    attr=name, ctx=ast.Load()),
+                args=[ast.Constant(value=val)],
+                keywords=[])
+            dec.lineno = max(func.lineno - 1, 1)
+            dec.col_offset = func.col_offset
+            func.decorator_list.append(dec)
+
+        # Reuse loop var types from _infer_loop_var_types
+        loop_var_types: dict[str, str] = {}
+        for inner in ast.walk(func):
+            if isinstance(inner, ast.For) and isinstance(inner.target, ast.Name):
+                var_name = inner.target.id
+                iter_node = inner.iter
+                if (isinstance(iter_node, ast.ListComp)
+                        and isinstance(iter_node.elt, ast.Call)
+                        and isinstance(iter_node.elt.func, ast.Name)
+                        and iter_node.elt.func.id in self.cdef_class_names):
+                    loop_var_types[var_name] = iter_node.elt.func.id
+                elif isinstance(iter_node, ast.Name):
+                    cls = self._find_list_var_type(func, iter_node.id)
+                    if cls:
+                        loop_var_types[var_name] = cls
+
+        # Merge: typed locals from solver + loop var object types
+        typed_locals = dict(solver.typed_locals)
+        for var in self.loopify_float_vars.get(func.name, ()):
+            if var not in typed_locals:
+                typed_locals[var] = DOUBLE
+        for var, cls in loop_var_types.items():
+            typed_locals[var] = cls
+
+        # Closure-capture guard: a variable referenced inside a nested
+        # genexp/listcomp/setcomp/dictcomp *body* (not its own loop target)
+        # is captured by a Python closure.  Cython C-types locals live
+        # outside the cell protocol, so a typed captured var silently
+        # yields wrong values (e.g. binary_trees `d`).  Never type them.
+        captured = set()
+        for comp in ast.walk(func):
+            if isinstance(comp, (ast.GeneratorExp, ast.ListComp,
+                                 ast.SetComp, ast.DictComp)):
+                for name_node in ast.walk(comp):
+                    if isinstance(name_node, ast.Name):
+                        captured.add(name_node.id)
+        # comprehension loop targets are local to the comprehension, not captures
+        for comp in ast.walk(func):
+            if isinstance(comp, (ast.GeneratorExp, ast.ListComp,
+                                 ast.SetComp, ast.DictComp)):
+                for gen in comp.generators:
+                    tgt = gen.target
+                    for name_node in ast.walk(tgt):
+                        if isinstance(name_node, ast.Name):
+                            captured.discard(name_node.id)
+        for name in captured:
+            typed_locals.pop(name, None)
+
+        # Infer cdef class types for locals that access cdef attributes
+        # (e.g. a = points[i]; a.x  →  a is 'P' type for C-level field access)
+        cdef_locals = self._infer_cdef_locals(func, loop_var_types)
+        for var, cls in cdef_locals.items():
+            if var not in typed_locals:
+                typed_locals[var] = cls
+
+        # Merge cdef_locals into loop_var_types for cfunc rewriting
+        all_obj_vars = dict(loop_var_types)
+        all_obj_vars.update(cdef_locals)
+
+        # Rewrite cfunc calls for typed obj vars
+        if all_obj_vars:
+            self._rewrite_cfunc_calls(func, all_obj_vars, all_cfunc_methods)
+
+        # @cython.locals
+        if typed_locals:
+            dec = ast.Call(
+                func=ast.Attribute(
+                    value=ast.Name(id="cython", ctx=ast.Load()),
+                    attr="locals", ctx=ast.Load()),
+                args=[],
+                keywords=[ast.keyword(arg=n, value=_ctype_to_ast(t))
+                          for n, t in sorted(typed_locals.items())])
+            dec.lineno = max(func.lineno - 1, 1)
+            dec.col_offset = func.col_offset
+            func.decorator_list.append(dec)
+            self.applied_strategies.append("type-infer")
+
+    def _find_list_var_type(self, func: ast.FunctionDef,
+                            var_name: str) -> str | None:
+        for node in ast.walk(func):
+            if isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name) and target.id == var_name:
+                        val = node.value
+                        if (isinstance(val, ast.ListComp)
+                                and isinstance(val.elt, ast.Call)
+                                and isinstance(val.elt.func, ast.Name)
+                                and val.elt.func.id in self.cdef_class_names):
+                            return val.elt.func.id
+                        if (isinstance(val, ast.List) and val.elts
+                                and isinstance(val.elts[0], ast.Call)
+                                and isinstance(val.elts[0].func, ast.Name)
+                                and val.elts[0].func.id in self.cdef_class_names):
+                            return val.elts[0].func.id
+        return None
+
+    def _infer_cdef_locals(self, func: ast.FunctionDef,
+                           known_vars: dict[str, str]) -> dict[str, str]:
+        """Infer cdef class types for locals that access cdef attributes.
+
+        When a module-level function does:
+            a = points[i]
+            dx = a.x - b.x
+        Cython doesn't know that `a` and `b` are cdef class instances,
+        so `a.x` goes through Python attribute lookup.  By adding
+        @cython.locals(a='P', b='P'), Cython does C-level field access.
+
+        Strategy: find all Name nodes that are used as the receiver of
+        an Attribute access where the attribute name matches a cdef class
+        field.  Then trace back to find how that Name was assigned — if it
+        came from a subscription/iteration of a list known to hold cdef
+        instances, we can type it.
+
+        Also handle for-loop targets: for p in points  →  p is 'P' if
+        points is known to hold P instances (tracked via known_vars or
+        list construction).
+        """
+        result: dict[str, str] = {}
+
+        # Build a map: attr_name -> set of cdef class names that have it
+        attr_to_classes: dict[str, set[str]] = {}
+        for plan in self.class_plans.values():
+            if plan.skip:
+                continue
+            for attr_name in plan.all_attrs:
+                attr_to_classes.setdefault(attr_name, set()).add(plan.name)
+
+        # Build a map: var_name -> cdef class type from assignments
+        # We look for patterns like:
+        #   var = list_var[index]        (where list_var holds cdef instances)
+        #   var = Call(cdef_class, ...)  (direct construction)
+        #   for var in list_var          (iteration over cdef list)
+        var_types: dict[str, str] = dict(known_vars)
+
+        # Track which list vars hold cdef instances
+        # by looking at append calls:  points.append(P(...))
+        list_to_class: dict[str, str] = {}
+        for node in ast.walk(func):
+            if (isinstance(node, ast.Expr)
+                    and isinstance(node.value, ast.Call)
+                    and isinstance(node.value.func, ast.Attribute)
+                    and node.value.func.attr == "append"
+                    and isinstance(node.value.func.value, ast.Name)
+                    and node.value.args
+                    and isinstance(node.value.args[0], ast.Call)
+                    and isinstance(node.value.args[0].func, ast.Name)
+                    and node.value.args[0].func.id in self.cdef_class_names):
+                list_to_class[node.value.func.value.id] = \
+                    node.value.args[0].func.id
+
+        # Also check:  var = [P(...) for ...]  or  var = [P(...), ...]
+        for node in ast.walk(func):
+            if isinstance(node, ast.Assign):
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        cls = self._find_list_var_type(func, target.id)
+                        if cls:
+                            list_to_class[target.id] = cls
+
+        # Infer from for-loop targets
+        for node in ast.walk(func):
+            if (isinstance(node, ast.For)
+                    and isinstance(node.target, ast.Name)
+                    and isinstance(node.iter, ast.Name)
+                    and node.iter.id in list_to_class):
+                var_types[node.target.id] = list_to_class[node.iter.id]
+
+        # Infer from assignments:  var = list_var[index]
+        for node in ast.walk(func):
+            if (isinstance(node, ast.Assign)
+                    and len(node.targets) == 1
+                    and isinstance(node.targets[0], ast.Name)
+                    and isinstance(node.value, ast.Subscript)
+                    and isinstance(node.value.value, ast.Name)
+                    and node.value.value.id in list_to_class):
+                var_types[node.targets[0].id] = \
+                    list_to_class[node.value.value.id]
+
+        # Infer from direct construction:  var = CdefClass(...)
+        for node in ast.walk(func):
+            if (isinstance(node, ast.Assign)
+                    and len(node.targets) == 1
+                    and isinstance(node.targets[0], ast.Name)
+                    and isinstance(node.value, ast.Call)
+                    and isinstance(node.value.func, ast.Name)
+                    and node.value.func.id in self.cdef_class_names):
+                var_types[node.targets[0].id] = node.value.func.id
+
+        # Now find all Name.attr where attr is a cdef field,
+        # and the Name is in var_types
+        for node in ast.walk(func):
+            if (isinstance(node, ast.Attribute)
+                    and isinstance(node.value, ast.Name)
+                    and node.value.id in var_types
+                    and node.attr in attr_to_classes):
+                cls = var_types[node.value.id]
+                if cls in attr_to_classes[node.attr]:
+                    result[node.value.id] = cls
+
+        # Also find: var.attr = value  (AugAssign on cdef field)
+        for node in ast.walk(func):
+            if (isinstance(node, ast.AugAssign)
+                    and isinstance(node.target, ast.Attribute)
+                    and isinstance(node.target.value, ast.Name)
+                    and node.target.value.id in var_types
+                    and node.target.attr in attr_to_classes):
+                cls = var_types[node.target.value.id]
+                if cls in attr_to_classes[node.target.attr]:
+                    result[node.target.value.id] = cls
+
+        # Also include vars that call cdef class methods: p.scale(...)
+        # Even though 'scale' is a method name (not in all_attrs), typing p
+        # as the cdef class lets Cython resolve the method call faster.
+        # Check both direct: p.method() and chained: points[i].method()
+        cdef_class_names = self.cdef_class_names
+        for node in ast.walk(func):
+            if (isinstance(node, ast.Call)
+                    and isinstance(node.func, ast.Attribute)
+                    and isinstance(node.func.value, ast.Name)
+                    and node.func.value.id in var_types):
+                var_name = node.func.value.id
+                cls = var_types[var_name]
+                if cls in cdef_class_names:
+                    result[var_name] = cls
+
+        # Also handle direct subscript calls: points[i].distance(...)
+        # points[i] is not a Name, so it won't be in var_types directly.
+        # But we can type the list var itself so Cython optimizes subscription.
+        # This is handled implicitly: if points is not a Name.attr pattern,
+        # we at least ensure any loop var or assigned var from points is typed.
+
+        return result
+
+    def _rewrite_cfunc_calls(self, func: ast.FunctionDef,
+                             loop_var_types: dict[str, str],
+                             all_cfunc_methods: dict[str, dict[str, str]]) -> None:
+        class _Rewriter(ast.NodeTransformer):
+            def __init__(self, var_types, cfunc_map):
+                self.var_types = var_types
+                self.cfunc_map = cfunc_map
+
+            def visit_Call(self, node):
+                self.generic_visit(node)
+                if (isinstance(node.func, ast.Attribute)
+                        and isinstance(node.func.value, ast.Name)
+                        and node.func.value.id in self.var_types):
+                    var_type = self.var_types[node.func.value.id]
+                    method_name = node.func.attr
+                    fast_map = self.cfunc_map.get(var_type, {})
+                    if method_name in fast_map and not node.keywords:
+                        node.func.attr = fast_map[method_name]
+                return node
+        _Rewriter(loop_var_types, all_cfunc_methods).visit(func)
+
+    # -----------------------------------------------------------------
+    # Ensure `import cython`
+    # -----------------------------------------------------------------
+
+    def _ensure_cython_import(self) -> None:
+        for node in self.tree.body:
+            if (isinstance(node, ast.Import)
+                    and any(a.name == "cython" for a in node.names)):
+                return
+        # Check if it's already there as ast.ImportFrom
+        for node in self.tree.body:
+            if (isinstance(node, ast.ImportFrom)
+                    and node.module == "cython"):
+                return
+        self.tree.body.insert(0, ast.Import(
+            names=[ast.alias(name="cython", asname=None)]))
+
+
+# ---------------------------------------------------------------------------
+# Type classification helpers (for attribute inference)
+# ---------------------------------------------------------------------------
+
+def _classify_literal(node: ast.AST) -> str:
+    if isinstance(node, ast.Constant):
+        if isinstance(node.value, bool):
+            return LONGLONG
+        if isinstance(node.value, float):
+            return DOUBLE
+        if isinstance(node.value, int):
+            return LONGLONG
+    return OBJECT
+
+
+def _classify_expr(node: ast.AST) -> str | None:
+    if isinstance(node, ast.Constant):
+        if isinstance(node.value, bool):
+            return LONGLONG
+        if isinstance(node.value, float):
+            return DOUBLE
+        if isinstance(node.value, int):
+            return LONGLONG
+    if isinstance(node, ast.BinOp):
+        lt = _classify_expr(node.left)
+        rt = _classify_expr(node.right)
+        if lt and rt:
+            if DOUBLE in (lt, rt):
+                return DOUBLE
+            return LONGLONG
+        return None
+    if isinstance(node, ast.UnaryOp):
+        return _classify_expr(node.operand)
+    if isinstance(node, ast.Call):
+        func = node.func
+        if isinstance(func, ast.Name):
+            if func.id == "float":
+                return DOUBLE
+            if func.id in ("int", "len", "abs"):
+                return LONGLONG
+    if isinstance(node, ast.Compare):
+        return LONGLONG
+    return None