Add files using upload-large-folder tool

micromamba_root/Lib/site-packages/mypy_extensions-1.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,27 @@
+Mypy extensions are licensed under the terms of the MIT license, reproduced below.
+
+= = = = =
+
+The MIT License
+
+Copyright (c) 2016-2017 Jukka Lehtosalo and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+= = = = =

micromamba_root/Lib/site-packages/mypyc/analysis/attrdefined.py

@@ -0,0 +1,437 @@
+"""Always defined attribute analysis.
+
+An always defined attribute has some statements in __init__ or the
+class body that cause the attribute to be always initialized when an
+instance is constructed. It must also not be possible to read the
+attribute before initialization, and it can't be deletable.
+
+We can assume that the value is always defined when reading an always
+defined attribute. Otherwise we'll need to raise AttributeError if the
+value is undefined (i.e. has the error value).
+
+We use data flow analysis to figure out attributes that are always
+defined. Example:
+
+  class C:
+      def __init__(self) -> None:
+          self.x = 0
+          if func():
+              self.y = 1
+          else:
+              self.y = 2
+              self.z = 3
+
+In this example, the attributes 'x' and 'y' are always defined, but 'z'
+is not. The analysis assumes that we know that there won't be any subclasses.
+
+The analysis also works if there is a known, closed set of subclasses.
+An attribute defined in a base class can only be always defined if it's
+also always defined in all subclasses.
+
+As soon as __init__ contains an op that can 'leak' self to another
+function, we will stop inferring always defined attributes, since the
+analysis is mostly intra-procedural and only looks at __init__ methods.
+The called code could read an uninitialized attribute. Example:
+
+  class C:
+      def __init__(self) -> None:
+          self.x = self.foo()
+
+      def foo(self) -> int:
+          ...
+
+Now we won't infer 'x' as always defined, since 'foo' might read 'x'
+before initialization.
+
+As an exception to the above limitation, we perform inter-procedural
+analysis of super().__init__ calls, since these are very common.
+
+Our analysis is somewhat optimistic. We assume that nobody calls a
+method of a partially uninitialized object through gc.get_objects(), in
+particular. Code like this could potentially cause a segfault with a null
+pointer dereference. This seems very unlikely to be an issue in practice,
+however.
+
+Accessing an attribute via getattr always checks for undefined attributes
+and thus works if the object is partially uninitialized. This can be used
+as a workaround if somebody ever needs to inspect partially uninitialized
+objects via gc.get_objects().
+
+The analysis runs after IR building as a separate pass. Since we only
+run this on __init__ methods, this analysis pass will be fairly quick.
+"""
+
+from __future__ import annotations
+
+from typing import Final
+
+from mypyc.analysis.dataflow import (
+    CFG,
+    MAYBE_ANALYSIS,
+    AnalysisResult,
+    BaseAnalysisVisitor,
+    get_cfg,
+    run_analysis,
+)
+from mypyc.analysis.selfleaks import analyze_self_leaks
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.ops import (
+    Assign,
+    AssignMulti,
+    BasicBlock,
+    Branch,
+    Call,
+    ControlOp,
+    GetAttr,
+    Register,
+    RegisterOp,
+    Return,
+    SetAttr,
+    SetMem,
+    Unreachable,
+)
+from mypyc.ir.rtypes import RInstance
+
+# If True, print out all always-defined attributes of native classes (to aid
+# debugging and testing)
+dump_always_defined: Final = False
+
+
+def analyze_always_defined_attrs(class_irs: list[ClassIR]) -> None:
+    """Find always defined attributes all classes of a compilation unit.
+
+    Also tag attribute initialization ops to not decref the previous
+    value (as this would read a NULL pointer and segfault).
+
+    Update the _always_initialized_attrs, _sometimes_initialized_attrs
+    and init_self_leak attributes in ClassIR instances.
+
+    This is the main entry point.
+    """
+    seen: set[ClassIR] = set()
+
+    # First pass: only look at target class and classes in MRO
+    for cl in class_irs:
+        analyze_always_defined_attrs_in_class(cl, seen)
+
+    # Second pass: look at all derived class
+    seen = set()
+    for cl in class_irs:
+        update_always_defined_attrs_using_subclasses(cl, seen)
+
+    # Final pass: detect attributes that need to use a bitmap to track definedness
+    seen = set()
+    for cl in class_irs:
+        detect_undefined_bitmap(cl, seen)
+
+
+def analyze_always_defined_attrs_in_class(cl: ClassIR, seen: set[ClassIR]) -> None:
+    if cl in seen:
+        return
+
+    seen.add(cl)
+
+    if (
+        cl.is_trait
+        or cl.inherits_python
+        or cl.allow_interpreted_subclasses
+        or cl.builtin_base is not None
+        or cl.children is None
+        or cl.is_serializable()
+        or cl.has_method("__new__")
+    ):
+        # Give up -- we can't enforce that attributes are always defined.
+        return
+
+    # First analyze all base classes. Track seen classes to avoid duplicate work.
+    for base in cl.mro[1:]:
+        analyze_always_defined_attrs_in_class(base, seen)
+
+    m = cl.get_method("__init__")
+    if m is None:
+        cl._always_initialized_attrs = cl.attrs_with_defaults.copy()
+        cl._sometimes_initialized_attrs = cl.attrs_with_defaults.copy()
+        return
+    self_reg = m.arg_regs[0]
+    cfg = get_cfg(m.blocks)
+    dirty = analyze_self_leaks(m.blocks, self_reg, cfg)
+    maybe_defined = analyze_maybe_defined_attrs_in_init(
+        m.blocks, self_reg, cl.attrs_with_defaults, cfg
+    )
+    all_attrs: set[str] = set()
+    for base in cl.mro:
+        all_attrs.update(base.attributes)
+    maybe_undefined = analyze_maybe_undefined_attrs_in_init(
+        m.blocks, self_reg, initial_undefined=all_attrs - cl.attrs_with_defaults, cfg=cfg
+    )
+
+    always_defined = find_always_defined_attributes(
+        m.blocks, self_reg, all_attrs, maybe_defined, maybe_undefined, dirty
+    )
+    always_defined = {a for a in always_defined if not cl.is_deletable(a)}
+
+    cl._always_initialized_attrs = always_defined
+    if dump_always_defined:
+        print(cl.name, sorted(always_defined))
+    cl._sometimes_initialized_attrs = find_sometimes_defined_attributes(
+        m.blocks, self_reg, maybe_defined, dirty
+    )
+
+    mark_attr_initialization_ops(m.blocks, self_reg, maybe_defined, dirty)
+
+    # Check if __init__ can run unpredictable code (leak 'self').
+    any_dirty = False
+    for b in m.blocks:
+        for i, op in enumerate(b.ops):
+            if dirty.after[b, i] and not isinstance(op, Return):
+                any_dirty = True
+                break
+    cl.init_self_leak = any_dirty
+
+
+def find_always_defined_attributes(
+    blocks: list[BasicBlock],
+    self_reg: Register,
+    all_attrs: set[str],
+    maybe_defined: AnalysisResult[str],
+    maybe_undefined: AnalysisResult[str],
+    dirty: AnalysisResult[None],
+) -> set[str]:
+    """Find attributes that are always initialized in some basic blocks.
+
+    The analysis results are expected to be up-to-date for the blocks.
+
+    Return a set of always defined attributes.
+    """
+    attrs = all_attrs.copy()
+    for block in blocks:
+        for i, op in enumerate(block.ops):
+            # If an attribute we *read* may be undefined, it isn't always defined.
+            if isinstance(op, GetAttr) and op.obj is self_reg:
+                if op.attr in maybe_undefined.before[block, i]:
+                    attrs.discard(op.attr)
+            # If an attribute we *set* may be sometimes undefined and
+            # sometimes defined, don't consider it always defined. Unlike
+            # the get case, it's fine for the attribute to be undefined.
+            # The set operation will then be treated as initialization.
+            if isinstance(op, SetAttr) and op.obj is self_reg:
+                if (
+                    op.attr in maybe_undefined.before[block, i]
+                    and op.attr in maybe_defined.before[block, i]
+                ):
+                    attrs.discard(op.attr)
+            # Treat an op that might run arbitrary code as an "exit"
+            # in terms of the analysis -- we can't do any inference
+            # afterwards reliably.
+            if dirty.after[block, i]:
+                if not dirty.before[block, i]:
+                    attrs = attrs & (
+                        maybe_defined.after[block, i] - maybe_undefined.after[block, i]
+                    )
+                break
+            if isinstance(op, ControlOp):
+                for target in op.targets():
+                    # Gotos/branches can also be "exits".
+                    if not dirty.after[block, i] and dirty.before[target, 0]:
+                        attrs = attrs & (
+                            maybe_defined.after[target, 0] - maybe_undefined.after[target, 0]
+                        )
+    return attrs
+
+
+def find_sometimes_defined_attributes(
+    blocks: list[BasicBlock],
+    self_reg: Register,
+    maybe_defined: AnalysisResult[str],
+    dirty: AnalysisResult[None],
+) -> set[str]:
+    """Find attributes that are sometimes initialized in some basic blocks."""
+    attrs: set[str] = set()
+    for block in blocks:
+        for i, op in enumerate(block.ops):
+            # Only look at possibly defined attributes at exits.
+            if dirty.after[block, i]:
+                if not dirty.before[block, i]:
+                    attrs = attrs | maybe_defined.after[block, i]
+                break
+            if isinstance(op, ControlOp):
+                for target in op.targets():
+                    if not dirty.after[block, i] and dirty.before[target, 0]:
+                        attrs = attrs | maybe_defined.after[target, 0]
+    return attrs
+
+
+def mark_attr_initialization_ops(
+    blocks: list[BasicBlock],
+    self_reg: Register,
+    maybe_defined: AnalysisResult[str],
+    dirty: AnalysisResult[None],
+) -> None:
+    """Tag all SetAttr ops in the basic blocks that initialize attributes.
+
+    Initialization ops assume that the previous attribute value is the error value,
+    so there's no need to decref or check for definedness.
+    """
+    for block in blocks:
+        for i, op in enumerate(block.ops):
+            if isinstance(op, SetAttr) and op.obj is self_reg:
+                attr = op.attr
+                if attr not in maybe_defined.before[block, i] and not dirty.after[block, i]:
+                    op.mark_as_initializer()
+
+
+GenAndKill = tuple[set[str], set[str]]
+
+
+def attributes_initialized_by_init_call(op: Call) -> set[str]:
+    """Calculate attributes that are always initialized by a super().__init__ call."""
+    self_type = op.fn.sig.args[0].type
+    assert isinstance(self_type, RInstance), self_type
+    cl = self_type.class_ir
+    return {a for base in cl.mro for a in base.attributes if base.is_always_defined(a)}
+
+
+def attributes_maybe_initialized_by_init_call(op: Call) -> set[str]:
+    """Calculate attributes that may be initialized by a super().__init__ call."""
+    self_type = op.fn.sig.args[0].type
+    assert isinstance(self_type, RInstance), self_type
+    cl = self_type.class_ir
+    return attributes_initialized_by_init_call(op) | cl._sometimes_initialized_attrs
+
+
+class AttributeMaybeDefinedVisitor(BaseAnalysisVisitor[str]):
+    """Find attributes that may have been defined via some code path.
+
+    Consider initializations in class body and assignments to 'self.x'
+    and calls to base class '__init__'.
+    """
+
+    def __init__(self, self_reg: Register) -> None:
+        self.self_reg = self_reg
+
+    def visit_branch(self, op: Branch) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+    def visit_return(self, op: Return) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+    def visit_unreachable(self, op: Unreachable) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+    def visit_register_op(self, op: RegisterOp) -> tuple[set[str], set[str]]:
+        if isinstance(op, SetAttr) and op.obj is self.self_reg:
+            return {op.attr}, set()
+        if isinstance(op, Call) and op.fn.class_name and op.fn.name == "__init__":
+            return attributes_maybe_initialized_by_init_call(op), set()
+        return set(), set()
+
+    def visit_assign(self, op: Assign) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+    def visit_assign_multi(self, op: AssignMulti) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+    def visit_set_mem(self, op: SetMem) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+
+def analyze_maybe_defined_attrs_in_init(
+    blocks: list[BasicBlock], self_reg: Register, attrs_with_defaults: set[str], cfg: CFG
+) -> AnalysisResult[str]:
+    return run_analysis(
+        blocks=blocks,
+        cfg=cfg,
+        gen_and_kill=AttributeMaybeDefinedVisitor(self_reg),
+        initial=attrs_with_defaults,
+        backward=False,
+        kind=MAYBE_ANALYSIS,
+    )
+
+
+class AttributeMaybeUndefinedVisitor(BaseAnalysisVisitor[str]):
+    """Find attributes that may be undefined via some code path.
+
+    Consider initializations in class body, assignments to 'self.x'
+    and calls to base class '__init__'.
+    """
+
+    def __init__(self, self_reg: Register) -> None:
+        self.self_reg = self_reg
+
+    def visit_branch(self, op: Branch) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+    def visit_return(self, op: Return) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+    def visit_unreachable(self, op: Unreachable) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+    def visit_register_op(self, op: RegisterOp) -> tuple[set[str], set[str]]:
+        if isinstance(op, SetAttr) and op.obj is self.self_reg:
+            return set(), {op.attr}
+        if isinstance(op, Call) and op.fn.class_name and op.fn.name == "__init__":
+            return set(), attributes_initialized_by_init_call(op)
+        return set(), set()
+
+    def visit_assign(self, op: Assign) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+    def visit_assign_multi(self, op: AssignMulti) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+    def visit_set_mem(self, op: SetMem) -> tuple[set[str], set[str]]:
+        return set(), set()
+
+
+def analyze_maybe_undefined_attrs_in_init(
+    blocks: list[BasicBlock], self_reg: Register, initial_undefined: set[str], cfg: CFG
+) -> AnalysisResult[str]:
+    return run_analysis(
+        blocks=blocks,
+        cfg=cfg,
+        gen_and_kill=AttributeMaybeUndefinedVisitor(self_reg),
+        initial=initial_undefined,
+        backward=False,
+        kind=MAYBE_ANALYSIS,
+    )
+
+
+def update_always_defined_attrs_using_subclasses(cl: ClassIR, seen: set[ClassIR]) -> None:
+    """Remove attributes not defined in all subclasses from always defined attrs."""
+    if cl in seen:
+        return
+    if cl.children is None:
+        # Subclasses are unknown
+        return
+    removed = set()
+    for attr in cl._always_initialized_attrs:
+        for child in cl.children:
+            update_always_defined_attrs_using_subclasses(child, seen)
+            if attr not in child._always_initialized_attrs:
+                removed.add(attr)
+    cl._always_initialized_attrs -= removed
+    seen.add(cl)
+
+
+def detect_undefined_bitmap(cl: ClassIR, seen: set[ClassIR]) -> None:
+    if cl.is_trait:
+        return
+
+    if cl in seen:
+        return
+    seen.add(cl)
+    for base in cl.base_mro[1:]:
+        detect_undefined_bitmap(base, seen)
+
+    if len(cl.base_mro) > 1:
+        cl.bitmap_attrs.extend(cl.base_mro[1].bitmap_attrs)
+    for n, t in cl.attributes.items():
+        if t.error_overlap and not cl.is_always_defined(n):
+            cl.bitmap_attrs.append(n)
+
+    for base in cl.mro[1:]:
+        if base.is_trait:
+            for n, t in base.attributes.items():
+                if t.error_overlap and not cl.is_always_defined(n) and n not in cl.bitmap_attrs:
+                    cl.bitmap_attrs.append(n)

micromamba_root/Lib/site-packages/mypyc/analysis/blockfreq.py

@@ -0,0 +1,32 @@
+"""Find basic blocks that are likely to be executed frequently.
+
+For example, this would not include blocks that have exception handlers.
+
+We can use different optimization heuristics for common and rare code. For
+example, we can make IR fast to compile instead of fast to execute for rare
+code.
+"""
+
+from __future__ import annotations
+
+from mypyc.ir.ops import BasicBlock, Branch, Goto
+
+
+def frequently_executed_blocks(entry_point: BasicBlock) -> set[BasicBlock]:
+    result: set[BasicBlock] = set()
+    worklist = [entry_point]
+    while worklist:
+        block = worklist.pop()
+        if block in result:
+            continue
+        result.add(block)
+        t = block.terminator
+        if isinstance(t, Goto):
+            worklist.append(t.label)
+        elif isinstance(t, Branch):
+            if t.rare or t.traceback_entry is not None:
+                worklist.append(t.false)
+            else:
+                worklist.append(t.true)
+                worklist.append(t.false)
+    return result

micromamba_root/Lib/site-packages/mypyc/analysis/capsule_deps.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.deps import Dependency
+from mypyc.ir.func_ir import FuncIR
+from mypyc.ir.ops import Assign, CallC, PrimitiveOp
+from mypyc.ir.rtypes import RStruct, RTuple, RType, RUnion, RVec
+
+
+def find_implicit_op_dependencies(fn: FuncIR) -> set[Dependency] | None:
+    """Find implicit dependencies that need to be imported.
+
+    Using primitives or types defined in librt submodules such as "librt.base64"
+    requires dependency imports (e.g., capsule imports).
+
+    Note that a module can depend on a librt module even if it doesn't explicitly
+    import it, for example via re-exported names or via return types of functions
+    defined in other modules.
+    """
+    deps: set[Dependency] | None = None
+    # Check function signature types for dependencies
+    deps = find_type_dependencies(fn, deps)
+    # Check ops for dependencies
+    for block in fn.blocks:
+        for op in block.ops:
+            assert not isinstance(op, PrimitiveOp), "Lowered IR is expected"
+            if isinstance(op, CallC) and op.dependencies is not None:
+                for dep in op.dependencies:
+                    if deps is None:
+                        deps = set()
+                    deps.add(dep)
+            deps = collect_type_deps(op.type, deps)
+            if isinstance(op, Assign):
+                deps = collect_type_deps(op.dest.type, deps)
+    return deps
+
+
+def find_type_dependencies(fn: FuncIR, deps: set[Dependency] | None) -> set[Dependency] | None:
+    """Find dependencies from RTypes in function signatures.
+
+    Some RTypes (e.g., those for librt types) have associated dependencies
+    that need to be imported when the type is used.
+    """
+    # Check parameter types
+    for arg in fn.decl.sig.args:
+        deps = collect_type_deps(arg.type, deps)
+    # Check return type
+    deps = collect_type_deps(fn.decl.sig.ret_type, deps)
+    return deps
+
+
+def find_class_dependencies(cl: ClassIR) -> set[Dependency] | None:
+    """Find dependencies from class attribute types."""
+    deps: set[Dependency] | None = None
+    for base in cl.mro:
+        for attr_type in base.attributes.values():
+            deps = collect_type_deps(attr_type, deps)
+    return deps
+
+
+def collect_type_deps(typ: RType, deps: set[Dependency] | None) -> set[Dependency] | None:
+    """Collect dependencies from an RType, recursively checking compound types."""
+    if typ.dependencies is not None:
+        for dep in typ.dependencies:
+            if deps is None:
+                deps = set()
+            deps.add(dep)
+    if isinstance(typ, RUnion):
+        for item in typ.items:
+            deps = collect_type_deps(item, deps)
+    elif isinstance(typ, RTuple):
+        for item in typ.types:
+            deps = collect_type_deps(item, deps)
+    elif isinstance(typ, RStruct):
+        for item in typ.types:
+            deps = collect_type_deps(item, deps)
+    elif isinstance(typ, RVec):
+        deps = collect_type_deps(typ.item_type, deps)
+    return deps

micromamba_root/Lib/site-packages/mypyc/analysis/dataflow.py

@@ -0,0 +1,645 @@
+"""Data-flow analyses."""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Iterable, Iterator, Set as AbstractSet
+from typing import Any, Generic, TypeVar
+
+from mypyc.ir.ops import (
+    Assign,
+    AssignMulti,
+    BasicBlock,
+    Box,
+    Branch,
+    Call,
+    CallC,
+    Cast,
+    ComparisonOp,
+    ControlOp,
+    DecRef,
+    Extend,
+    Float,
+    FloatComparisonOp,
+    FloatNeg,
+    FloatOp,
+    GetAttr,
+    GetElement,
+    GetElementPtr,
+    Goto,
+    IncRef,
+    InitStatic,
+    Integer,
+    IntOp,
+    KeepAlive,
+    LoadAddress,
+    LoadErrorValue,
+    LoadGlobal,
+    LoadLiteral,
+    LoadMem,
+    LoadStatic,
+    MethodCall,
+    Op,
+    OpVisitor,
+    PrimitiveOp,
+    RaiseStandardError,
+    RegisterOp,
+    Return,
+    SetAttr,
+    SetElement,
+    SetMem,
+    Truncate,
+    TupleGet,
+    TupleSet,
+    Unborrow,
+    Unbox,
+    Undef,
+    Unreachable,
+    Value,
+)
+
+
+class CFG:
+    """Control-flow graph.
+
+    Node 0 is always assumed to be the entry point. There must be a
+    non-empty set of exits.
+    """
+
+    def __init__(
+        self,
+        succ: dict[BasicBlock, list[BasicBlock]],
+        pred: dict[BasicBlock, list[BasicBlock]],
+        exits: set[BasicBlock],
+    ) -> None:
+        assert exits
+        self.succ = succ
+        self.pred = pred
+        self.exits = exits
+
+    def __str__(self) -> str:
+        exits = sorted(self.exits, key=lambda e: int(e.label))
+        return f"exits: {exits}\nsucc: {self.succ}\npred: {self.pred}"
+
+
+def get_cfg(blocks: list[BasicBlock], *, use_yields: bool = False) -> CFG:
+    """Calculate basic block control-flow graph.
+
+    If use_yields is set, then we treat returns inserted by yields as gotos
+    instead of exits.
+    """
+    succ_map = {}
+    pred_map: dict[BasicBlock, list[BasicBlock]] = {}
+    exits = set()
+    for block in blocks:
+        assert not any(
+            isinstance(op, ControlOp) for op in block.ops[:-1]
+        ), "Control-flow ops must be at the end of blocks"
+
+        if use_yields and isinstance(block.terminator, Return) and block.terminator.yield_target:
+            succ = [block.terminator.yield_target]
+        else:
+            succ = list(block.terminator.targets())
+        if not succ:
+            exits.add(block)
+
+        # Errors can occur anywhere inside a block, which means that
+        # we can't assume that the entire block has executed before
+        # jumping to the error handler. In our CFG construction, we
+        # model this as saying that a block can jump to its error
+        # handler or the error handlers of any of its normal
+        # successors (to represent an error before that next block
+        # completes). This works well for analyses like "must
+        # defined", where it implies that registers assigned in a
+        # block may be undefined in its error handler, but is in
+        # general not a precise representation of reality; any
+        # analyses that require more fidelity must wait until after
+        # exception insertion.
+        for error_point in [block] + succ:
+            if error_point.error_handler:
+                succ.append(error_point.error_handler)
+
+        succ_map[block] = succ
+        pred_map[block] = []
+    for prev, nxt in succ_map.items():
+        for label in nxt:
+            pred_map[label].append(prev)
+    return CFG(succ_map, pred_map, exits)
+
+
+def get_real_target(label: BasicBlock) -> BasicBlock:
+    if len(label.ops) == 1 and isinstance(label.ops[-1], Goto):
+        label = label.ops[-1].label
+    return label
+
+
+def cleanup_cfg(blocks: list[BasicBlock]) -> None:
+    """Cleanup the control flow graph.
+
+    This eliminates obviously dead basic blocks and eliminates blocks that contain
+    nothing but a single jump.
+
+    There is a lot more that could be done.
+    """
+    changed = True
+    while changed:
+        # First collapse any jumps to basic block that only contain a goto
+        for block in blocks:
+            for i, tgt in enumerate(block.terminator.targets()):
+                block.terminator.set_target(i, get_real_target(tgt))
+
+        # Then delete any blocks that have no predecessors
+        changed = False
+        cfg = get_cfg(blocks)
+        orig_blocks = blocks.copy()
+        blocks.clear()
+        for i, block in enumerate(orig_blocks):
+            if i == 0 or cfg.pred[block]:
+                blocks.append(block)
+            else:
+                changed = True
+
+
+T = TypeVar("T")
+
+AnalysisDict = dict[tuple[BasicBlock, int], set[T]]
+
+
+class AnalysisResult(Generic[T]):
+    def __init__(self, before: AnalysisDict[T], after: AnalysisDict[T]) -> None:
+        self.before = before
+        self.after = after
+
+    def __str__(self) -> str:
+        return f"before: {self.before}\nafter: {self.after}\n"
+
+
+GenAndKill = tuple[AbstractSet[T], AbstractSet[T]]
+
+_EMPTY: tuple[frozenset[Any], frozenset[Any]] = (frozenset(), frozenset())
+
+
+class BaseAnalysisVisitor(OpVisitor[GenAndKill[T]]):
+    def visit_goto(self, op: Goto) -> GenAndKill[T]:
+        return _EMPTY
+
+    @abstractmethod
+    def visit_register_op(self, op: RegisterOp) -> GenAndKill[T]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_assign(self, op: Assign) -> GenAndKill[T]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_assign_multi(self, op: AssignMulti) -> GenAndKill[T]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_set_mem(self, op: SetMem) -> GenAndKill[T]:
+        raise NotImplementedError
+
+    def visit_inc_ref(self, op: IncRef) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_dec_ref(self, op: DecRef) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_call(self, op: Call) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_method_call(self, op: MethodCall) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_load_error_value(self, op: LoadErrorValue) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_load_literal(self, op: LoadLiteral) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_get_attr(self, op: GetAttr) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_set_attr(self, op: SetAttr) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_load_static(self, op: LoadStatic) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_init_static(self, op: InitStatic) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_tuple_get(self, op: TupleGet) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_tuple_set(self, op: TupleSet) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_box(self, op: Box) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_unbox(self, op: Unbox) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_cast(self, op: Cast) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_raise_standard_error(self, op: RaiseStandardError) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_call_c(self, op: CallC) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_primitive_op(self, op: PrimitiveOp) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_truncate(self, op: Truncate) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_extend(self, op: Extend) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_load_global(self, op: LoadGlobal) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_int_op(self, op: IntOp) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_float_op(self, op: FloatOp) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_float_neg(self, op: FloatNeg) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_comparison_op(self, op: ComparisonOp) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_float_comparison_op(self, op: FloatComparisonOp) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_load_mem(self, op: LoadMem) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_get_element(self, op: GetElement) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_get_element_ptr(self, op: GetElementPtr) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_set_element(self, op: SetElement) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_load_address(self, op: LoadAddress) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_keep_alive(self, op: KeepAlive) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+    def visit_unborrow(self, op: Unborrow) -> GenAndKill[T]:
+        return self.visit_register_op(op)
+
+
+class DefinedVisitor(BaseAnalysisVisitor[Value]):
+    """Visitor for finding defined registers.
+
+    Note that this only deals with registers and not temporaries, on
+    the assumption that we never access temporaries when they might be
+    undefined.
+
+    If strict_errors is True, then we regard any use of LoadErrorValue
+    as making a register undefined. Otherwise we only do if
+    `undefines` is set on the error value.
+
+    This lets us only consider the things we care about during
+    uninitialized variable checking while capturing all possibly
+    undefined things for refcounting.
+    """
+
+    def __init__(self, strict_errors: bool = False) -> None:
+        self.strict_errors = strict_errors
+
+    def visit_branch(self, op: Branch) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_return(self, op: Return) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_unreachable(self, op: Unreachable) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_register_op(self, op: RegisterOp) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_assign(self, op: Assign) -> GenAndKill[Value]:
+        # Loading an error value may undefine the register.
+        if isinstance(op.src, LoadErrorValue) and (op.src.undefines or self.strict_errors):
+            return set(), {op.dest}
+        else:
+            return {op.dest}, set()
+
+    def visit_assign_multi(self, op: AssignMulti) -> GenAndKill[Value]:
+        # Array registers are special and we don't track the definedness of them.
+        return _EMPTY
+
+    def visit_set_mem(self, op: SetMem) -> GenAndKill[Value]:
+        return _EMPTY
+
+
+def analyze_maybe_defined_regs(
+    blocks: list[BasicBlock], cfg: CFG, initial_defined: set[Value]
+) -> AnalysisResult[Value]:
+    """Calculate potentially defined registers at each CFG location.
+
+    A register is defined if it has a value along some path from the initial location.
+    """
+    return run_analysis(
+        blocks=blocks,
+        cfg=cfg,
+        gen_and_kill=DefinedVisitor(),
+        initial=initial_defined,
+        backward=False,
+        kind=MAYBE_ANALYSIS,
+    )
+
+
+def analyze_must_defined_regs(
+    blocks: list[BasicBlock],
+    cfg: CFG,
+    initial_defined: set[Value],
+    regs: Iterable[Value],
+    strict_errors: bool = False,
+) -> AnalysisResult[Value]:
+    """Calculate always defined registers at each CFG location.
+
+    This analysis can work before exception insertion, since it is a
+    sound assumption that registers defined in a block might not be
+    initialized in its error handler.
+
+    A register is defined if it has a value along all paths from the
+    initial location.
+    """
+    return run_analysis(
+        blocks=blocks,
+        cfg=cfg,
+        gen_and_kill=DefinedVisitor(strict_errors=strict_errors),
+        initial=initial_defined,
+        backward=False,
+        kind=MUST_ANALYSIS,
+        universe=set(regs),
+    )
+
+
+class BorrowedArgumentsVisitor(BaseAnalysisVisitor[Value]):
+    def __init__(self, args: set[Value]) -> None:
+        self.args = args
+
+    def visit_branch(self, op: Branch) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_return(self, op: Return) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_unreachable(self, op: Unreachable) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_register_op(self, op: RegisterOp) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_assign(self, op: Assign) -> GenAndKill[Value]:
+        if op.dest in self.args:
+            return set(), {op.dest}
+        return _EMPTY
+
+    def visit_assign_multi(self, op: AssignMulti) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_set_mem(self, op: SetMem) -> GenAndKill[Value]:
+        return _EMPTY
+
+
+def analyze_borrowed_arguments(
+    blocks: list[BasicBlock], cfg: CFG, borrowed: set[Value]
+) -> AnalysisResult[Value]:
+    """Calculate arguments that can use references borrowed from the caller.
+
+    When assigning to an argument, it no longer is borrowed.
+    """
+    return run_analysis(
+        blocks=blocks,
+        cfg=cfg,
+        gen_and_kill=BorrowedArgumentsVisitor(borrowed),
+        initial=borrowed,
+        backward=False,
+        kind=MUST_ANALYSIS,
+        universe=borrowed,
+    )
+
+
+class UndefinedVisitor(BaseAnalysisVisitor[Value]):
+    def visit_branch(self, op: Branch) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_return(self, op: Return) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_unreachable(self, op: Unreachable) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_register_op(self, op: RegisterOp) -> GenAndKill[Value]:
+        return set(), {op} if not op.is_void else set()
+
+    def visit_assign(self, op: Assign) -> GenAndKill[Value]:
+        return set(), {op.dest}
+
+    def visit_assign_multi(self, op: AssignMulti) -> GenAndKill[Value]:
+        return set(), {op.dest}
+
+    def visit_set_mem(self, op: SetMem) -> GenAndKill[Value]:
+        return _EMPTY
+
+
+def non_trivial_sources(op: Op) -> set[Value]:
+    result = set()
+    for source in op.sources():
+        if not isinstance(source, (Integer, Float, Undef)):
+            result.add(source)
+    return result
+
+
+class LivenessVisitor(BaseAnalysisVisitor[Value]):
+    def visit_branch(self, op: Branch) -> GenAndKill[Value]:
+        return non_trivial_sources(op), set()
+
+    def visit_return(self, op: Return) -> GenAndKill[Value]:
+        if not isinstance(op.value, (Integer, Float)):
+            return {op.value}, set()
+        else:
+            return _EMPTY
+
+    def visit_unreachable(self, op: Unreachable) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_register_op(self, op: RegisterOp) -> GenAndKill[Value]:
+        gen = non_trivial_sources(op)
+        if not op.is_void:
+            return gen, {op}
+        else:
+            return gen, set()
+
+    def visit_assign(self, op: Assign) -> GenAndKill[Value]:
+        return non_trivial_sources(op), {op.dest}
+
+    def visit_assign_multi(self, op: AssignMulti) -> GenAndKill[Value]:
+        return non_trivial_sources(op), {op.dest}
+
+    def visit_set_mem(self, op: SetMem) -> GenAndKill[Value]:
+        return non_trivial_sources(op), set()
+
+    def visit_inc_ref(self, op: IncRef) -> GenAndKill[Value]:
+        return _EMPTY
+
+    def visit_dec_ref(self, op: DecRef) -> GenAndKill[Value]:
+        return _EMPTY
+
+
+def analyze_live_regs(blocks: list[BasicBlock], cfg: CFG) -> AnalysisResult[Value]:
+    """Calculate live registers at each CFG location.
+
+    A register is live at a location if it can be read along some CFG path starting
+    from the location.
+    """
+    return run_analysis(
+        blocks=blocks,
+        cfg=cfg,
+        gen_and_kill=LivenessVisitor(),
+        initial=set(),
+        backward=True,
+        kind=MAYBE_ANALYSIS,
+    )
+
+
+# Analysis kinds
+MUST_ANALYSIS = 0
+MAYBE_ANALYSIS = 1
+
+
+def run_analysis(
+    blocks: list[BasicBlock],
+    cfg: CFG,
+    gen_and_kill: OpVisitor[GenAndKill[T]],
+    initial: set[T],
+    kind: int,
+    backward: bool,
+    universe: set[T] | None = None,
+) -> AnalysisResult[T]:
+    """Run a general set-based data flow analysis.
+
+    Args:
+        blocks: All basic blocks
+        cfg: Control-flow graph for the code
+        gen_and_kill: Implementation of gen and kill functions for each op
+        initial: Value of analysis for the entry points (for a forward analysis) or the
+            exit points (for a backward analysis)
+        kind: MUST_ANALYSIS or MAYBE_ANALYSIS
+        backward: If False, the analysis is a forward analysis; it's backward otherwise
+        universe: For a must analysis, the set of all possible values. This is the starting
+            value for the work list algorithm, which will narrow this down until reaching a
+            fixed point. For a maybe analysis the iteration always starts from an empty set
+            and this argument is ignored.
+
+    Return analysis results: (before, after)
+    """
+    block_gen = {}
+    block_kill = {}
+
+    # Calculate kill and gen sets for entire basic blocks.
+    for block in blocks:
+        gen: set[T] = set()
+        kill: set[T] = set()
+        ops = block.ops
+        if backward:
+            ops = list(reversed(ops))
+        for op in ops:
+            opgen, opkill = op.accept(gen_and_kill)
+            if opkill:
+                gen -= opkill
+
+            if opgen:
+                gen |= opgen
+                kill -= opgen
+
+            if opkill:
+                kill |= opkill
+
+        block_gen[block] = gen
+        block_kill[block] = kill
+
+    # Set up initial state for worklist algorithm.
+    worklist = list(blocks)
+    if not backward:
+        worklist.reverse()  # Reverse for a small performance improvement
+    workset = set(worklist)
+    before: dict[BasicBlock, set[T]] = {}
+    after: dict[BasicBlock, set[T]] = {}
+    for block in blocks:
+        if kind == MAYBE_ANALYSIS:
+            before[block] = set()
+            after[block] = set()
+        else:
+            assert universe is not None, "Universe must be defined for a must analysis"
+            before[block] = set(universe)
+            after[block] = set(universe)
+
+    if backward:
+        pred_map = cfg.succ
+        succ_map = cfg.pred
+    else:
+        pred_map = cfg.pred
+        succ_map = cfg.succ
+
+    # Run work list algorithm to generate in and out sets for each basic block.
+    while worklist:
+        label = worklist.pop()
+        workset.remove(label)
+        if pred_map[label]:
+            new_before: set[T] | None = None
+            for pred in pred_map[label]:
+                if new_before is None:
+                    new_before = set(after[pred])
+                elif kind == MAYBE_ANALYSIS:
+                    new_before |= after[pred]
+                else:
+                    new_before &= after[pred]
+            assert new_before is not None
+        else:
+            new_before = set(initial)
+        before[label] = new_before
+        new_after = (new_before - block_kill[label]) | block_gen[label]
+        if new_after != after[label]:
+            for succ in succ_map[label]:
+                if succ not in workset:
+                    worklist.append(succ)
+                    workset.add(succ)
+        after[label] = new_after
+
+    # Run algorithm for each basic block to generate opcode-level sets.
+    op_before: dict[tuple[BasicBlock, int], set[T]] = {}
+    op_after: dict[tuple[BasicBlock, int], set[T]] = {}
+    for block in blocks:
+        label = block
+        cur = before[label]
+        ops_enum: Iterator[tuple[int, Op]] = enumerate(block.ops)
+        if backward:
+            ops_enum = reversed(list(ops_enum))
+        for idx, op in ops_enum:
+            op_before[label, idx] = cur
+            opgen, opkill = op.accept(gen_and_kill)
+            if opkill:
+                cur = cur - opkill
+            if opgen:
+                cur = cur | opgen
+            op_after[label, idx] = cur
+    if backward:
+        op_after, op_before = op_before, op_after
+
+    return AnalysisResult(op_before, op_after)

micromamba_root/Lib/site-packages/mypyc/analysis/ircheck.py

@@ -0,0 +1,498 @@
+"""Utilities for checking that internal ir is valid and consistent."""
+
+from __future__ import annotations
+
+from mypyc.ir.func_ir import FUNC_STATICMETHOD, FuncIR
+from mypyc.ir.ops import (
+    Assign,
+    AssignMulti,
+    BaseAssign,
+    BasicBlock,
+    Box,
+    Branch,
+    Call,
+    CallC,
+    Cast,
+    ComparisonOp,
+    ControlOp,
+    DecRef,
+    Extend,
+    Float,
+    FloatComparisonOp,
+    FloatNeg,
+    FloatOp,
+    GetAttr,
+    GetElement,
+    GetElementPtr,
+    Goto,
+    IncRef,
+    InitStatic,
+    Integer,
+    IntOp,
+    KeepAlive,
+    LoadAddress,
+    LoadErrorValue,
+    LoadGlobal,
+    LoadLiteral,
+    LoadMem,
+    LoadStatic,
+    MethodCall,
+    Op,
+    OpVisitor,
+    PrimitiveOp,
+    RaiseStandardError,
+    Register,
+    Return,
+    SetAttr,
+    SetElement,
+    SetMem,
+    Truncate,
+    TupleGet,
+    TupleSet,
+    Unborrow,
+    Unbox,
+    Undef,
+    Unreachable,
+    Value,
+)
+from mypyc.ir.pprint import format_func
+from mypyc.ir.rtypes import (
+    KNOWN_NATIVE_TYPES,
+    RArray,
+    RInstance,
+    RPrimitive,
+    RType,
+    RUnion,
+    RVec,
+    bytes_rprimitive,
+    dict_rprimitive,
+    int_rprimitive,
+    is_c_py_ssize_t_rprimitive,
+    is_fixed_width_rtype,
+    is_float_rprimitive,
+    is_object_rprimitive,
+    is_pointer_rprimitive,
+    list_rprimitive,
+    pointer_rprimitive,
+    range_rprimitive,
+    set_rprimitive,
+    str_rprimitive,
+    tuple_rprimitive,
+)
+
+
+class FnError:
+    def __init__(self, source: Op | BasicBlock, desc: str) -> None:
+        self.source = source
+        self.desc = desc
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, FnError) and self.source == other.source and self.desc == other.desc
+        )
+
+    def __repr__(self) -> str:
+        return f"FnError(source={self.source}, desc={self.desc})"
+
+
+def check_func_ir(fn: FuncIR) -> list[FnError]:
+    """Applies validations to a given function ir and returns a list of errors found."""
+    errors = []
+
+    op_set = set()
+
+    for block in fn.blocks:
+        if not block.terminated:
+            errors.append(
+                FnError(source=block.ops[-1] if block.ops else block, desc="Block not terminated")
+            )
+        for op in block.ops[:-1]:
+            if isinstance(op, ControlOp):
+                errors.append(FnError(source=op, desc="Block has operations after control op"))
+
+            if op in op_set:
+                errors.append(FnError(source=op, desc="Func has a duplicate op"))
+            op_set.add(op)
+
+    errors.extend(check_op_sources_valid(fn))
+    if errors:
+        return errors
+
+    op_checker = OpChecker(fn)
+    for block in fn.blocks:
+        for op in block.ops:
+            op.accept(op_checker)
+
+    return op_checker.errors
+
+
+class IrCheckException(Exception):
+    pass
+
+
+def assert_func_ir_valid(fn: FuncIR) -> None:
+    errors = check_func_ir(fn)
+    if errors:
+        raise IrCheckException(
+            "Internal error: Generated invalid IR: \n"
+            + "\n".join(format_func(fn, [(e.source, e.desc) for e in errors]))
+        )
+
+
+def check_op_sources_valid(fn: FuncIR) -> list[FnError]:
+    errors = []
+    valid_ops: set[Op] = set()
+    valid_registers: set[Register] = set()
+
+    for block in fn.blocks:
+        valid_ops.update(block.ops)
+
+        for op in block.ops:
+            if isinstance(op, BaseAssign):
+                valid_registers.add(op.dest)
+            elif isinstance(op, LoadAddress) and isinstance(op.src, Register):
+                valid_registers.add(op.src)
+
+    valid_registers.update(fn.arg_regs)
+
+    for block in fn.blocks:
+        for op in block.ops:
+            for source in op.sources():
+                if isinstance(source, (Integer, Float, Undef)):
+                    pass
+                elif isinstance(source, Op):
+                    if source not in valid_ops:
+                        errors.append(
+                            FnError(
+                                source=op,
+                                desc=f"Invalid op reference to op of type {type(source).__name__}",
+                            )
+                        )
+                elif isinstance(source, Register):
+                    if source not in valid_registers:
+                        errors.append(
+                            FnError(
+                                source=op, desc=f"Invalid op reference to register {source.name!r}"
+                            )
+                        )
+
+    return errors
+
+
+disjoint_types = {
+    int_rprimitive.name,
+    bytes_rprimitive.name,
+    str_rprimitive.name,
+    dict_rprimitive.name,
+    list_rprimitive.name,
+    set_rprimitive.name,
+    tuple_rprimitive.name,
+    range_rprimitive.name,
+} | set(KNOWN_NATIVE_TYPES)
+
+
+def can_coerce_to(src: RType, dest: RType) -> bool:
+    """Check if src can be assigned to dest_rtype.
+
+    Currently okay to have false positives.
+    """
+    if isinstance(dest, RUnion):
+        return any(can_coerce_to(src, d) for d in dest.items)
+
+    if isinstance(dest, RPrimitive):
+        if isinstance(src, RPrimitive):
+            # If either src or dest is a disjoint type, then they must both be.
+            if src.name in disjoint_types and dest.name in disjoint_types:
+                return src.name == dest.name
+            return src.size == dest.size
+        if isinstance(src, (RInstance, RVec)):
+            return is_object_rprimitive(dest)
+        if isinstance(src, RUnion):
+            # IR doesn't have the ability to narrow unions based on
+            # control flow, so cannot be a strict all() here.
+            return any(can_coerce_to(s, dest) for s in src.items)
+        return False
+
+    return True
+
+
+def is_valid_ptr_displacement_type(rtype: RType) -> bool:
+    """Check if rtype is a valid displacement type for pointer arithmetic."""
+    if not (is_fixed_width_rtype(rtype) or is_c_py_ssize_t_rprimitive(rtype)):
+        return False
+    assert isinstance(rtype, RPrimitive)
+    return rtype.size == pointer_rprimitive.size
+
+
+def is_pointer_arithmetic(op: IntOp) -> bool:
+    """Check if op is add/subtract targeting pointer_rprimitive and integer of the same size."""
+    if op.op not in (IntOp.ADD, IntOp.SUB):
+        return False
+    if not is_pointer_rprimitive(op.type):
+        return False
+    left = op.lhs.type
+    right = op.rhs.type
+    if is_pointer_rprimitive(left):
+        return is_valid_ptr_displacement_type(right)
+    if is_pointer_rprimitive(right):
+        return is_valid_ptr_displacement_type(left)
+    return False
+
+
+class OpChecker(OpVisitor[None]):
+    def __init__(self, parent_fn: FuncIR) -> None:
+        self.parent_fn = parent_fn
+        self.errors: list[FnError] = []
+
+    def fail(self, source: Op, desc: str) -> None:
+        self.errors.append(FnError(source=source, desc=desc))
+
+    def check_control_op_targets(self, op: ControlOp) -> None:
+        for target in op.targets():
+            if target not in self.parent_fn.blocks:
+                self.fail(source=op, desc=f"Invalid control operation target: {target.label}")
+
+    def check_type_coercion(self, op: Op, src: RType, dest: RType) -> None:
+        if not can_coerce_to(src, dest):
+            self.fail(
+                source=op, desc=f"Cannot coerce source type {src.name} to dest type {dest.name}"
+            )
+
+    def check_compatibility(self, op: Op, t: RType, s: RType) -> None:
+        if not can_coerce_to(t, s) or not can_coerce_to(s, t):
+            self.fail(source=op, desc=f"{t.name} and {s.name} are not compatible")
+
+    def expect_float(self, op: Op, v: Value) -> None:
+        if not is_float_rprimitive(v.type):
+            self.fail(op, f"Float expected (actual type is {v.type})")
+
+    def expect_non_float(self, op: Op, v: Value) -> None:
+        if is_float_rprimitive(v.type):
+            self.fail(op, "Float not expected")
+
+    def expect_primitive_type(self, op: Op, v: Value) -> None:
+        if not isinstance(v.type, RPrimitive):
+            self.fail(op, f"RPrimitive expected, got {type(v.type).__name__}")
+
+    def visit_goto(self, op: Goto) -> None:
+        self.check_control_op_targets(op)
+
+    def visit_branch(self, op: Branch) -> None:
+        self.check_control_op_targets(op)
+
+    def visit_return(self, op: Return) -> None:
+        self.check_type_coercion(op, op.value.type, self.parent_fn.decl.sig.ret_type)
+
+    def visit_unreachable(self, op: Unreachable) -> None:
+        # Unreachables are checked at a higher level since validation
+        # requires access to the entire basic block.
+        pass
+
+    def visit_assign(self, op: Assign) -> None:
+        self.check_type_coercion(op, op.src.type, op.dest.type)
+
+    def visit_assign_multi(self, op: AssignMulti) -> None:
+        for src in op.src:
+            assert isinstance(op.dest.type, RArray)
+            self.check_type_coercion(op, src.type, op.dest.type.item_type)
+
+    def visit_load_error_value(self, op: LoadErrorValue) -> None:
+        # Currently it is assumed that all types have an error value.
+        # Once this is fixed we can validate that the rtype here actually
+        # has an error value.
+        pass
+
+    def check_tuple_items_valid_literals(self, op: LoadLiteral, t: tuple[object, ...]) -> None:
+        for x in t:
+            if x is not None and not isinstance(x, (str, bytes, bool, int, float, complex, tuple)):
+                self.fail(op, f"Invalid type for item of tuple literal: {type(x)})")
+            if isinstance(x, tuple):
+                self.check_tuple_items_valid_literals(op, x)
+
+    def check_frozenset_items_valid_literals(self, op: LoadLiteral, s: frozenset[object]) -> None:
+        for x in s:
+            if x is None or isinstance(x, (str, bytes, bool, int, float, complex)):
+                pass
+            elif isinstance(x, tuple):
+                self.check_tuple_items_valid_literals(op, x)
+            else:
+                self.fail(op, f"Invalid type for item of frozenset literal: {type(x)})")
+
+    def visit_load_literal(self, op: LoadLiteral) -> None:
+        expected_type = None
+        if op.value is None:
+            expected_type = "builtins.object"
+        elif isinstance(op.value, int):
+            expected_type = "builtins.int"
+        elif isinstance(op.value, str):
+            expected_type = "builtins.str"
+        elif isinstance(op.value, bytes):
+            expected_type = "builtins.bytes"
+        elif isinstance(op.value, float):
+            expected_type = "builtins.float"
+        elif isinstance(op.value, complex):
+            expected_type = "builtins.object"
+        elif isinstance(op.value, tuple):
+            expected_type = "builtins.tuple"
+            self.check_tuple_items_valid_literals(op, op.value)
+        elif isinstance(op.value, frozenset):
+            # There's no frozenset_rprimitive type since it'd be pretty useless so we just pretend
+            # it's a set (when it's really a frozenset).
+            expected_type = "builtins.set"
+            self.check_frozenset_items_valid_literals(op, op.value)
+
+        assert expected_type is not None, "Missed a case for LoadLiteral check"
+
+        if op.type.name not in [expected_type, "builtins.object"]:
+            self.fail(
+                op,
+                f"Invalid literal value for type: value has "
+                f"type {expected_type}, but op has type {op.type.name}",
+            )
+
+    def visit_get_attr(self, op: GetAttr) -> None:
+        # Nothing to do.
+        pass
+
+    def visit_set_attr(self, op: SetAttr) -> None:
+        # Nothing to do.
+        pass
+
+    # Static operations cannot be checked at the function level.
+    def visit_load_static(self, op: LoadStatic) -> None:
+        pass
+
+    def visit_init_static(self, op: InitStatic) -> None:
+        pass
+
+    def visit_tuple_get(self, op: TupleGet) -> None:
+        # Nothing to do.
+        pass
+
+    def visit_tuple_set(self, op: TupleSet) -> None:
+        # Nothing to do.
+        pass
+
+    def visit_inc_ref(self, op: IncRef) -> None:
+        # Nothing to do.
+        pass
+
+    def visit_dec_ref(self, op: DecRef) -> None:
+        # Nothing to do.
+        pass
+
+    def visit_call(self, op: Call) -> None:
+        # Length is checked in constructor, and return type is set
+        # in a way that can't be incorrect
+        for arg_value, arg_runtime in zip(op.args, op.fn.sig.args):
+            self.check_type_coercion(op, arg_value.type, arg_runtime.type)
+
+    def visit_method_call(self, op: MethodCall) -> None:
+        # Similar to above, but we must look up method first.
+        method_decl = op.receiver_type.class_ir.method_decl(op.method)
+        if method_decl.kind == FUNC_STATICMETHOD:
+            decl_index = 0
+        else:
+            decl_index = 1
+
+        if len(op.args) + decl_index != len(method_decl.sig.args):
+            self.fail(op, "Incorrect number of args for method call.")
+
+        # Skip the receiver argument (self)
+        for arg_value, arg_runtime in zip(op.args, method_decl.sig.args[decl_index:]):
+            self.check_type_coercion(op, arg_value.type, arg_runtime.type)
+
+    def visit_cast(self, op: Cast) -> None:
+        pass
+
+    def visit_box(self, op: Box) -> None:
+        pass
+
+    def visit_unbox(self, op: Unbox) -> None:
+        pass
+
+    def visit_raise_standard_error(self, op: RaiseStandardError) -> None:
+        pass
+
+    def visit_call_c(self, op: CallC) -> None:
+        pass
+
+    def visit_primitive_op(self, op: PrimitiveOp) -> None:
+        pass
+
+    def visit_truncate(self, op: Truncate) -> None:
+        pass
+
+    def visit_extend(self, op: Extend) -> None:
+        pass
+
+    def visit_load_global(self, op: LoadGlobal) -> None:
+        pass
+
+    def visit_int_op(self, op: IntOp) -> None:
+        self.expect_primitive_type(op, op.lhs)
+        self.expect_primitive_type(op, op.rhs)
+        self.expect_non_float(op, op.lhs)
+        self.expect_non_float(op, op.rhs)
+        left = op.lhs.type
+        right = op.rhs.type
+        op_str = op.op_str[op.op]
+        if (
+            isinstance(left, RPrimitive)
+            and isinstance(right, RPrimitive)
+            and left.is_signed != right.is_signed
+            and (
+                op_str in ("+", "-", "*", "/", "%")
+                or (op_str not in ("<<", ">>") and left.size != right.size)
+            )
+            and not is_pointer_arithmetic(op)
+        ):
+            self.fail(op, f"Operand types have incompatible signs: {left}, {right}")
+
+    def visit_comparison_op(self, op: ComparisonOp) -> None:
+        self.check_compatibility(op, op.lhs.type, op.rhs.type)
+        self.expect_non_float(op, op.lhs)
+        self.expect_non_float(op, op.rhs)
+        left = op.lhs.type
+        right = op.rhs.type
+        if (
+            isinstance(left, RPrimitive)
+            and isinstance(right, RPrimitive)
+            and left.is_signed != right.is_signed
+        ):
+            self.fail(op, f"Operand types have incompatible signs: {left}, {right}")
+
+    def visit_float_op(self, op: FloatOp) -> None:
+        self.expect_float(op, op.lhs)
+        self.expect_float(op, op.rhs)
+
+    def visit_float_neg(self, op: FloatNeg) -> None:
+        self.expect_float(op, op.src)
+
+    def visit_float_comparison_op(self, op: FloatComparisonOp) -> None:
+        self.expect_float(op, op.lhs)
+        self.expect_float(op, op.rhs)
+
+    def visit_load_mem(self, op: LoadMem) -> None:
+        pass
+
+    def visit_set_mem(self, op: SetMem) -> None:
+        pass
+
+    def visit_get_element(self, op: GetElement) -> None:
+        pass
+
+    def visit_get_element_ptr(self, op: GetElementPtr) -> None:
+        pass
+
+    def visit_set_element(self, op: SetElement) -> None:
+        pass
+
+    def visit_load_address(self, op: LoadAddress) -> None:
+        pass
+
+    def visit_keep_alive(self, op: KeepAlive) -> None:
+        pass
+
+    def visit_unborrow(self, op: Unborrow) -> None:
+        pass

micromamba_root/Lib/site-packages/mypyc/analysis/selfleaks.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+from mypyc.analysis.dataflow import (
+    CFG,
+    MAYBE_ANALYSIS,
+    AnalysisResult,
+    GenAndKill as _DataflowGenAndKill,
+    run_analysis,
+)
+from mypyc.ir.ops import (
+    Assign,
+    AssignMulti,
+    BasicBlock,
+    Box,
+    Branch,
+    Call,
+    CallC,
+    Cast,
+    ComparisonOp,
+    DecRef,
+    Extend,
+    FloatComparisonOp,
+    FloatNeg,
+    FloatOp,
+    GetAttr,
+    GetElement,
+    GetElementPtr,
+    Goto,
+    IncRef,
+    InitStatic,
+    IntOp,
+    KeepAlive,
+    LoadAddress,
+    LoadErrorValue,
+    LoadGlobal,
+    LoadLiteral,
+    LoadMem,
+    LoadStatic,
+    MethodCall,
+    OpVisitor,
+    PrimitiveOp,
+    RaiseStandardError,
+    Register,
+    RegisterOp,
+    Return,
+    SetAttr,
+    SetElement,
+    SetMem,
+    Truncate,
+    TupleGet,
+    TupleSet,
+    Unborrow,
+    Unbox,
+    Unreachable,
+)
+from mypyc.ir.rtypes import RInstance
+
+GenAndKill = _DataflowGenAndKill[None]
+
+CLEAN: GenAndKill = (set(), set())
+DIRTY: GenAndKill = ({None}, {None})
+
+
+class SelfLeakedVisitor(OpVisitor[GenAndKill]):
+    """Analyze whether 'self' may be seen by arbitrary code in '__init__'.
+
+    More formally, the set is not empty if along some path from IR entry point
+    arbitrary code could have been executed that has access to 'self'.
+
+    (We don't consider access via 'gc.get_objects()'.)
+    """
+
+    def __init__(self, self_reg: Register) -> None:
+        self.self_reg = self_reg
+
+    def visit_goto(self, op: Goto) -> GenAndKill:
+        return CLEAN
+
+    def visit_branch(self, op: Branch) -> GenAndKill:
+        return CLEAN
+
+    def visit_return(self, op: Return) -> GenAndKill:
+        # Consider all exits from the function 'dirty' since they implicitly
+        # cause 'self' to be returned.
+        return DIRTY
+
+    def visit_unreachable(self, op: Unreachable) -> GenAndKill:
+        return CLEAN
+
+    def visit_assign(self, op: Assign) -> GenAndKill:
+        if op.src is self.self_reg or op.dest is self.self_reg:
+            return DIRTY
+        return CLEAN
+
+    def visit_assign_multi(self, op: AssignMulti) -> GenAndKill:
+        return CLEAN
+
+    def visit_set_mem(self, op: SetMem) -> GenAndKill:
+        return CLEAN
+
+    def visit_inc_ref(self, op: IncRef) -> GenAndKill:
+        return CLEAN
+
+    def visit_dec_ref(self, op: DecRef) -> GenAndKill:
+        return CLEAN
+
+    def visit_call(self, op: Call) -> GenAndKill:
+        fn = op.fn
+        if fn.class_name and fn.name == "__init__":
+            self_type = op.fn.sig.args[0].type
+            assert isinstance(self_type, RInstance), self_type
+            cl = self_type.class_ir
+            if not cl.init_self_leak:
+                return CLEAN
+        return self.check_register_op(op)
+
+    def visit_method_call(self, op: MethodCall) -> GenAndKill:
+        return self.check_register_op(op)
+
+    def visit_load_error_value(self, op: LoadErrorValue) -> GenAndKill:
+        return CLEAN
+
+    def visit_load_literal(self, op: LoadLiteral) -> GenAndKill:
+        return CLEAN
+
+    def visit_get_attr(self, op: GetAttr) -> GenAndKill:
+        cl = op.class_type.class_ir
+        if cl.get_method(op.attr):
+            # Property -- calls a function
+            return self.check_register_op(op)
+        return CLEAN
+
+    def visit_set_attr(self, op: SetAttr) -> GenAndKill:
+        cl = op.class_type.class_ir
+        if cl.get_method(op.attr):
+            # Property - calls a function
+            return self.check_register_op(op)
+        return CLEAN
+
+    def visit_load_static(self, op: LoadStatic) -> GenAndKill:
+        return CLEAN
+
+    def visit_init_static(self, op: InitStatic) -> GenAndKill:
+        return self.check_register_op(op)
+
+    def visit_tuple_get(self, op: TupleGet) -> GenAndKill:
+        return CLEAN
+
+    def visit_tuple_set(self, op: TupleSet) -> GenAndKill:
+        return self.check_register_op(op)
+
+    def visit_box(self, op: Box) -> GenAndKill:
+        return self.check_register_op(op)
+
+    def visit_unbox(self, op: Unbox) -> GenAndKill:
+        return self.check_register_op(op)
+
+    def visit_cast(self, op: Cast) -> GenAndKill:
+        return self.check_register_op(op)
+
+    def visit_raise_standard_error(self, op: RaiseStandardError) -> GenAndKill:
+        return CLEAN
+
+    def visit_call_c(self, op: CallC) -> GenAndKill:
+        return self.check_register_op(op)
+
+    def visit_primitive_op(self, op: PrimitiveOp) -> GenAndKill:
+        return self.check_register_op(op)
+
+    def visit_truncate(self, op: Truncate) -> GenAndKill:
+        return CLEAN
+
+    def visit_extend(self, op: Extend) -> GenAndKill:
+        return CLEAN
+
+    def visit_load_global(self, op: LoadGlobal) -> GenAndKill:
+        return CLEAN
+
+    def visit_int_op(self, op: IntOp) -> GenAndKill:
+        return CLEAN
+
+    def visit_comparison_op(self, op: ComparisonOp) -> GenAndKill:
+        return CLEAN
+
+    def visit_float_op(self, op: FloatOp) -> GenAndKill:
+        return CLEAN
+
+    def visit_float_neg(self, op: FloatNeg) -> GenAndKill:
+        return CLEAN
+
+    def visit_float_comparison_op(self, op: FloatComparisonOp) -> GenAndKill:
+        return CLEAN
+
+    def visit_load_mem(self, op: LoadMem) -> GenAndKill:
+        return CLEAN
+
+    def visit_get_element(self, op: GetElement) -> GenAndKill:
+        return CLEAN
+
+    def visit_get_element_ptr(self, op: GetElementPtr) -> GenAndKill:
+        return CLEAN
+
+    def visit_set_element(self, op: SetElement) -> GenAndKill:
+        return CLEAN
+
+    def visit_load_address(self, op: LoadAddress) -> GenAndKill:
+        return CLEAN
+
+    def visit_keep_alive(self, op: KeepAlive) -> GenAndKill:
+        return CLEAN
+
+    def visit_unborrow(self, op: Unborrow) -> GenAndKill:
+        return CLEAN
+
+    def check_register_op(self, op: RegisterOp) -> GenAndKill:
+        if any(src is self.self_reg for src in op.sources()):
+            return DIRTY
+        return CLEAN
+
+
+def analyze_self_leaks(
+    blocks: list[BasicBlock], self_reg: Register, cfg: CFG
+) -> AnalysisResult[None]:
+    return run_analysis(
+        blocks=blocks,
+        cfg=cfg,
+        gen_and_kill=SelfLeakedVisitor(self_reg),
+        initial=set(),
+        backward=False,
+        kind=MAYBE_ANALYSIS,
+    )

micromamba_root/Lib/site-packages/mypyc/codegen/cstring.py

@@ -0,0 +1,54 @@
+"""Encode valid C string literals from Python strings.
+
+If a character is not allowed in C string literals, it is either emitted
+as a simple escape sequence (e.g. '\\n'), or an octal escape sequence
+with exactly three digits ('\\oXXX'). Question marks are escaped to
+prevent trigraphs in the string literal from being interpreted. Note
+that '\\?' is an invalid escape sequence in Python.
+
+Consider the string literal "AB\\xCDEF". As one would expect, Python
+parses it as ['A', 'B', 0xCD, 'E', 'F']. However, the C standard
+specifies that all hexadecimal digits immediately following '\\x' will
+be interpreted as part of the escape sequence. Therefore, it is
+unexpectedly parsed as ['A', 'B', 0xCDEF].
+
+Emitting ("AB\\xCD" "EF") would avoid this behaviour. However, we opt
+for simplicity and use octal escape sequences instead. They do not
+suffer from the same issue as they are defined to parse at most three
+octal digits.
+"""
+
+from __future__ import annotations
+
+import string
+from typing import Final
+
+CHAR_MAP: Final = [f"\\{i:03o}" for i in range(256)]
+
+# It is safe to use string.printable as it always uses the C locale.
+for c in string.printable:
+    CHAR_MAP[ord(c)] = c
+
+# These assignments must come last because we prioritize simple escape
+# sequences over any other representation.
+for c in ("'", '"', "\\", "a", "b", "f", "n", "r", "t", "v"):
+    escaped = f"\\{c}"
+    decoded = escaped.encode("ascii").decode("unicode_escape")
+    CHAR_MAP[ord(decoded)] = escaped
+
+# This escape sequence is invalid in Python.
+CHAR_MAP[ord("?")] = r"\?"
+
+
+def encode_bytes_as_c_string(b: bytes) -> str:
+    """Produce contents of a C string literal for a byte string, without quotes."""
+    escaped = "".join([CHAR_MAP[i] for i in b])
+    return escaped
+
+
+def c_string_initializer(value: bytes) -> str:
+    """Create initializer for a C char[]/ char * variable from a string.
+
+    For example, if value if b'foo', the result would be '"foo"'.
+    """
+    return '"' + encode_bytes_as_c_string(value) + '"'

micromamba_root/Lib/site-packages/mypyc/codegen/emit.py

@@ -0,0 +1,1439 @@
+"""Utilities for emitting C code."""
+
+from __future__ import annotations
+
+import pprint
+import sys
+import textwrap
+from collections.abc import Callable
+from typing import Final
+
+from mypyc.codegen.cstring import c_string_initializer
+from mypyc.codegen.literals import Literals
+from mypyc.common import (
+    ATTR_PREFIX,
+    BITMAP_BITS,
+    FAST_ISINSTANCE_MAX_SUBCLASSES,
+    HAVE_IMMORTAL,
+    MODULE_PREFIX,
+    NATIVE_PREFIX,
+    PREFIX,
+    REG_PREFIX,
+    STATIC_PREFIX,
+    TYPE_PREFIX,
+    TYPE_VAR_PREFIX,
+)
+from mypyc.ir.class_ir import ClassIR, all_concrete_classes
+from mypyc.ir.func_ir import FUNC_STATICMETHOD, FuncDecl, FuncIR, get_text_signature
+from mypyc.ir.ops import (
+    NAMESPACE_MODULE,
+    NAMESPACE_STATIC,
+    NAMESPACE_TYPE,
+    NAMESPACE_TYPE_VAR,
+    BasicBlock,
+    Value,
+)
+from mypyc.ir.rtypes import (
+    RInstance,
+    RPrimitive,
+    RTuple,
+    RType,
+    RUnion,
+    RVec,
+    int_rprimitive,
+    is_bool_or_bit_rprimitive,
+    is_bytearray_rprimitive,
+    is_bytes_rprimitive,
+    is_dict_rprimitive,
+    is_fixed_width_rtype,
+    is_float_rprimitive,
+    is_frozenset_rprimitive,
+    is_int16_rprimitive,
+    is_int32_rprimitive,
+    is_int64_rprimitive,
+    is_int_rprimitive,
+    is_list_rprimitive,
+    is_native_rprimitive,
+    is_none_rprimitive,
+    is_object_rprimitive,
+    is_optional_type,
+    is_range_rprimitive,
+    is_set_rprimitive,
+    is_short_int_rprimitive,
+    is_str_rprimitive,
+    is_tuple_rprimitive,
+    is_uint8_rprimitive,
+    object_rprimitive,
+    optional_value_type,
+    vec_api_by_item_type,
+    vec_item_type_tags,
+)
+from mypyc.namegen import NameGenerator, exported_name
+from mypyc.primitives.registry import builtin_names
+from mypyc.sametype import is_same_type
+
+# Whether to insert debug asserts for all error handling, to quickly
+# catch errors propagating without exceptions set.
+DEBUG_ERRORS: Final = False
+
+PREFIX_MAP: Final = {
+    NAMESPACE_STATIC: STATIC_PREFIX,
+    NAMESPACE_TYPE: TYPE_PREFIX,
+    NAMESPACE_MODULE: MODULE_PREFIX,
+    NAMESPACE_TYPE_VAR: TYPE_VAR_PREFIX,
+}
+
+
+class HeaderDeclaration:
+    """A representation of a declaration in C.
+
+    This is used to generate declarations in header files and
+    (optionally) definitions in source files.
+
+    Attributes:
+      decl: C source code for the declaration.
+      defn: Optionally, C source code for a definition.
+      dependencies: The names of any objects that must be declared prior.
+      is_type: Whether the declaration is of a C type. (C types will be declared in
+               external header files and not marked 'extern'.)
+      needs_export: Whether the declared object needs to be exported to
+                    other modules in the linking table.
+    """
+
+    def __init__(
+        self,
+        decl: str | list[str],
+        defn: list[str] | None = None,
+        *,
+        dependencies: set[str] | None = None,
+        is_type: bool = False,
+        needs_export: bool = False,
+    ) -> None:
+        self.decl = [decl] if isinstance(decl, str) else decl
+        self.defn = defn
+        self.dependencies = dependencies or set()
+        self.is_type = is_type
+        self.needs_export = needs_export
+
+
+class EmitterContext:
+    """Shared emitter state for a compilation group."""
+
+    def __init__(
+        self,
+        names: NameGenerator,
+        strict_traceback_checks: bool,
+        group_name: str | None = None,
+        group_map: dict[str, str | None] | None = None,
+    ) -> None:
+        """Setup shared emitter state.
+
+        Args:
+            names: The name generator to use
+            group_map: Map from module names to group name
+            group_name: Current group name
+        """
+        self.temp_counter = 0
+        self.names = names
+        self.group_name = group_name
+        self.group_map = group_map or {}
+        # Groups that this group depends on
+        self.group_deps: set[str] = set()
+
+        # The map below is used for generating declarations and
+        # definitions at the top of the C file. The main idea is that they can
+        # be generated at any time during the emit phase.
+
+        # A map of a C identifier to whatever the C identifier declares. Currently this is
+        # used for declaring structs and the key corresponds to the name of the struct.
+        # The declaration contains the body of the struct.
+        self.declarations: dict[str, HeaderDeclaration] = {}
+
+        self.literals = Literals()
+        # See mypyc/options.py for context.
+        self.strict_traceback_checks = strict_traceback_checks
+
+
+class ErrorHandler:
+    """Describes handling errors in unbox/cast operations."""
+
+
+class AssignHandler(ErrorHandler):
+    """Assign an error value on error."""
+
+
+class GotoHandler(ErrorHandler):
+    """Goto label on error."""
+
+    def __init__(self, label: str) -> None:
+        self.label = label
+
+
+class TracebackAndGotoHandler(ErrorHandler):
+    """Add traceback item and goto label on error."""
+
+    def __init__(
+        self, label: str, source_path: str, module_name: str, traceback_entry: tuple[str, int]
+    ) -> None:
+        self.label = label
+        self.source_path = source_path
+        self.module_name = module_name
+        self.traceback_entry = traceback_entry
+
+
+class ReturnHandler(ErrorHandler):
+    """Return a constant value on error."""
+
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+
+class Emitter:
+    """Helper for C code generation."""
+
+    def __init__(
+        self,
+        context: EmitterContext,
+        value_names: dict[Value, str] | None = None,
+        capi_version: tuple[int, int] | None = None,
+        filepath: str | None = None,
+    ) -> None:
+        self.context = context
+        self.capi_version = capi_version or sys.version_info[:2]
+        self.names = context.names
+        self.value_names = value_names or {}
+        self.fragments: list[str] = []
+        self._indent = 0
+        self.filepath = filepath
+
+    # Low-level operations
+
+    def indent(self) -> None:
+        self._indent += 4
+
+    def dedent(self) -> None:
+        self._indent -= 4
+        assert self._indent >= 0
+
+    def label(self, label: BasicBlock) -> str:
+        return "CPyL%s" % label.label
+
+    def reg(self, reg: Value) -> str:
+        return REG_PREFIX + self.value_names[reg]
+
+    def attr(self, name: str) -> str:
+        return ATTR_PREFIX + name
+
+    def object_annotation(self, obj: object, line: str) -> str:
+        """Build a C comment with an object's string representation.
+
+        If the comment exceeds the line length limit, it's wrapped into a
+        multiline string (with the extra lines indented to be aligned with
+        the first line's comment).
+
+        If it contains illegal characters, an empty string is returned."""
+        line_width = self._indent + len(line)
+        formatted = pprint.pformat(obj, compact=True, width=max(90 - line_width, 20))
+        if any(x in formatted for x in ("/*", "*/", "\0")):
+            return ""
+
+        if "\n" in formatted:
+            first_line, rest = formatted.split("\n", maxsplit=1)
+            comment_continued = textwrap.indent(rest, (line_width + 3) * " ")
+            return f" /* {first_line}\n{comment_continued} */"
+        else:
+            return f" /* {formatted} */"
+
+    def emit_line(self, line: str = "", *, ann: object = None) -> None:
+        if line.startswith("}"):
+            self.dedent()
+        comment = self.object_annotation(ann, line) if ann is not None else ""
+        self.fragments.append(self._indent * " " + line + comment + "\n")
+        if line.endswith("{"):
+            self.indent()
+
+    def emit_lines(self, *lines: str) -> None:
+        for line in lines:
+            self.emit_line(line)
+
+    def emit_label(self, label: BasicBlock | str) -> None:
+        if isinstance(label, str):
+            text = label
+        else:
+            if label.label == 0 or not label.referenced:
+                return
+
+            text = self.label(label)
+        # Extra semicolon prevents an error when the next line declares a tempvar
+        self.fragments.append(f"{text}: ;\n")
+
+    def emit_from_emitter(self, emitter: Emitter) -> None:
+        self.fragments.extend(emitter.fragments)
+
+    def emit_printf(self, fmt: str, *args: str) -> None:
+        fmt = fmt.replace("\n", "\\n")
+        self.emit_line("printf(%s);" % ", ".join(['"%s"' % fmt] + list(args)))
+        self.emit_line("fflush(stdout);")
+
+    def temp_name(self) -> str:
+        self.context.temp_counter += 1
+        return "__tmp%d" % self.context.temp_counter
+
+    def new_label(self) -> str:
+        self.context.temp_counter += 1
+        return "__LL%d" % self.context.temp_counter
+
+    def get_module_group_prefix(self, module_name: str) -> str:
+        """Get the group prefix for a module (relative to the current group).
+
+        The prefix should be prepended to the object name whenever
+        accessing an object from this module.
+
+        If the module lives is in the current compilation group, there is
+        no prefix.  But if it lives in a different group (and hence a separate
+        extension module), we need to access objects from it indirectly via an
+        export table.
+
+        For example, for code in group `a` to call a function `bar` in group `b`,
+        it would need to do `exports_b.CPyDef_bar(...)`, while code that is
+        also in group `b` can simply do `CPyDef_bar(...)`.
+
+        Thus the prefix for a module in group `b` is 'exports_b.' if the current
+        group is *not* b and just '' if it is.
+        """
+        groups = self.context.group_map
+        target_group_name = groups.get(module_name)
+        if target_group_name and target_group_name != self.context.group_name:
+            self.context.group_deps.add(target_group_name)
+            return f"exports_{exported_name(target_group_name)}."
+        else:
+            return ""
+
+    def get_group_prefix(self, obj: ClassIR | FuncDecl) -> str:
+        """Get the group prefix for an object."""
+        # See docs above
+        return self.get_module_group_prefix(obj.module_name)
+
+    def static_name(self, id: str, module: str | None, prefix: str = STATIC_PREFIX) -> str:
+        """Create name of a C static variable.
+
+        These are used for literals and imported modules, among other
+        things.
+
+        The caller should ensure that the (id, module) pair cannot
+        overlap with other calls to this method within a compilation
+        group.
+        """
+        lib_prefix = "" if not module else self.get_module_group_prefix(module)
+        # If we are accessing static via the export table, we need to dereference
+        # the pointer also.
+        star_maybe = "*" if lib_prefix else ""
+        suffix = self.names.private_name(module or "", id)
+        return f"{star_maybe}{lib_prefix}{prefix}{suffix}"
+
+    def type_struct_name(self, cl: ClassIR) -> str:
+        return self.static_name(cl.name, cl.module_name, prefix=TYPE_PREFIX)
+
+    def ctype(self, rtype: RType) -> str:
+        return rtype._ctype
+
+    def ctype_spaced(self, rtype: RType) -> str:
+        """Adds a space after ctype for non-pointers."""
+        ctype = self.ctype(rtype)
+        if ctype[-1] == "*":
+            return ctype
+        else:
+            return ctype + " "
+
+    def set_undefined_value(self, target: str, rtype: RType) -> None:
+        if isinstance(rtype, RVec):
+            self.emit_line(f"{target}.len = -1;")
+            self.emit_line(f"{target}.buf = NULL;")
+        else:
+            self.emit_line(f"{target} = {self.c_undefined_value(rtype)};")
+
+    def c_undefined_value(self, rtype: RType) -> str:
+        if not rtype.is_unboxed:
+            return "NULL"
+        elif isinstance(rtype, RPrimitive):
+            return rtype.c_undefined
+        elif isinstance(rtype, RTuple):
+            return self.tuple_undefined_value(rtype)
+        elif isinstance(rtype, RVec):
+            return f"({self.ctype(rtype)}) {{ -1, NULL }}"
+        assert False, rtype
+
+    def c_error_value(self, rtype: RType) -> str:
+        return self.c_undefined_value(rtype)
+
+    def native_function_name(self, fn: FuncDecl) -> str:
+        return f"{NATIVE_PREFIX}{fn.cname(self.names)}"
+
+    def tuple_c_declaration(self, rtuple: RTuple) -> list[str]:
+        result = [
+            f"#ifndef MYPYC_DECLARED_{rtuple.struct_name}",
+            f"#define MYPYC_DECLARED_{rtuple.struct_name}",
+            f"typedef struct {rtuple.struct_name} {{",
+        ]
+        if len(rtuple.types) == 0:  # empty tuple
+            # Empty tuples contain a flag so that they can still indicate
+            # error values.
+            result.append("int empty_struct_error_flag;")
+        else:
+            i = 0
+            for typ in rtuple.types:
+                result.append(f"{self.ctype_spaced(typ)}f{i};")
+                i += 1
+        result.append(f"}} {rtuple.struct_name};")
+        result.append("#endif")
+        result.append("")
+
+        return result
+
+    def bitmap_field(self, index: int) -> str:
+        """Return C field name used for attribute bitmap."""
+        n = index // BITMAP_BITS
+        if n == 0:
+            return "bitmap"
+        return f"bitmap{n + 1}"
+
+    def attr_bitmap_expr(self, obj: str, cl: ClassIR, index: int) -> str:
+        """Return reference to the attribute definedness bitmap."""
+        cast = f"({cl.struct_name(self.names)} *)"
+        attr = self.bitmap_field(index)
+        return f"({cast}{obj})->{attr}"
+
+    def emit_attr_bitmap_set(
+        self, value: str, obj: str, rtype: RType, cl: ClassIR, attr: str
+    ) -> None:
+        """Mark an attribute as defined in the attribute bitmap.
+
+        Assumes that the attribute is tracked in the bitmap (only some attributes
+        use the bitmap). If 'value' is not equal to the error value, do nothing.
+        """
+        self._emit_attr_bitmap_update(value, obj, rtype, cl, attr, clear=False)
+
+    def emit_attr_bitmap_clear(self, obj: str, rtype: RType, cl: ClassIR, attr: str) -> None:
+        """Mark an attribute as undefined in the attribute bitmap.
+
+        Unlike emit_attr_bitmap_set, clear unconditionally.
+        """
+        self._emit_attr_bitmap_update("", obj, rtype, cl, attr, clear=True)
+
+    def _emit_attr_bitmap_update(
+        self, value: str, obj: str, rtype: RType, cl: ClassIR, attr: str, clear: bool
+    ) -> None:
+        if value:
+            check = self.error_value_check(rtype, value, "==")
+            self.emit_line(f"if (unlikely({check})) {{")
+        index = cl.bitmap_attrs.index(attr)
+        mask = 1 << (index & (BITMAP_BITS - 1))
+        bitmap = self.attr_bitmap_expr(obj, cl, index)
+        if clear:
+            self.emit_line(f"{bitmap} &= ~{mask};")
+        else:
+            self.emit_line(f"{bitmap} |= {mask};")
+        if value:
+            self.emit_line("}")
+
+    def emit_undefined_attr_check(
+        self,
+        rtype: RType,
+        attr_expr: str,
+        compare: str,
+        obj: str,
+        attr: str,
+        cl: ClassIR,
+        *,
+        unlikely: bool = False,
+    ) -> None:
+        check = self.error_value_check(rtype, attr_expr, compare)
+        if unlikely:
+            check = f"unlikely({check})"
+        if rtype.error_overlap:
+            index = cl.bitmap_attrs.index(attr)
+            bit = 1 << (index & (BITMAP_BITS - 1))
+            attr = self.bitmap_field(index)
+            obj_expr = f"({cl.struct_name(self.names)} *){obj}"
+            check = f"{check} && !(({obj_expr})->{attr} & {bit})"
+        self.emit_line(f"if ({check}) {{")
+
+    def error_value_check(self, rtype: RType, value: str, compare: str) -> str:
+        if isinstance(rtype, RTuple):
+            return self.tuple_undefined_check_cond(
+                rtype, value, self.c_error_value, compare, check_exception=False
+            )
+        elif isinstance(rtype, RVec):
+            if compare == "==":
+                return f"{value}.len < 0"
+            elif compare == "!=":
+                return f"{value}.len >= 0"
+            assert False, compare
+        else:
+            return f"{value} {compare} {self.c_error_value(rtype)}"
+
+    def tuple_undefined_check_cond(
+        self,
+        rtuple: RTuple,
+        tuple_expr_in_c: str,
+        c_type_compare_val: Callable[[RType], str],
+        compare: str,
+        *,
+        check_exception: bool = True,
+    ) -> str:
+        if len(rtuple.types) == 0:
+            # empty tuple
+            return "{}.empty_struct_error_flag {} {}".format(
+                tuple_expr_in_c, compare, c_type_compare_val(int_rprimitive)
+            )
+        if rtuple.error_overlap:
+            i = 0
+            item_type = rtuple.types[0]
+        else:
+            for i, typ in enumerate(rtuple.types):
+                if not typ.error_overlap:
+                    item_type = rtuple.types[i]
+                    break
+            else:
+                assert False, "not expecting tuple with error overlap"
+        if isinstance(item_type, RTuple):
+            return self.tuple_undefined_check_cond(
+                item_type, tuple_expr_in_c + f".f{i}", c_type_compare_val, compare
+            )
+        elif isinstance(item_type, RVec):
+            return f"{tuple_expr_in_c}.f{i}.len {compare} -1"
+        else:
+            check = f"{tuple_expr_in_c}.f{i} {compare} {c_type_compare_val(item_type)}"
+            if rtuple.error_overlap and check_exception:
+                check += " && PyErr_Occurred()"
+            return check
+
+    def tuple_undefined_value(self, rtuple: RTuple) -> str:
+        """Undefined tuple value suitable in an expression."""
+        return f"({rtuple.struct_name}) {self.c_initializer_undefined_value(rtuple)}"
+
+    def c_initializer_undefined_value(self, rtype: RType) -> str:
+        """Undefined value represented in a form suitable for variable initialization."""
+        if isinstance(rtype, RTuple):
+            if not rtype.types:
+                # Empty tuples contain a flag so that they can still indicate
+                # error values.
+                return f"{{ {int_rprimitive.c_undefined} }}"
+            items = ", ".join([self.c_initializer_undefined_value(t) for t in rtype.types])
+            return f"{{ {items} }}"
+        elif isinstance(rtype, RVec):
+            return "{ -1, NULL }"
+        else:
+            return self.c_undefined_value(rtype)
+
+    # Higher-level operations
+
+    def declare_tuple_struct(self, tuple_type: RTuple) -> None:
+        if tuple_type.struct_name not in self.context.declarations:
+            dependencies = set()
+            for typ in tuple_type.types:
+                # XXX other types might eventually need similar behavior
+                if isinstance(typ, RTuple):
+                    dependencies.add(typ.struct_name)
+
+            self.context.declarations[tuple_type.struct_name] = HeaderDeclaration(
+                self.tuple_c_declaration(tuple_type), dependencies=dependencies, is_type=True
+            )
+
+    def emit_inc_ref(self, dest: str, rtype: RType, *, rare: bool = False) -> None:
+        """Increment reference count of C expression `dest`.
+
+        For composite unboxed structures (e.g. tuples) recursively
+        increment reference counts for each component.
+
+        If rare is True, optimize for code size and compilation speed.
+        """
+        if is_int_rprimitive(rtype):
+            if rare:
+                self.emit_line("CPyTagged_IncRef(%s);" % dest)
+            else:
+                self.emit_line("CPyTagged_INCREF(%s);" % dest)
+        elif isinstance(rtype, RTuple):
+            for i, item_type in enumerate(rtype.types):
+                self.emit_inc_ref(f"{dest}.f{i}", item_type)
+        elif isinstance(rtype, RVec):
+            # TODO: Only use the X variant if buf can be NULL
+            self.emit_line(f"Py_XINCREF({dest}.buf);")
+        elif not rtype.is_unboxed:
+            # Always inline, since this is a simple but very hot op
+            if rtype.may_be_immortal or not HAVE_IMMORTAL:
+                self.emit_line("CPy_INCREF(%s);" % dest)
+            else:
+                self.emit_line("CPy_INCREF_NO_IMM(%s);" % dest)
+        # Otherwise assume it's an unboxed, pointerless value and do nothing.
+
+    def emit_dec_ref(
+        self, dest: str, rtype: RType, *, is_xdec: bool = False, rare: bool = False
+    ) -> None:
+        """Decrement reference count of C expression `dest`.
+
+        For composite unboxed structures (e.g. tuples) recursively
+        decrement reference counts for each component.
+
+        If rare is True, optimize for code size and compilation speed.
+        """
+        x = "X" if is_xdec else ""
+        if is_int_rprimitive(rtype):
+            if rare:
+                self.emit_line(f"CPyTagged_{x}DecRef({dest});")
+            else:
+                # Inlined
+                self.emit_line(f"CPyTagged_{x}DECREF({dest});")
+        elif isinstance(rtype, RTuple):
+            for i, item_type in enumerate(rtype.types):
+                self.emit_dec_ref(f"{dest}.f{i}", item_type, is_xdec=is_xdec, rare=rare)
+        elif isinstance(rtype, RVec):
+            # TODO: Only use the X variant if buf can be NULL
+            if rare:
+                self.emit_line(f"CPy_XDecRef({dest}.buf);")
+            else:
+                self.emit_line(f"CPy_XDECREF({dest}.buf);")
+        elif not rtype.is_unboxed:
+            if rare:
+                self.emit_line(f"CPy_{x}DecRef({dest});")
+            else:
+                # Inlined
+                if rtype.may_be_immortal or not HAVE_IMMORTAL:
+                    self.emit_line(f"CPy_{x}DECREF({dest});")
+                else:
+                    self.emit_line(f"CPy_{x}DECREF_NO_IMM({dest});")
+        elif rtype.is_refcounted:
+            assert False, f"dec_ref not implemented for {rtype}"
+        # Otherwise assume it's an unboxed, pointerless value and do nothing.
+
+    def pretty_name(self, typ: RType) -> str:
+        value_type = optional_value_type(typ)
+        if value_type is not None:
+            return "%s or None" % self.pretty_name(value_type)
+        return str(typ)
+
+    def emit_cast(
+        self,
+        src: str,
+        dest: str,
+        typ: RType,
+        *,
+        declare_dest: bool = False,
+        error: ErrorHandler | None = None,
+        raise_exception: bool = True,
+        optional: bool = False,
+        src_type: RType | None = None,
+        likely: bool = True,
+    ) -> None:
+        """Emit code for casting a value of given type.
+
+        Somewhat strangely, this supports unboxed types but only
+        operates on boxed versions.  This is necessary to properly
+        handle types such as Optional[int] in compatibility glue.
+
+        By default, assign NULL (error value) to dest if the value has
+        an incompatible type and raise TypeError. These can be customized
+        using 'error' and 'raise_exception'.
+
+        Always copy/steal the reference in 'src'.
+
+        Args:
+            src: Name of source C variable
+            dest: Name of target C variable
+            typ: Type of value
+            declare_dest: If True, also declare the variable 'dest'
+            error: What happens on error
+            raise_exception: If True, also raise TypeError on failure
+            likely: If the cast is likely to succeed (can be False for unions)
+        """
+        error = error or AssignHandler()
+
+        # Special case casting *from* optional
+        if src_type and is_optional_type(src_type) and not is_object_rprimitive(typ):
+            value_type = optional_value_type(src_type)
+            assert value_type is not None
+            if is_same_type(value_type, typ):
+                if declare_dest:
+                    self.emit_line(f"PyObject *{dest};")
+                check = "({} != Py_None)"
+                if likely:
+                    check = f"(likely{check})"
+                self.emit_arg_check(src, dest, typ, check.format(src), optional)
+                self.emit_lines(f"    {dest} = {src};", "else {")
+                self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+                self.emit_line("}")
+                return
+
+        # TODO: Verify refcount handling.
+        if (
+            is_list_rprimitive(typ)
+            or is_dict_rprimitive(typ)
+            or is_set_rprimitive(typ)
+            or is_frozenset_rprimitive(typ)
+            or is_str_rprimitive(typ)
+            or is_range_rprimitive(typ)
+            or is_float_rprimitive(typ)
+            or is_int_rprimitive(typ)
+            or is_bool_or_bit_rprimitive(typ)
+            or is_fixed_width_rtype(typ)
+        ):
+            if declare_dest:
+                self.emit_line(f"PyObject *{dest};")
+            if is_list_rprimitive(typ):
+                prefix = "PyList"
+            elif is_dict_rprimitive(typ):
+                prefix = "PyDict"
+            elif is_set_rprimitive(typ):
+                prefix = "PySet"
+            elif is_frozenset_rprimitive(typ):
+                prefix = "PyFrozenSet"
+            elif is_str_rprimitive(typ):
+                prefix = "PyUnicode"
+            elif is_range_rprimitive(typ):
+                prefix = "PyRange"
+            elif is_float_rprimitive(typ):
+                prefix = "CPyFloat"
+            elif is_int_rprimitive(typ) or is_fixed_width_rtype(typ):
+                # TODO: Range check for fixed-width types?
+                prefix = "PyLong"
+            elif is_bool_or_bit_rprimitive(typ):
+                prefix = "PyBool"
+            else:
+                assert False, f"unexpected primitive type: {typ}"
+            check = "({}_Check({}))"
+            if likely:
+                check = f"(likely{check})"
+            self.emit_arg_check(src, dest, typ, check.format(prefix, src), optional)
+            self.emit_lines(f"    {dest} = {src};", "else {")
+            self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+            self.emit_line("}")
+        elif is_bytes_rprimitive(typ):
+            if declare_dest:
+                self.emit_line(f"PyObject *{dest};")
+            check = "(PyBytes_Check({}))"
+            if likely:
+                check = f"(likely{check})"
+            self.emit_arg_check(src, dest, typ, check.format(src, src), optional)
+            self.emit_lines(f"    {dest} = {src};", "else {")
+            self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+            self.emit_line("}")
+        elif is_bytearray_rprimitive(typ):
+            if declare_dest:
+                self.emit_line(f"PyObject *{dest};")
+            check = "(PyByteArray_Check({}))"
+            if likely:
+                check = f"(likely{check})"
+            self.emit_arg_check(src, dest, typ, check.format(src, src), optional)
+            self.emit_lines(f"    {dest} = {src};", "else {")
+            self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+            self.emit_line("}")
+        elif is_tuple_rprimitive(typ):
+            if declare_dest:
+                self.emit_line(f"{self.ctype(typ)} {dest};")
+            check = "(PyTuple_Check({}))"
+            if likely:
+                check = f"(likely{check})"
+            self.emit_arg_check(src, dest, typ, check.format(src), optional)
+            self.emit_lines(f"    {dest} = {src};", "else {")
+            self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+            self.emit_line("}")
+        elif isinstance(typ, RInstance):
+            if declare_dest:
+                self.emit_line(f"PyObject *{dest};")
+            concrete = all_concrete_classes(typ.class_ir)
+            # If there are too many concrete subclasses or we can't find any
+            # (meaning the code ought to be dead or we aren't doing global opts),
+            # fall back to a normal typecheck.
+            # Otherwise check all the subclasses.
+            if not concrete or len(concrete) > FAST_ISINSTANCE_MAX_SUBCLASSES + 1:
+                check = "(PyObject_TypeCheck({}, {}))".format(
+                    src, self.type_struct_name(typ.class_ir)
+                )
+            else:
+                full_str = "(Py_TYPE({src}) == {targets[0]})"
+                for i in range(1, len(concrete)):
+                    full_str += " || (Py_TYPE({src}) == {targets[%d]})" % i
+                if len(concrete) > 1:
+                    full_str = "(%s)" % full_str
+                check = full_str.format(
+                    src=src, targets=[self.type_struct_name(ir) for ir in concrete]
+                )
+            if likely:
+                check = f"(likely{check})"
+            self.emit_arg_check(src, dest, typ, check, optional)
+            self.emit_lines(f"    {dest} = {src};", "else {")
+            self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+            self.emit_line("}")
+        elif is_none_rprimitive(typ):
+            if declare_dest:
+                self.emit_line(f"PyObject *{dest};")
+            check = "({} == Py_None)"
+            if likely:
+                check = f"(likely{check})"
+            self.emit_arg_check(src, dest, typ, check.format(src), optional)
+            self.emit_lines(f"    {dest} = {src};", "else {")
+            self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+            self.emit_line("}")
+        elif is_object_rprimitive(typ):
+            if declare_dest:
+                self.emit_line(f"PyObject *{dest};")
+            self.emit_arg_check(src, dest, typ, "", optional)
+            self.emit_line(f"{dest} = {src};")
+            if optional:
+                self.emit_line("}")
+        elif is_native_rprimitive(typ):
+            # Native primitive types have type check functions of form "CPy<Name>_Check(...)".
+            if declare_dest:
+                self.emit_line(f"PyObject *{dest};")
+            short_name = typ.name.rsplit(".", 1)[-1]
+            check = f"(CPy{short_name}_Check({src}))"
+            if likely:
+                check = f"(likely{check})"
+            self.emit_arg_check(src, dest, typ, check, optional)
+            self.emit_lines(f"    {dest} = {src};", "else {")
+            self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+            self.emit_line("}")
+        elif isinstance(typ, RUnion):
+            self.emit_union_cast(
+                src, dest, typ, declare_dest, error, optional, src_type, raise_exception
+            )
+        elif isinstance(typ, RTuple):
+            assert not optional
+            self.emit_tuple_cast(src, dest, typ, declare_dest, error, src_type)
+        elif isinstance(typ, RVec):
+            if declare_dest:
+                self.emit_line(f"PyObject *{dest};")
+            # Build type check expression based on vec kind
+            api_name = vec_api_by_item_type.get(typ.item_type)
+            depth = typ.depth()
+            if api_name:
+                # Specialized vec types (vec[i64], vec[i32], etc.)
+                check = f"(Py_TYPE({src}) == {api_name}.boxed_type)"
+            elif depth == 0:
+                # Generic vec types (vec[T], vec[T | None]) with reference type items
+                item_type_c = self.vec_item_type_c(typ)
+                check = (
+                    f"(Py_TYPE({src}) == VecTApi.boxed_type && "
+                    f"((VecTObject *){src})->vec.buf->item_type == {item_type_c})"
+                )
+            else:
+                # Nested vec types (vec[vec[...]]). Check boxed type, item type, and depth.
+                unwrapped = typ.unwrap_item_type()
+                if unwrapped in vec_item_type_tags:
+                    type_value = str(vec_item_type_tags[unwrapped])
+                else:
+                    type_value = self.vec_item_type_c(typ)
+                check = (
+                    f"(Py_TYPE({src}) == VecNestedApi.boxed_type && "
+                    f"((VecNestedObject *){src})->vec.buf->item_type == {type_value} && "
+                    f"((VecNestedObject *){src})->vec.buf->depth == {depth})"
+                )
+            if likely:
+                check = f"(likely{check})"
+            self.emit_arg_check(src, dest, typ, check, optional)
+            self.emit_lines(f"    {dest} = {src};", "else {")
+            self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+            self.emit_line("}")
+        else:
+            assert False, "Cast not implemented: %s" % typ
+
+    def emit_cast_error_handler(
+        self, error: ErrorHandler, src: str, dest: str, typ: RType, raise_exception: bool
+    ) -> None:
+        if raise_exception:
+            if isinstance(error, TracebackAndGotoHandler):
+                # Merge raising and emitting traceback entry into a single call.
+                self.emit_type_error_traceback(
+                    error.source_path, error.module_name, error.traceback_entry, typ=typ, src=src
+                )
+                self.emit_line("goto %s;" % error.label)
+                return
+            self.emit_line(f'CPy_TypeError("{self.pretty_name(typ)}", {src}); ')
+        if isinstance(error, AssignHandler):
+            self.emit_line("%s = NULL;" % dest)
+        elif isinstance(error, GotoHandler):
+            self.emit_line("goto %s;" % error.label)
+        elif isinstance(error, TracebackAndGotoHandler):
+            self.emit_line("%s = NULL;" % dest)
+            self.emit_traceback(error.source_path, error.module_name, error.traceback_entry)
+            self.emit_line("goto %s;" % error.label)
+        else:
+            assert isinstance(error, ReturnHandler), error
+            self.emit_line("return %s;" % error.value)
+
+    def emit_union_cast(
+        self,
+        src: str,
+        dest: str,
+        typ: RUnion,
+        declare_dest: bool,
+        error: ErrorHandler,
+        optional: bool,
+        src_type: RType | None,
+        raise_exception: bool,
+    ) -> None:
+        """Emit cast to a union type.
+
+        The arguments are similar to emit_cast.
+        """
+        if declare_dest:
+            self.emit_line(f"PyObject *{dest};")
+        good_label = self.new_label()
+        if optional:
+            self.emit_line(f"if ({src} == NULL) {{")
+            self.emit_line(f"{dest} = {self.c_error_value(typ)};")
+            self.emit_line(f"goto {good_label};")
+            self.emit_line("}")
+        for item in typ.items:
+            self.emit_cast(
+                src,
+                dest,
+                item,
+                declare_dest=False,
+                raise_exception=False,
+                optional=False,
+                likely=False,
+            )
+            self.emit_line(f"if ({dest} != NULL) goto {good_label};")
+        # Handle cast failure.
+        self.emit_cast_error_handler(error, src, dest, typ, raise_exception)
+        self.emit_label(good_label)
+
+    def emit_tuple_cast(
+        self,
+        src: str,
+        dest: str,
+        typ: RTuple,
+        declare_dest: bool,
+        error: ErrorHandler,
+        src_type: RType | None,
+    ) -> None:
+        """Emit cast to a tuple type.
+
+        The arguments are similar to emit_cast.
+        """
+        if declare_dest:
+            self.emit_line(f"PyObject *{dest};")
+        # This reuse of the variable is super dodgy. We don't even
+        # care about the values except to check whether they are
+        # invalid.
+        out_label = self.new_label()
+        self.emit_lines(
+            "if (unlikely(!(PyTuple_Check({r}) && PyTuple_GET_SIZE({r}) == {size}))) {{".format(
+                r=src, size=len(typ.types)
+            ),
+            f"{dest} = NULL;",
+            f"goto {out_label};",
+            "}",
+        )
+        for i, item in enumerate(typ.types):
+            # Since we did the checks above this should never fail
+            self.emit_cast(
+                f"PyTuple_GET_ITEM({src}, {i})",
+                dest,
+                item,
+                declare_dest=False,
+                raise_exception=False,
+                optional=False,
+            )
+            self.emit_line(f"if ({dest} == NULL) goto {out_label};")
+
+        self.emit_line(f"{dest} = {src};")
+        self.emit_label(out_label)
+
+    def emit_arg_check(self, src: str, dest: str, typ: RType, check: str, optional: bool) -> None:
+        if optional:
+            self.emit_line(f"if ({src} == NULL) {{")
+            self.emit_line(f"{dest} = {self.c_error_value(typ)};")
+        if check != "":
+            self.emit_line("{}if {}".format("} else " if optional else "", check))
+        elif optional:
+            self.emit_line("else {")
+
+    def emit_unbox(
+        self,
+        src: str,
+        dest: str,
+        typ: RType,
+        *,
+        declare_dest: bool = False,
+        error: ErrorHandler | None = None,
+        raise_exception: bool = True,
+        optional: bool = False,
+        borrow: bool = False,
+    ) -> None:
+        """Emit code for unboxing a value of given type (from PyObject *).
+
+        By default, assign error value to dest if the value has an
+        incompatible type and raise TypeError. These can be customized
+        using 'error' and 'raise_exception'.
+
+        Generate a new reference unless 'borrow' is True.
+
+        Args:
+            src: Name of source C variable
+            dest: Name of target C variable
+            typ: Type of value
+            declare_dest: If True, also declare the variable 'dest'
+            error: What happens on error
+            raise_exception: If True, also raise TypeError on failure
+            optional: If True, NULL src value is allowed and will map to error value
+            borrow: If True, create a borrowed reference
+
+        """
+        error = error or AssignHandler()
+        # TODO: Verify refcount handling.
+        if isinstance(error, AssignHandler):
+            failure = f"{dest} = {self.c_error_value(typ)};"
+        elif isinstance(error, GotoHandler):
+            failure = "goto %s;" % error.label
+        else:
+            assert isinstance(error, ReturnHandler), error
+            failure = "return %s;" % error.value
+        if raise_exception:
+            raise_exc = f'CPy_TypeError("{self.pretty_name(typ)}", {src}); '
+            failure = raise_exc + failure
+        if is_int_rprimitive(typ) or is_short_int_rprimitive(typ):
+            if declare_dest:
+                self.emit_line(f"CPyTagged {dest};")
+            self.emit_arg_check(src, dest, typ, f"(likely(PyLong_Check({src})))", optional)
+            if borrow:
+                self.emit_line(f"    {dest} = CPyTagged_BorrowFromObject({src});")
+            else:
+                self.emit_line(f"    {dest} = CPyTagged_FromObject({src});")
+            self.emit_line("else {")
+            self.emit_line(failure)
+            self.emit_line("}")
+        elif is_bool_or_bit_rprimitive(typ):
+            # Whether we are borrowing or not makes no difference.
+            if declare_dest:
+                self.emit_line(f"char {dest};")
+            self.emit_arg_check(src, dest, typ, f"(unlikely(!PyBool_Check({src}))) {{", optional)
+            self.emit_line(failure)
+            self.emit_line("} else")
+            conversion = f"{src} == Py_True"
+            self.emit_line(f"    {dest} = {conversion};")
+        elif is_none_rprimitive(typ):
+            # Whether we are borrowing or not makes no difference.
+            if declare_dest:
+                self.emit_line(f"char {dest};")
+            self.emit_arg_check(src, dest, typ, f"(unlikely({src} != Py_None)) {{", optional)
+            self.emit_line(failure)
+            self.emit_line("} else")
+            self.emit_line(f"    {dest} = 1;")
+        elif is_int64_rprimitive(typ):
+            # Whether we are borrowing or not makes no difference.
+            assert not optional  # Not supported for overlapping error values
+            if declare_dest:
+                self.emit_line(f"int64_t {dest};")
+            self.emit_line(f"{dest} = CPyLong_AsInt64({src});")
+            if not isinstance(error, AssignHandler):
+                self.emit_unbox_failure_with_overlapping_error_value(dest, typ, failure)
+        elif is_int32_rprimitive(typ):
+            # Whether we are borrowing or not makes no difference.
+            assert not optional  # Not supported for overlapping error values
+            if declare_dest:
+                self.emit_line(f"int32_t {dest};")
+            self.emit_line(f"{dest} = CPyLong_AsInt32({src});")
+            if not isinstance(error, AssignHandler):
+                self.emit_unbox_failure_with_overlapping_error_value(dest, typ, failure)
+        elif is_int16_rprimitive(typ):
+            # Whether we are borrowing or not makes no difference.
+            assert not optional  # Not supported for overlapping error values
+            if declare_dest:
+                self.emit_line(f"int16_t {dest};")
+            self.emit_line(f"{dest} = CPyLong_AsInt16({src});")
+            if not isinstance(error, AssignHandler):
+                self.emit_unbox_failure_with_overlapping_error_value(dest, typ, failure)
+        elif is_uint8_rprimitive(typ):
+            # Whether we are borrowing or not makes no difference.
+            assert not optional  # Not supported for overlapping error values
+            if declare_dest:
+                self.emit_line(f"uint8_t {dest};")
+            self.emit_line(f"{dest} = CPyLong_AsUInt8({src});")
+            if not isinstance(error, AssignHandler):
+                self.emit_unbox_failure_with_overlapping_error_value(dest, typ, failure)
+        elif is_float_rprimitive(typ):
+            assert not optional  # Not supported for overlapping error values
+            if declare_dest:
+                self.emit_line(f"double {dest};")
+            # TODO: Don't use __float__ and __index__
+            self.emit_line(f"{dest} = PyFloat_AsDouble({src});")
+            self.emit_lines(f"if ({dest} == -1.0 && PyErr_Occurred()) {{", failure, "}")
+        elif isinstance(typ, RTuple):
+            self.declare_tuple_struct(typ)
+            if declare_dest:
+                self.emit_line(f"{self.ctype(typ)} {dest};")
+            # HACK: The error handling for unboxing tuples is busted
+            # and instead of fixing it I am just wrapping it in the
+            # cast code which I think is right. This is not good.
+            if optional:
+                self.emit_line(f"if ({src} == NULL) {{")
+                self.emit_line(f"{dest} = {self.c_error_value(typ)};")
+                self.emit_line("} else {")
+
+            cast_temp = self.temp_name()
+            self.emit_tuple_cast(
+                src, cast_temp, typ, declare_dest=True, error=error, src_type=None
+            )
+            self.emit_line(f"if (unlikely({cast_temp} == NULL)) {{")
+
+            # self.emit_arg_check(src, dest, typ,
+            #     '(!PyTuple_Check({}) || PyTuple_Size({}) != {}) {{'.format(
+            #         src, src, len(typ.types)), optional)
+            self.emit_line(failure)  # TODO: Decrease refcount?
+            self.emit_line("} else {")
+            if not typ.types:
+                self.emit_line(f"{dest}.empty_struct_error_flag = 0;")
+            for i, item_type in enumerate(typ.types):
+                temp = self.temp_name()
+                # emit_tuple_cast above checks the size, so this should not fail
+                self.emit_line(f"PyObject *{temp} = PyTuple_GET_ITEM({src}, {i});")
+                temp2 = self.temp_name()
+                # Unbox or check the item.
+                if item_type.is_unboxed:
+                    self.emit_unbox(
+                        temp,
+                        temp2,
+                        item_type,
+                        raise_exception=raise_exception,
+                        error=error,
+                        declare_dest=True,
+                        borrow=borrow,
+                    )
+                else:
+                    if not borrow:
+                        self.emit_inc_ref(temp, object_rprimitive)
+                    self.emit_cast(temp, temp2, item_type, declare_dest=True)
+                self.emit_line(f"{dest}.f{i} = {temp2};")
+            self.emit_line("}")
+            if optional:
+                self.emit_line("}")
+        elif isinstance(typ, RVec):
+            if declare_dest:
+                self.emit_line(f"{self.ctype(typ)} {dest};")
+
+            if optional:
+                self.emit_line(f"if ({src} == NULL) {{")
+                self.emit_line(f"{dest} = {self.c_error_value(typ)};")
+                self.emit_line("} else {")
+
+            specialized_api_name = vec_api_by_item_type.get(typ.item_type)
+            if specialized_api_name is not None:
+                self.emit_line(f"{dest} = {specialized_api_name}.unbox({src});")
+            else:
+                depth = typ.depth()
+                unwrapped = typ.unwrap_item_type()
+                if unwrapped in vec_item_type_tags:
+                    type_value = str(vec_item_type_tags[unwrapped])
+                else:
+                    type_value = self.vec_item_type_c(typ)
+                if depth == 0:
+                    self.emit_line(f"{dest} = VecTApi.unbox({src}, {type_value});")
+                else:
+                    self.emit_line(f"{dest} = VecNestedApi.unbox({src}, {type_value}, {depth});")
+
+            self.emit_line(f"if (VEC_IS_ERROR({dest})) {{")
+            self.emit_line(failure)
+            self.emit_line("}")
+
+            if optional:
+                self.emit_line("}")
+        else:
+            assert False, "Unboxing not implemented: %s" % typ
+
+    def vec_item_type_c(self, typ: RVec) -> str:
+        item_type = typ.unwrap_item_type()
+        type_c_ptr = self.type_c_ptr(item_type)
+        # Can never be None, since we unwrapped the item type above
+        assert type_c_ptr is not None
+        type_value = f"(size_t){type_c_ptr}"
+        if typ.is_optional():
+            type_value = f"({type_value} | 1)"
+        return type_value
+
+    def type_c_ptr(self, typ: RPrimitive | RInstance) -> str | None:
+        if isinstance(typ, RPrimitive) and typ.is_refcounted:
+            return "&" + builtin_names[typ.name][1]
+        elif isinstance(typ, RInstance):
+            return self.type_struct_name(typ.class_ir)
+        return None
+
+    def emit_box(
+        self, src: str, dest: str, typ: RType, declare_dest: bool = False, can_borrow: bool = False
+    ) -> None:
+        """Emit code for boxing a value of given type.
+
+        Generate a simple assignment if no boxing is needed.
+
+        The source reference count is stolen for the result (no need to decref afterwards).
+        """
+        # TODO: Always generate a new reference (if a reference type)
+        if declare_dest:
+            declaration = "PyObject *"
+        else:
+            declaration = ""
+        if is_int_rprimitive(typ) or is_short_int_rprimitive(typ):
+            # Steal the existing reference if it exists.
+            self.emit_line(f"{declaration}{dest} = CPyTagged_StealAsObject({src});")
+        elif is_bool_or_bit_rprimitive(typ):
+            # N.B: bool is special cased to produce a borrowed value
+            # after boxing, so we don't need to increment the refcount
+            # when this comes directly from a Box op.
+            self.emit_lines(f"{declaration}{dest} = {src} ? Py_True : Py_False;")
+            if not can_borrow:
+                self.emit_inc_ref(dest, object_rprimitive)
+        elif is_none_rprimitive(typ):
+            # N.B: None is special cased to produce a borrowed value
+            # after boxing, so we don't need to increment the refcount
+            # when this comes directly from a Box op.
+            self.emit_lines(f"{declaration}{dest} = Py_None;")
+            if not can_borrow:
+                self.emit_inc_ref(dest, object_rprimitive)
+        elif is_int32_rprimitive(typ) or is_int16_rprimitive(typ) or is_uint8_rprimitive(typ):
+            self.emit_line(f"{declaration}{dest} = PyLong_FromLong({src});")
+        elif is_int64_rprimitive(typ):
+            self.emit_line(f"{declaration}{dest} = PyLong_FromLongLong({src});")
+        elif is_float_rprimitive(typ):
+            self.emit_line(f"{declaration}{dest} = PyFloat_FromDouble({src});")
+        elif isinstance(typ, RTuple):
+            self.declare_tuple_struct(typ)
+            if not typ.types:
+                self.emit_line(f"{declaration}{dest} = CPyTuple_LoadEmptyTupleConstant();")
+            else:
+                self.emit_line(f"{declaration}{dest} = PyTuple_New({len(typ.types)});")
+                self.emit_line(f"if (unlikely({dest} == NULL))")
+                self.emit_line("    CPyError_OutOfMemory();")
+
+                # TODO: Fail if dest is None
+                for i in range(len(typ.types)):
+                    if not typ.is_unboxed:
+                        self.emit_line(f"PyTuple_SET_ITEM({dest}, {i}, {src}.f{i}")
+                    else:
+                        inner_name = self.temp_name()
+                        self.emit_box(f"{src}.f{i}", inner_name, typ.types[i], declare_dest=True)
+                        self.emit_line(f"PyTuple_SET_ITEM({dest}, {i}, {inner_name});")
+        elif isinstance(typ, RVec):
+            specialized_api_name = vec_api_by_item_type.get(typ.item_type)
+            if specialized_api_name is not None:
+                api = specialized_api_name
+            elif typ.depth() > 0:
+                api = "VecNestedApi"
+            else:
+                api = "VecTApi"
+                # Empty vecs of this sort don't describe item type, so it needs to be
+                # passed explicitly.
+                item_type = self.vec_item_type_c(typ)
+                self.emit_line(f"{declaration}{dest} = {api}.box({src}, {item_type});")
+                return
+            self.emit_line(f"{declaration}{dest} = {api}.box({src});")
+        else:
+            assert not typ.is_unboxed
+            # Type is boxed -- trivially just assign.
+            self.emit_line(f"{declaration}{dest} = {src};")
+
+    def emit_error_check(self, value: str, rtype: RType, failure: str) -> None:
+        """Emit code for checking a native function return value for uncaught exception."""
+        if isinstance(rtype, RTuple):
+            if len(rtype.types) == 0:
+                return  # empty tuples can't fail.
+            else:
+                cond = self.tuple_undefined_check_cond(rtype, value, self.c_error_value, "==")
+                self.emit_line(f"if ({cond}) {{")
+        elif isinstance(rtype, RVec):
+            self.emit_line(f"if ({value}.len < 0) {{")
+        elif rtype.error_overlap:
+            # The error value is also valid as a normal value, so we need to also check
+            # for a raised exception.
+            self.emit_line(f"if ({value} == {self.c_error_value(rtype)} && PyErr_Occurred()) {{")
+        else:
+            self.emit_line(f"if ({value} == {self.c_error_value(rtype)}) {{")
+        self.emit_lines(failure, "}")
+
+    def emit_gc_visit(self, target: str, rtype: RType) -> None:
+        """Emit code for GC visiting a C variable reference.
+
+        Assume that 'target' represents a C expression that refers to a
+        struct member, such as 'self->x'.
+        """
+        if not rtype.is_refcounted:
+            # Not refcounted -> no pointers -> no GC interaction.
+            return
+        elif isinstance(rtype, RPrimitive) and rtype.name == "builtins.int":
+            self.emit_line(f"if (CPyTagged_CheckLong({target})) {{")
+            self.emit_line(f"Py_VISIT(CPyTagged_LongAsObject({target}));")
+            self.emit_line("}")
+        elif isinstance(rtype, RTuple):
+            for i, item_type in enumerate(rtype.types):
+                self.emit_gc_visit(f"{target}.f{i}", item_type)
+        elif isinstance(rtype, RVec):
+            self.emit_line(f"Py_VISIT({target}.buf);")
+        elif self.ctype(rtype) == "PyObject *":
+            # The simplest case.
+            self.emit_line(f"Py_VISIT({target});")
+        else:
+            assert False, "emit_gc_visit() not implemented for %s" % repr(rtype)
+
+    def emit_gc_clear(self, target: str, rtype: RType) -> None:
+        """Emit code for clearing a C attribute reference for GC.
+
+        Assume that 'target' represents a C expression that refers to a
+        struct member, such as 'self->x'.
+        """
+        if not rtype.is_refcounted:
+            # Not refcounted -> no pointers -> no GC interaction.
+            return
+        elif isinstance(rtype, RPrimitive) and rtype.name == "builtins.int":
+            self.emit_line(f"if (CPyTagged_CheckLong({target})) {{")
+            self.emit_line(f"CPyTagged __tmp = {target};")
+            self.emit_line(f"{target} = {self.c_undefined_value(rtype)};")
+            self.emit_line("Py_XDECREF(CPyTagged_LongAsObject(__tmp));")
+            self.emit_line("}")
+        elif isinstance(rtype, RTuple):
+            for i, item_type in enumerate(rtype.types):
+                self.emit_gc_clear(f"{target}.f{i}", item_type)
+        elif isinstance(rtype, RVec):
+            self.emit_line(f"Py_CLEAR({target}.buf);")
+        elif self.ctype(rtype) == "PyObject *" and self.c_undefined_value(rtype) == "NULL":
+            # The simplest case.
+            self.emit_line(f"Py_CLEAR({target});")
+        else:
+            assert False, "emit_gc_clear() not implemented for %s" % repr(rtype)
+
+    def emit_reuse_clear(self, target: str, rtype: RType) -> None:
+        """Emit attribute clear before object is added into freelist.
+
+        Assume that 'target' represents a C expression that refers to a
+        struct member, such as 'self->x'.
+
+        Unlike emit_gc_clear(), initialize attribute value to match a freshly
+        allocated object.
+        """
+        if isinstance(rtype, RTuple):
+            for i, item_type in enumerate(rtype.types):
+                self.emit_reuse_clear(f"{target}.f{i}", item_type)
+        elif not rtype.is_refcounted:
+            self.emit_line(f"{target} = {rtype.c_undefined};")
+        elif isinstance(rtype, RPrimitive) and rtype.name == "builtins.int":
+            self.emit_line(f"if (CPyTagged_CheckLong({target})) {{")
+            self.emit_line(f"CPyTagged __tmp = {target};")
+            self.emit_line(f"{target} = {self.c_undefined_value(rtype)};")
+            self.emit_line("Py_XDECREF(CPyTagged_LongAsObject(__tmp));")
+            self.emit_line("} else {")
+            self.emit_line(f"{target} = {self.c_undefined_value(rtype)};")
+            self.emit_line("}")
+        else:
+            self.emit_gc_clear(target, rtype)
+
+    def emit_traceback(
+        self, source_path: str, module_name: str, traceback_entry: tuple[str, int]
+    ) -> None:
+        return self._emit_traceback("CPy_AddTraceback", source_path, module_name, traceback_entry)
+
+    def emit_type_error_traceback(
+        self,
+        source_path: str,
+        module_name: str,
+        traceback_entry: tuple[str, int],
+        *,
+        typ: RType,
+        src: str,
+    ) -> None:
+        func = "CPy_TypeErrorTraceback"
+        type_str = f'"{self.pretty_name(typ)}"'
+        return self._emit_traceback(
+            func, source_path, module_name, traceback_entry, type_str=type_str, src=src
+        )
+
+    def _emit_traceback(
+        self,
+        func: str,
+        source_path: str,
+        module_name: str,
+        traceback_entry: tuple[str, int],
+        type_str: str = "",
+        src: str = "",
+    ) -> None:
+        if self.context.strict_traceback_checks:
+            assert traceback_entry[1] >= 0, "Traceback cannot have a negative line number"
+        globals_static = self.static_name("globals", module_name)
+        line = '%s("%s", "%s", %d, %s' % (
+            func,
+            source_path.replace("\\", "\\\\"),
+            traceback_entry[0],
+            traceback_entry[1],
+            globals_static,
+        )
+        if type_str:
+            assert src
+            line += f", {type_str}, {src}"
+        line += ");"
+        self.emit_line(line)
+        if DEBUG_ERRORS:
+            self.emit_line('assert(PyErr_Occurred() != NULL && "failure w/o err!");')
+
+    def emit_unbox_failure_with_overlapping_error_value(
+        self, dest: str, typ: RType, failure: str
+    ) -> None:
+        self.emit_line(f"if ({dest} == {self.c_error_value(typ)} && PyErr_Occurred()) {{")
+        self.emit_line(failure)
+        self.emit_line("}")
+
+    def emit_cpyfunction_instance(
+        self, fn: FuncIR, name: str, filepath: str, error_stmt: str
+    ) -> str:
+        module = self.static_name(fn.decl.module_name, None, prefix=MODULE_PREFIX)
+        cname = f"{PREFIX}{fn.cname(self.names)}"
+        wrapper_name = f"{cname}_wrapper"
+        cfunc = f"(PyCFunction){cname}"
+        func_flags = "METH_FASTCALL | METH_KEYWORDS"
+        doc = f"PyDoc_STR({native_function_doc_initializer(fn)})"
+        has_self_arg = "true" if fn.class_name and fn.decl.kind != FUNC_STATICMETHOD else "false"
+
+        code_flags = "CO_COROUTINE"
+        self.emit_line(
+            f'PyObject* {wrapper_name} = CPyFunction_New({module}, "{filepath}", "{name}", {cfunc}, {func_flags}, {doc}, {fn.line}, {code_flags}, {has_self_arg});'
+        )
+        self.emit_line(f"if (unlikely(!{wrapper_name}))")
+        self.emit_line(error_stmt)
+        return wrapper_name
+
+
+def c_array_initializer(components: list[str], *, indented: bool = False) -> str:
+    """Construct an initializer for a C array variable.
+
+    Components are C expressions valid in an initializer.
+
+    For example, if components are ["1", "2"], the result
+    would be "{1, 2}", which can be used like this:
+
+        int a[] = {1, 2};
+
+    If the result is long, split it into multiple lines.
+    """
+    indent = " " * 4 if indented else ""
+    res = []
+    current: list[str] = []
+    cur_len = 0
+    for c in components:
+        if not current or cur_len + 2 + len(indent) + len(c) < 70:
+            current.append(c)
+            cur_len += len(c) + 2
+        else:
+            res.append(indent + ", ".join(current))
+            current = [c]
+            cur_len = len(c)
+    if not res:
+        # Result fits on a single line
+        return "{%s}" % ", ".join(current)
+    # Multi-line result
+    res.append(indent + ", ".join(current))
+    return "{\n    " + ",\n    ".join(res) + "\n" + indent + "}"
+
+
+def native_function_doc_initializer(func: FuncIR) -> str:
+    text_sig = get_text_signature(func)
+    if text_sig is None:
+        return "NULL"
+    docstring = f"{text_sig}\n--\n\n"
+    return c_string_initializer(docstring.encode("ascii", errors="backslashreplace"))

micromamba_root/Lib/site-packages/mypyc/codegen/emitclass.py

@@ -0,0 +1,1326 @@
+"""Code generation for native classes and related wrappers."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Mapping
+
+from mypy.nodes import ARG_STAR, ARG_STAR2
+from mypyc.codegen.cstring import c_string_initializer
+from mypyc.codegen.emit import (
+    Emitter,
+    HeaderDeclaration,
+    ReturnHandler,
+    native_function_doc_initializer,
+)
+from mypyc.codegen.emitfunc import native_function_header
+from mypyc.codegen.emitwrapper import (
+    generate_bin_op_wrapper,
+    generate_bool_wrapper,
+    generate_contains_wrapper,
+    generate_dunder_wrapper,
+    generate_get_wrapper,
+    generate_hash_wrapper,
+    generate_ipow_wrapper,
+    generate_len_wrapper,
+    generate_richcompare_wrapper,
+    generate_set_del_item_wrapper,
+)
+from mypyc.common import (
+    BITMAP_BITS,
+    BITMAP_TYPE,
+    CPYFUNCTION_NAME,
+    NATIVE_PREFIX,
+    PREFIX,
+    REG_PREFIX,
+    short_id_from_name,
+)
+from mypyc.ir.class_ir import ClassIR, VTableEntries
+from mypyc.ir.func_ir import (
+    FUNC_CLASSMETHOD,
+    FUNC_STATICMETHOD,
+    FuncDecl,
+    FuncIR,
+    get_text_signature,
+)
+from mypyc.ir.rtypes import RTuple, RType, object_rprimitive
+from mypyc.namegen import NameGenerator
+from mypyc.sametype import is_same_type
+
+
+def native_slot(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    return f"{NATIVE_PREFIX}{fn.cname(emitter.names)}"
+
+
+def dunder_attr_slot(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    wrapper_fn = cl.get_method(fn.name + "__wrapper")
+    assert wrapper_fn
+    return f"{NATIVE_PREFIX}{wrapper_fn.cname(emitter.names)}"
+
+
+# We maintain a table from dunder function names to struct slots they
+# correspond to and functions that generate a wrapper (if necessary)
+# and return the function name to stick in the slot.
+# TODO: Add remaining dunder methods
+SlotGenerator = Callable[[ClassIR, FuncIR, Emitter], str]
+SlotTable = Mapping[str, tuple[str, SlotGenerator]]
+
+SLOT_DEFS: SlotTable = {
+    "__init__": ("tp_init", lambda c, t, e: generate_init_for_class(c, t, e)),
+    "__call__": ("tp_call", lambda c, t, e: generate_call_wrapper(c, t, e)),
+    "__str__": ("tp_str", native_slot),
+    "__repr__": ("tp_repr", native_slot),
+    "__next__": ("tp_iternext", native_slot),
+    "__iter__": ("tp_iter", native_slot),
+    "__hash__": ("tp_hash", generate_hash_wrapper),
+    "__get__": ("tp_descr_get", generate_get_wrapper),
+    "__getattr__": ("tp_getattro", dunder_attr_slot),
+    "__setattr__": ("tp_setattro", dunder_attr_slot),
+}
+
+AS_MAPPING_SLOT_DEFS: SlotTable = {
+    "__getitem__": ("mp_subscript", generate_dunder_wrapper),
+    "__setitem__": ("mp_ass_subscript", generate_set_del_item_wrapper),
+    "__delitem__": ("mp_ass_subscript", generate_set_del_item_wrapper),
+    "__len__": ("mp_length", generate_len_wrapper),
+}
+
+AS_SEQUENCE_SLOT_DEFS: SlotTable = {"__contains__": ("sq_contains", generate_contains_wrapper)}
+
+AS_NUMBER_SLOT_DEFS: SlotTable = {
+    # Unary operations.
+    "__bool__": ("nb_bool", generate_bool_wrapper),
+    "__int__": ("nb_int", generate_dunder_wrapper),
+    "__float__": ("nb_float", generate_dunder_wrapper),
+    "__neg__": ("nb_negative", generate_dunder_wrapper),
+    "__pos__": ("nb_positive", generate_dunder_wrapper),
+    "__abs__": ("nb_absolute", generate_dunder_wrapper),
+    "__invert__": ("nb_invert", generate_dunder_wrapper),
+    # Binary operations.
+    "__add__": ("nb_add", generate_bin_op_wrapper),
+    "__radd__": ("nb_add", generate_bin_op_wrapper),
+    "__sub__": ("nb_subtract", generate_bin_op_wrapper),
+    "__rsub__": ("nb_subtract", generate_bin_op_wrapper),
+    "__mul__": ("nb_multiply", generate_bin_op_wrapper),
+    "__rmul__": ("nb_multiply", generate_bin_op_wrapper),
+    "__mod__": ("nb_remainder", generate_bin_op_wrapper),
+    "__rmod__": ("nb_remainder", generate_bin_op_wrapper),
+    "__truediv__": ("nb_true_divide", generate_bin_op_wrapper),
+    "__rtruediv__": ("nb_true_divide", generate_bin_op_wrapper),
+    "__floordiv__": ("nb_floor_divide", generate_bin_op_wrapper),
+    "__rfloordiv__": ("nb_floor_divide", generate_bin_op_wrapper),
+    "__divmod__": ("nb_divmod", generate_bin_op_wrapper),
+    "__rdivmod__": ("nb_divmod", generate_bin_op_wrapper),
+    "__lshift__": ("nb_lshift", generate_bin_op_wrapper),
+    "__rlshift__": ("nb_lshift", generate_bin_op_wrapper),
+    "__rshift__": ("nb_rshift", generate_bin_op_wrapper),
+    "__rrshift__": ("nb_rshift", generate_bin_op_wrapper),
+    "__and__": ("nb_and", generate_bin_op_wrapper),
+    "__rand__": ("nb_and", generate_bin_op_wrapper),
+    "__or__": ("nb_or", generate_bin_op_wrapper),
+    "__ror__": ("nb_or", generate_bin_op_wrapper),
+    "__xor__": ("nb_xor", generate_bin_op_wrapper),
+    "__rxor__": ("nb_xor", generate_bin_op_wrapper),
+    "__matmul__": ("nb_matrix_multiply", generate_bin_op_wrapper),
+    "__rmatmul__": ("nb_matrix_multiply", generate_bin_op_wrapper),
+    # In-place binary operations.
+    "__iadd__": ("nb_inplace_add", generate_dunder_wrapper),
+    "__isub__": ("nb_inplace_subtract", generate_dunder_wrapper),
+    "__imul__": ("nb_inplace_multiply", generate_dunder_wrapper),
+    "__imod__": ("nb_inplace_remainder", generate_dunder_wrapper),
+    "__itruediv__": ("nb_inplace_true_divide", generate_dunder_wrapper),
+    "__ifloordiv__": ("nb_inplace_floor_divide", generate_dunder_wrapper),
+    "__ilshift__": ("nb_inplace_lshift", generate_dunder_wrapper),
+    "__irshift__": ("nb_inplace_rshift", generate_dunder_wrapper),
+    "__iand__": ("nb_inplace_and", generate_dunder_wrapper),
+    "__ior__": ("nb_inplace_or", generate_dunder_wrapper),
+    "__ixor__": ("nb_inplace_xor", generate_dunder_wrapper),
+    "__imatmul__": ("nb_inplace_matrix_multiply", generate_dunder_wrapper),
+    # Ternary operations. (yes, really)
+    # These are special cased in generate_bin_op_wrapper().
+    "__pow__": ("nb_power", generate_bin_op_wrapper),
+    "__rpow__": ("nb_power", generate_bin_op_wrapper),
+    "__ipow__": ("nb_inplace_power", generate_ipow_wrapper),
+}
+
+AS_ASYNC_SLOT_DEFS: SlotTable = {
+    "__await__": ("am_await", native_slot),
+    "__aiter__": ("am_aiter", native_slot),
+    "__anext__": ("am_anext", native_slot),
+}
+
+SIDE_TABLES = [
+    ("as_mapping", "PyMappingMethods", AS_MAPPING_SLOT_DEFS),
+    ("as_sequence", "PySequenceMethods", AS_SEQUENCE_SLOT_DEFS),
+    ("as_number", "PyNumberMethods", AS_NUMBER_SLOT_DEFS),
+    ("as_async", "PyAsyncMethods", AS_ASYNC_SLOT_DEFS),
+]
+
+# Slots that need to always be filled in because they don't get
+# inherited right.
+ALWAYS_FILL = {"__hash__"}
+
+
+def generate_call_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    return "PyVectorcall_Call"
+
+
+def slot_key(attr: str) -> str:
+    """Map dunder method name to sort key.
+
+    Sort reverse operator methods and __delitem__ after others ('x' > '_').
+    """
+    if (attr.startswith("__r") and attr != "__rshift__") or attr == "__delitem__":
+        return "x" + attr
+    return attr
+
+
+def generate_slots(cl: ClassIR, table: SlotTable, emitter: Emitter) -> dict[str, str]:
+    fields: dict[str, str] = {}
+    generated: dict[str, str] = {}
+    # Sort for determinism on Python 3.5
+    for name, (slot, generator) in sorted(table.items(), key=lambda x: slot_key(x[0])):
+        method_cls = cl.get_method_and_class(name)
+        if method_cls and (method_cls[1] == cl or name in ALWAYS_FILL):
+            if slot in generated:
+                # Reuse previously generated wrapper.
+                fields[slot] = generated[slot]
+            else:
+                # Generate new wrapper.
+                name = generator(cl, method_cls[0], emitter)
+                fields[slot] = name
+                generated[slot] = name
+
+    return fields
+
+
+def generate_class_type_decl(
+    cl: ClassIR, c_emitter: Emitter, external_emitter: Emitter, emitter: Emitter
+) -> None:
+    context = c_emitter.context
+    name = emitter.type_struct_name(cl)
+    context.declarations[name] = HeaderDeclaration(
+        f"PyTypeObject *{emitter.type_struct_name(cl)};", needs_export=True
+    )
+
+    # If this is a non-extension class, all we want is the type object decl.
+    if not cl.is_ext_class:
+        return
+
+    generate_object_struct(cl, external_emitter)
+    generate_full = not cl.is_trait and not cl.builtin_base
+    if generate_full:
+        context.declarations[emitter.native_function_name(cl.ctor)] = HeaderDeclaration(
+            f"{native_function_header(cl.ctor, emitter)};", needs_export=True
+        )
+
+
+def generate_class_reuse(
+    cl: ClassIR, c_emitter: Emitter, external_emitter: Emitter, emitter: Emitter
+) -> None:
+    """Generate a definition of a single-object per-class free "list".
+
+    This speeds up object allocation and freeing when there are many short-lived
+    objects.
+
+    TODO: Generalize to support a free list with up to N objects.
+    """
+    assert cl.reuse_freed_instance
+    context = c_emitter.context
+    name = cl.name_prefix(c_emitter.names) + "_free_instance"
+    struct_name = cl.struct_name(c_emitter.names)
+    context.declarations[name] = HeaderDeclaration(
+        f"CPyThreadLocal {struct_name} *{name};", needs_export=True
+    )
+
+
+def generate_class(cl: ClassIR, module: str, emitter: Emitter) -> None:
+    """Generate C code for a class.
+
+    This is the main entry point to the module.
+    """
+    name = cl.name
+    name_prefix = cl.name_prefix(emitter.names)
+
+    setup_name = emitter.native_function_name(cl.setup)
+    new_name = f"{name_prefix}_new"
+    finalize_name = f"{name_prefix}_finalize"
+    members_name = f"{name_prefix}_members"
+    getseters_name = f"{name_prefix}_getseters"
+    vtable_name = f"{name_prefix}_vtable"
+    traverse_name = f"{name_prefix}_traverse"
+    clear_name = f"{name_prefix}_clear"
+    dealloc_name = f"{name_prefix}_dealloc"
+    methods_name = f"{name_prefix}_methods"
+    vtable_setup_name = f"{name_prefix}_trait_vtable_setup"
+    coroutine_setup_name = f"{name_prefix}_coroutine_setup"
+
+    fields: dict[str, str] = {"tp_name": f'"{name}"'}
+
+    generate_full = not cl.is_trait and not cl.builtin_base
+    needs_getseters = cl.needs_getseters or not cl.is_generated or cl.has_dict
+
+    if not cl.builtin_base:
+        fields["tp_new"] = new_name
+
+    if generate_full:
+        fields["tp_dealloc"] = f"(destructor){name_prefix}_dealloc"
+        if not cl.is_acyclic:
+            fields["tp_traverse"] = f"(traverseproc){name_prefix}_traverse"
+            fields["tp_clear"] = f"(inquiry){name_prefix}_clear"
+    # Populate .tp_finalize and generate a finalize method only if __del__ is defined for this class.
+    del_method = next((e.method for e in cl.vtable_entries if e.name == "__del__"), None)
+    if del_method:
+        fields["tp_finalize"] = f"(destructor){finalize_name}"
+    if needs_getseters:
+        fields["tp_getset"] = getseters_name
+    fields["tp_methods"] = methods_name
+
+    def emit_line() -> None:
+        emitter.emit_line()
+
+    emit_line()
+
+    # If the class has a method to initialize default attribute
+    # values, we need to call it during initialization.
+    defaults_fn = cl.get_method("__mypyc_defaults_setup")
+
+    # If there is a __init__ method, we'll use it in the native constructor.
+    init_fn = cl.get_method("__init__")
+
+    # Fill out slots in the type object from dunder methods.
+    fields.update(generate_slots(cl, SLOT_DEFS, emitter))
+
+    # Fill out dunder methods that live in tables hanging off the side.
+    for table_name, type, slot_defs in SIDE_TABLES:
+        slots = generate_slots(cl, slot_defs, emitter)
+        if slots:
+            table_struct_name = generate_side_table_for_class(cl, table_name, type, slots, emitter)
+            fields[f"tp_{table_name}"] = f"&{table_struct_name}"
+
+    richcompare_name = generate_richcompare_wrapper(cl, emitter)
+    if richcompare_name:
+        fields["tp_richcompare"] = richcompare_name
+
+    # If the class inherits from python, make space for a __dict__
+    struct_name = cl.struct_name(emitter.names)
+    if cl.builtin_base:
+        base_size = f"sizeof({cl.builtin_base})"
+    elif cl.is_trait:
+        base_size = "sizeof(PyObject)"
+    else:
+        base_size = f"sizeof({struct_name})"
+    # Since our types aren't allocated using type() we need to
+    # populate these fields ourselves if we want them to have correct
+    # values. PyType_Ready will inherit the offsets from tp_base but
+    # that isn't what we want.
+
+    # XXX: there is no reason for the __weakref__ stuff to be mixed up with __dict__
+    if cl.has_dict and not has_managed_dict(cl, emitter):
+        # __dict__ lives right after the struct and __weakref__ lives right after that
+        # TODO: They should get members in the struct instead of doing this nonsense.
+        weak_offset = f"{base_size} + sizeof(PyObject *)"
+        emitter.emit_lines(
+            f"PyMemberDef {members_name}[] = {{",
+            f'{{"__dict__", T_OBJECT_EX, {base_size}, 0, NULL}},',
+            f'{{"__weakref__", T_OBJECT_EX, {weak_offset}, 0, NULL}},',
+            "{0}",
+            "};",
+        )
+
+        fields["tp_members"] = members_name
+        fields["tp_basicsize"] = f"{base_size} + 2*sizeof(PyObject *)"
+        if emitter.capi_version < (3, 12):
+            fields["tp_dictoffset"] = base_size
+            fields["tp_weaklistoffset"] = weak_offset
+    else:
+        fields["tp_basicsize"] = base_size
+
+    if generate_full:
+        assert cl.setup is not None
+        emitter.emit_line(native_function_header(cl.setup, emitter) + ";")
+        assert cl.ctor is not None
+        emitter.emit_line(native_function_header(cl.ctor, emitter) + ";")
+
+        emit_line()
+        init_fn = cl.get_method("__init__")
+        generate_new_for_class(cl, new_name, vtable_name, setup_name, init_fn, emitter)
+        emit_line()
+        if not cl.is_acyclic:
+            generate_traverse_for_class(cl, traverse_name, emitter)
+            emit_line()
+        generate_clear_for_class(cl, clear_name, emitter)
+        emit_line()
+        generate_dealloc_for_class(cl, dealloc_name, clear_name, bool(del_method), emitter)
+        emit_line()
+
+        if cl.allow_interpreted_subclasses:
+            shadow_vtable_name: str | None = generate_vtables(
+                cl, vtable_setup_name + "_shadow", vtable_name + "_shadow", emitter, shadow=True
+            )
+            emit_line()
+        else:
+            shadow_vtable_name = None
+        vtable_name = generate_vtables(cl, vtable_setup_name, vtable_name, emitter, shadow=False)
+        emit_line()
+        generate_coroutine_setup(cl, coroutine_setup_name, module, emitter)
+        emit_line()
+    if del_method:
+        generate_finalize_for_class(del_method, finalize_name, emitter)
+        emit_line()
+    if needs_getseters:
+        generate_getseter_declarations(cl, emitter)
+        emit_line()
+        generate_getseters_table(cl, getseters_name, emitter)
+        emit_line()
+
+    if cl.is_trait:
+        generate_new_for_trait(cl, new_name, emitter)
+
+    generate_methods_table(cl, methods_name, setup_name if generate_full else None, emitter)
+    emit_line()
+
+    flags = ["Py_TPFLAGS_DEFAULT", "Py_TPFLAGS_HEAPTYPE", "Py_TPFLAGS_BASETYPE"]
+    if generate_full and not cl.is_acyclic:
+        flags.append("Py_TPFLAGS_HAVE_GC")
+    if cl.has_method("__call__"):
+        fields["tp_vectorcall_offset"] = "offsetof({}, vectorcall)".format(
+            cl.struct_name(emitter.names)
+        )
+        flags.append("_Py_TPFLAGS_HAVE_VECTORCALL")
+        if not fields.get("tp_vectorcall"):
+            # This is just a placeholder to please CPython. It will be
+            # overridden during setup.
+            fields["tp_call"] = "PyVectorcall_Call"
+    if has_managed_dict(cl, emitter):
+        flags.append("Py_TPFLAGS_MANAGED_DICT")
+    fields["tp_flags"] = " | ".join(flags)
+
+    fields["tp_doc"] = f"PyDoc_STR({native_class_doc_initializer(cl)})"
+
+    emitter.emit_line(f"static PyTypeObject {emitter.type_struct_name(cl)}_template_ = {{")
+    emitter.emit_line("PyVarObject_HEAD_INIT(NULL, 0)")
+    for field, value in fields.items():
+        emitter.emit_line(f".{field} = {value},")
+    emitter.emit_line("};")
+    emitter.emit_line(
+        "static PyTypeObject *{t}_template = &{t}_template_;".format(
+            t=emitter.type_struct_name(cl)
+        )
+    )
+
+    if cl.coroutine_name:
+        cpyfunction = emitter.static_name(cl.name + "_cpyfunction", module)
+        emitter.emit_line(f"static PyObject *{cpyfunction} = NULL;")
+
+    emitter.emit_line()
+    if generate_full:
+        generate_setup_for_class(cl, defaults_fn, vtable_name, shadow_vtable_name, emitter)
+        emitter.emit_line()
+        generate_constructor_for_class(cl, cl.ctor, init_fn, setup_name, vtable_name, emitter)
+        emitter.emit_line()
+    if needs_getseters:
+        generate_getseters(cl, emitter)
+
+
+def getter_name(cl: ClassIR, attribute: str, names: NameGenerator) -> str:
+    return names.private_name(cl.module_name, f"{cl.name}_get_{attribute}")
+
+
+def setter_name(cl: ClassIR, attribute: str, names: NameGenerator) -> str:
+    return names.private_name(cl.module_name, f"{cl.name}_set_{attribute}")
+
+
+def generate_object_struct(cl: ClassIR, emitter: Emitter) -> None:
+    seen_attrs: set[str] = set()
+    lines: list[str] = []
+    lines += ["typedef struct {", "PyObject_HEAD", "CPyVTableItem *vtable;"]
+    if cl.has_method("__call__"):
+        lines.append("vectorcallfunc vectorcall;")
+    bitmap_attrs = []
+    for base in reversed(cl.base_mro):
+        if not base.is_trait:
+            if base.bitmap_attrs:
+                # Do we need another attribute bitmap field?
+                if emitter.bitmap_field(len(base.bitmap_attrs) - 1) not in bitmap_attrs:
+                    for i in range(0, len(base.bitmap_attrs), BITMAP_BITS):
+                        attr = emitter.bitmap_field(i)
+                        if attr not in bitmap_attrs:
+                            lines.append(f"{BITMAP_TYPE} {attr};")
+                            bitmap_attrs.append(attr)
+            for attr, rtype in base.attributes.items():
+                # Generated class may redefine certain attributes with different
+                # types in subclasses (this would be unsafe for user-defined classes).
+                if attr not in seen_attrs:
+                    lines.append(f"{emitter.ctype_spaced(rtype)}{emitter.attr(attr)};")
+                    seen_attrs.add(attr)
+
+                    if isinstance(rtype, RTuple):
+                        emitter.declare_tuple_struct(rtype)
+
+    lines.append(f"}} {cl.struct_name(emitter.names)};")
+    lines.append("")
+    emitter.context.declarations[cl.struct_name(emitter.names)] = HeaderDeclaration(
+        lines, is_type=True
+    )
+
+
+def generate_vtables(
+    base: ClassIR, vtable_setup_name: str, vtable_name: str, emitter: Emitter, shadow: bool
+) -> str:
+    """Emit the vtables and vtable setup functions for a class.
+
+    This includes both the primary vtable and any trait implementation vtables.
+    The trait vtables go before the main vtable, and have the following layout:
+        {
+            CPyType_T1,         // pointer to type object
+            C_T1_trait_vtable,  // pointer to array of method pointers
+            C_T1_offset_table,  // pointer to array of attribute offsets
+            CPyType_T2,
+            C_T2_trait_vtable,
+            C_T2_offset_table,
+            ...
+        }
+    The method implementations are calculated at the end of IR pass, attribute
+    offsets are {offsetof(native__C, _x1), offsetof(native__C, _y1), ...}.
+
+    To account for both dynamic loading and dynamic class creation,
+    vtables are populated dynamically at class creation time, so we
+    emit empty array definitions to store the vtables and a function to
+    populate them.
+
+    If shadow is True, generate "shadow vtables" that point to the
+    shadow glue methods (which should dispatch via the Python C-API).
+
+    Returns the expression to use to refer to the vtable, which might be
+    different than the name, if there are trait vtables.
+    """
+
+    def trait_vtable_name(trait: ClassIR) -> str:
+        return "{}_{}_trait_vtable{}".format(
+            base.name_prefix(emitter.names),
+            trait.name_prefix(emitter.names),
+            "_shadow" if shadow else "",
+        )
+
+    def trait_offset_table_name(trait: ClassIR) -> str:
+        return "{}_{}_offset_table".format(
+            base.name_prefix(emitter.names), trait.name_prefix(emitter.names)
+        )
+
+    # Emit array definitions with enough space for all the entries
+    emitter.emit_line(
+        "static CPyVTableItem {}[{}];".format(
+            vtable_name, max(1, len(base.vtable_entries) + 3 * len(base.trait_vtables))
+        )
+    )
+
+    for trait, vtable in base.trait_vtables.items():
+        # Trait methods entry (vtable index -> method implementation).
+        emitter.emit_line(
+            f"static CPyVTableItem {trait_vtable_name(trait)}[{max(1, len(vtable))}];"
+        )
+        # Trait attributes entry (attribute number in trait -> offset in actual struct).
+        emitter.emit_line(
+            "static size_t {}[{}];".format(
+                trait_offset_table_name(trait), max(1, len(trait.attributes))
+            )
+        )
+
+    # Emit vtable setup function
+    emitter.emit_line("static bool")
+    emitter.emit_line(f"{NATIVE_PREFIX}{vtable_setup_name}(void)")
+    emitter.emit_line("{")
+
+    if base.allow_interpreted_subclasses and not shadow:
+        emitter.emit_line(f"{NATIVE_PREFIX}{vtable_setup_name}_shadow();")
+
+    subtables = []
+    for trait, vtable in base.trait_vtables.items():
+        name = trait_vtable_name(trait)
+        offset_name = trait_offset_table_name(trait)
+        generate_vtable(vtable, name, emitter, [], shadow)
+        generate_offset_table(offset_name, emitter, trait, base)
+        subtables.append((trait, name, offset_name))
+
+    generate_vtable(base.vtable_entries, vtable_name, emitter, subtables, shadow)
+
+    emitter.emit_line("return 1;")
+    emitter.emit_line("}")
+
+    return vtable_name if not subtables else f"{vtable_name} + {len(subtables) * 3}"
+
+
+def generate_offset_table(
+    trait_offset_table_name: str, emitter: Emitter, trait: ClassIR, cl: ClassIR
+) -> None:
+    """Generate attribute offset row of a trait vtable."""
+    emitter.emit_line(f"size_t {trait_offset_table_name}_scratch[] = {{")
+    for attr in trait.attributes:
+        emitter.emit_line(f"offsetof({cl.struct_name(emitter.names)}, {emitter.attr(attr)}),")
+    if not trait.attributes:
+        # This is for msvc.
+        emitter.emit_line("0")
+    emitter.emit_line("};")
+    emitter.emit_line(
+        "memcpy({name}, {name}_scratch, sizeof({name}));".format(name=trait_offset_table_name)
+    )
+
+
+def generate_vtable(
+    entries: VTableEntries,
+    vtable_name: str,
+    emitter: Emitter,
+    subtables: list[tuple[ClassIR, str, str]],
+    shadow: bool,
+) -> None:
+    emitter.emit_line(f"CPyVTableItem {vtable_name}_scratch[] = {{")
+    if subtables:
+        emitter.emit_line("/* Array of trait vtables */")
+        for trait, table, offset_table in subtables:
+            emitter.emit_line(
+                "(CPyVTableItem){}, (CPyVTableItem){}, (CPyVTableItem){},".format(
+                    emitter.type_struct_name(trait), table, offset_table
+                )
+            )
+        emitter.emit_line("/* Start of real vtable */")
+
+    for entry in entries:
+        method = entry.shadow_method if shadow and entry.shadow_method else entry.method
+        emitter.emit_line(
+            "(CPyVTableItem){}{}{},".format(
+                emitter.get_group_prefix(entry.method.decl),
+                NATIVE_PREFIX,
+                method.cname(emitter.names),
+            )
+        )
+
+    # msvc doesn't allow empty arrays; maybe allowing them at all is an extension?
+    if not entries:
+        emitter.emit_line("NULL")
+    emitter.emit_line("};")
+    emitter.emit_line("memcpy({name}, {name}_scratch, sizeof({name}));".format(name=vtable_name))
+
+
+def generate_setup_for_class(
+    cl: ClassIR,
+    defaults_fn: FuncIR | None,
+    vtable_name: str,
+    shadow_vtable_name: str | None,
+    emitter: Emitter,
+) -> None:
+    """Generate a native function that allocates an instance of a class."""
+    emitter.emit_line(native_function_header(cl.setup, emitter))
+    emitter.emit_line("{")
+    type_arg_name = REG_PREFIX + cl.setup.sig.args[0].name
+    emitter.emit_line(f"PyTypeObject *type = (PyTypeObject*){type_arg_name};")
+    struct_name = cl.struct_name(emitter.names)
+    emitter.emit_line(f"{struct_name} *self;")
+
+    prefix = cl.name_prefix(emitter.names)
+    if cl.reuse_freed_instance:
+        # Attempt to use a per-type free list first (a free "list" with up to one object only).
+        emitter.emit_line(f"if ({prefix}_free_instance != NULL) {{")
+        emitter.emit_line(f"self = {prefix}_free_instance;")
+        emitter.emit_line(f"{prefix}_free_instance = NULL;")
+        emitter.emit_line("Py_SET_REFCNT(self, 1);")
+        if not cl.is_acyclic:
+            emitter.emit_line("PyObject_GC_Track(self);")
+        if defaults_fn is not None:
+            emit_attr_defaults_func_call(defaults_fn, "self", emitter)
+        emitter.emit_line("return (PyObject *)self;")
+        emitter.emit_line("}")
+
+    emitter.emit_line(f"self = ({cl.struct_name(emitter.names)} *)type->tp_alloc(type, 0);")
+    emitter.emit_line("if (self == NULL)")
+    emitter.emit_line("    return NULL;")
+
+    if shadow_vtable_name:
+        emitter.emit_line(f"if (type != {emitter.type_struct_name(cl)}) {{")
+        emitter.emit_line(f"self->vtable = {shadow_vtable_name};")
+        emitter.emit_line("} else {")
+        emitter.emit_line(f"self->vtable = {vtable_name};")
+        emitter.emit_line("}")
+    else:
+        emitter.emit_line(f"self->vtable = {vtable_name};")
+
+    emit_clear_bitmaps(cl, emitter)
+
+    if cl.has_method("__call__"):
+        name = cl.method_decl("__call__").cname(emitter.names)
+        emitter.emit_line(f"self->vectorcall = {PREFIX}{name};")
+
+    for base in reversed(cl.base_mro):
+        for attr, rtype in base.attributes.items():
+            value = emitter.c_undefined_value(rtype)
+
+            # We don't need to set this field to NULL since tp_alloc() already
+            # zero-initializes `self`.
+            if value != "NULL":
+                emitter.set_undefined_value(f"self->{emitter.attr(attr)}", rtype)
+
+    # Initialize attributes to default values, if necessary
+    if defaults_fn is not None:
+        emit_attr_defaults_func_call(defaults_fn, "self", emitter)
+
+    emitter.emit_line("return (PyObject *)self;")
+    emitter.emit_line("}")
+
+
+def emit_clear_bitmaps(cl: ClassIR, emitter: Emitter) -> None:
+    """Emit C code to clear bitmaps that track if attributes have an assigned value."""
+    for i in range(0, len(cl.bitmap_attrs), BITMAP_BITS):
+        field = emitter.bitmap_field(i)
+        emitter.emit_line(f"self->{field} = 0;")
+
+
+def emit_attr_defaults_func_call(defaults_fn: FuncIR, self_name: str, emitter: Emitter) -> None:
+    """Emit C code to initialize attribute defaults by calling defaults_fn.
+
+    The code returns NULL on a raised exception.
+    """
+    emitter.emit_lines(
+        "if ({}{}((PyObject *){}) == 0) {{".format(
+            NATIVE_PREFIX, defaults_fn.cname(emitter.names), self_name
+        ),
+        "Py_DECREF(self);",
+        "return NULL;",
+        "}",
+    )
+
+
+def emit_setup_or_dunder_new_call(
+    cl: ClassIR,
+    setup_name: str,
+    type_arg: str,
+    native_prefix: bool,
+    new_args: str,
+    emitter: Emitter,
+) -> None:
+    def emit_null_check() -> None:
+        emitter.emit_line("if (self == NULL)")
+        emitter.emit_line("    return NULL;")
+
+    new_fn = cl.get_method("__new__")
+    if not new_fn:
+        emitter.emit_line(f"PyObject *self = {setup_name}({type_arg});")
+        emit_null_check()
+        return
+    prefix = emitter.get_group_prefix(new_fn.decl) + NATIVE_PREFIX if native_prefix else PREFIX
+    all_args = type_arg
+    if new_args != "":
+        all_args += ", " + new_args
+    emitter.emit_line(f"PyObject *self = {prefix}{new_fn.cname(emitter.names)}({all_args});")
+    emit_null_check()
+
+    # skip __init__ if __new__ returns some other type
+    emitter.emit_line(f"if (Py_TYPE(self) != {emitter.type_struct_name(cl)})")
+    emitter.emit_line("    return self;")
+
+
+def generate_constructor_for_class(
+    cl: ClassIR,
+    fn: FuncDecl,
+    init_fn: FuncIR | None,
+    setup_name: str,
+    vtable_name: str,
+    emitter: Emitter,
+) -> None:
+    """Generate a native function that allocates and initializes an instance of a class."""
+    emitter.emit_line(f"{native_function_header(fn, emitter)}")
+    emitter.emit_line("{")
+
+    fn_args = [REG_PREFIX + arg.name for arg in fn.sig.args]
+    type_arg = "(PyObject *)" + emitter.type_struct_name(cl)
+    new_args = ", ".join(fn_args)
+
+    use_wrapper = (
+        cl.has_method("__new__")
+        and len(fn.sig.args) == 2
+        and fn.sig.args[0].kind == ARG_STAR
+        and fn.sig.args[1].kind == ARG_STAR2
+    )
+    emit_setup_or_dunder_new_call(cl, setup_name, type_arg, not use_wrapper, new_args, emitter)
+
+    args = ", ".join(["self"] + fn_args)
+    if init_fn is not None:
+        prefix = PREFIX if use_wrapper else NATIVE_PREFIX
+        cast = "!= NULL ? 0 : -1" if use_wrapper else ""
+        emitter.emit_line(
+            "char res = {}{}{}({}){};".format(
+                emitter.get_group_prefix(init_fn.decl),
+                prefix,
+                init_fn.cname(emitter.names),
+                args,
+                cast,
+            )
+        )
+        emitter.emit_line("if (res == 2) {")
+        emitter.emit_line("Py_DECREF(self);")
+        emitter.emit_line("return NULL;")
+        emitter.emit_line("}")
+
+    # If there is a nontrivial ctor that we didn't define, invoke it via tp_init
+    elif len(fn.sig.args) > 1:
+        emitter.emit_line(f"int res = {emitter.type_struct_name(cl)}->tp_init({args});")
+
+        emitter.emit_line("if (res < 0) {")
+        emitter.emit_line("Py_DECREF(self);")
+        emitter.emit_line("return NULL;")
+        emitter.emit_line("}")
+
+    emitter.emit_line("return self;")
+    emitter.emit_line("}")
+
+
+def generate_init_for_class(cl: ClassIR, init_fn: FuncIR, emitter: Emitter) -> str:
+    """Generate an init function suitable for use as tp_init.
+
+    tp_init needs to be a function that returns an int, and our
+    __init__ methods return a PyObject. Translate NULL to -1,
+    everything else to 0.
+    """
+    func_name = f"{cl.name_prefix(emitter.names)}_init"
+
+    emitter.emit_line("static int")
+    emitter.emit_line(f"{func_name}(PyObject *self, PyObject *args, PyObject *kwds)")
+    emitter.emit_line("{")
+    if cl.allow_interpreted_subclasses or cl.builtin_base or cl.has_method("__new__"):
+        emitter.emit_line(
+            "return {}{}(self, args, kwds) != NULL ? 0 : -1;".format(
+                PREFIX, init_fn.cname(emitter.names)
+            )
+        )
+    else:
+        emitter.emit_line("return 0;")
+    emitter.emit_line("}")
+
+    return func_name
+
+
+def generate_new_for_class(
+    cl: ClassIR,
+    func_name: str,
+    vtable_name: str,
+    setup_name: str,
+    init_fn: FuncIR | None,
+    emitter: Emitter,
+) -> None:
+    emitter.emit_line("static PyObject *")
+    emitter.emit_line(f"{func_name}(PyTypeObject *type, PyObject *args, PyObject *kwds)")
+    emitter.emit_line("{")
+    # TODO: Check and unbox arguments
+    if not cl.allow_interpreted_subclasses:
+        emitter.emit_line(f"if (type != {emitter.type_struct_name(cl)}) {{")
+        emitter.emit_line(
+            'PyErr_SetString(PyExc_TypeError, "interpreted classes cannot inherit from compiled");'
+        )
+        emitter.emit_line("return NULL;")
+        emitter.emit_line("}")
+
+    type_arg = "(PyObject*)type"
+    new_args = "args, kwds"
+    emit_setup_or_dunder_new_call(cl, setup_name, type_arg, False, new_args, emitter)
+    if (
+        not init_fn
+        or cl.allow_interpreted_subclasses
+        or cl.builtin_base
+        or cl.is_serializable()
+        or cl.has_method("__new__")
+    ):
+        # Match Python semantics -- __new__ doesn't call __init__.
+        emitter.emit_line("return self;")
+    else:
+        # __new__ of a native class implicitly calls __init__ so that we
+        # can enforce that instances are always properly initialized. This
+        # is needed to support always defined attributes.
+        emitter.emit_line(
+            f"PyObject *ret = {PREFIX}{init_fn.cname(emitter.names)}(self, args, kwds);"
+        )
+        emitter.emit_lines("if (ret == NULL)", "    return NULL;")
+        emitter.emit_line("return self;")
+    emitter.emit_line("}")
+
+
+def generate_new_for_trait(cl: ClassIR, func_name: str, emitter: Emitter) -> None:
+    emitter.emit_line("static PyObject *")
+    emitter.emit_line(f"{func_name}(PyTypeObject *type, PyObject *args, PyObject *kwds)")
+    emitter.emit_line("{")
+    emitter.emit_line(f"if (type != {emitter.type_struct_name(cl)}) {{")
+    emitter.emit_line(
+        "PyErr_SetString(PyExc_TypeError, "
+        '"interpreted classes cannot inherit from compiled traits");'
+    )
+    emitter.emit_line("} else {")
+    emitter.emit_line('PyErr_SetString(PyExc_TypeError, "traits may not be directly created");')
+    emitter.emit_line("}")
+    emitter.emit_line("return NULL;")
+    emitter.emit_line("}")
+
+
+def generate_traverse_for_class(cl: ClassIR, func_name: str, emitter: Emitter) -> None:
+    """Emit function that performs cycle GC traversal of an instance."""
+    emitter.emit_line("static int")
+    emitter.emit_line(
+        f"{func_name}({cl.struct_name(emitter.names)} *self, visitproc visit, void *arg)"
+    )
+    emitter.emit_line("{")
+    for base in reversed(cl.base_mro):
+        for attr, rtype in base.attributes.items():
+            emitter.emit_gc_visit(f"self->{emitter.attr(attr)}", rtype)
+    if has_managed_dict(cl, emitter):
+        emitter.emit_line("PyObject_VisitManagedDict((PyObject *)self, visit, arg);")
+    elif cl.has_dict:
+        struct_name = cl.struct_name(emitter.names)
+        # __dict__ lives right after the struct and __weakref__ lives right after that
+        emitter.emit_gc_visit(
+            f"*((PyObject **)((char *)self + sizeof({struct_name})))", object_rprimitive
+        )
+        emitter.emit_gc_visit(
+            f"*((PyObject **)((char *)self + sizeof(PyObject *) + sizeof({struct_name})))",
+            object_rprimitive,
+        )
+    emitter.emit_line("return 0;")
+    emitter.emit_line("}")
+
+
+def generate_clear_for_class(cl: ClassIR, func_name: str, emitter: Emitter) -> None:
+    emitter.emit_line("static int")
+    emitter.emit_line(f"{func_name}({cl.struct_name(emitter.names)} *self)")
+    emitter.emit_line("{")
+    for base in reversed(cl.base_mro):
+        for attr, rtype in base.attributes.items():
+            emitter.emit_gc_clear(f"self->{emitter.attr(attr)}", rtype)
+    if has_managed_dict(cl, emitter):
+        emitter.emit_line("PyObject_ClearManagedDict((PyObject *)self);")
+    elif cl.has_dict:
+        struct_name = cl.struct_name(emitter.names)
+        # __dict__ lives right after the struct and __weakref__ lives right after that
+        emitter.emit_gc_clear(
+            f"*((PyObject **)((char *)self + sizeof({struct_name})))", object_rprimitive
+        )
+        emitter.emit_gc_clear(
+            f"*((PyObject **)((char *)self + sizeof(PyObject *) + sizeof({struct_name})))",
+            object_rprimitive,
+        )
+    emitter.emit_line("return 0;")
+    emitter.emit_line("}")
+
+
+def generate_dealloc_for_class(
+    cl: ClassIR,
+    dealloc_func_name: str,
+    clear_func_name: str,
+    has_tp_finalize: bool,
+    emitter: Emitter,
+) -> None:
+    emitter.emit_line("static void")
+    emitter.emit_line(f"{dealloc_func_name}({cl.struct_name(emitter.names)} *self)")
+    emitter.emit_line("{")
+    if has_tp_finalize:
+        emitter.emit_line("PyObject *type, *value, *traceback;")
+        emitter.emit_line("PyErr_Fetch(&type, &value, &traceback);")
+        emitter.emit_line("int res = PyObject_CallFinalizerFromDealloc((PyObject *)self);")
+        # CPython interpreter uses PyErr_WriteUnraisable: https://docs.python.org/3/c-api/exceptions.html#c.PyErr_WriteUnraisable
+        # However, the message is slightly different due to the way mypyc compiles classes.
+        # CPython interpreter prints: Exception ignored in: <function F.__del__ at 0x100aed940>
+        # mypyc prints: Exception ignored in: <slot wrapper '__del__' of 'F' objects>
+        emitter.emit_line("if (PyErr_Occurred() != NULL) {")
+        # Don't untrack instance if error occurred
+        emitter.emit_line("PyErr_WriteUnraisable((PyObject *)self);")
+        emitter.emit_line("res = -1;")
+        emitter.emit_line("}")
+        emitter.emit_line("PyErr_Restore(type, value, traceback);")
+        emitter.emit_line("if (res < 0) {")
+        emitter.emit_line("goto done;")
+        emitter.emit_line("}")
+    if not cl.is_acyclic:
+        emitter.emit_line("PyObject_GC_UnTrack(self);")
+    if cl.reuse_freed_instance:
+        emit_reuse_dealloc(cl, emitter)
+    # The trashcan is needed to handle deep recursive deallocations
+    emitter.emit_line(f"CPy_TRASHCAN_BEGIN(self, {dealloc_func_name})")
+    emitter.emit_line(f"{clear_func_name}(self);")
+    emitter.emit_line("Py_TYPE(self)->tp_free((PyObject *)self);")
+    emitter.emit_line("CPy_TRASHCAN_END(self)")
+    emitter.emit_line("done: ;")
+    emitter.emit_line("}")
+
+
+def emit_reuse_dealloc(cl: ClassIR, emitter: Emitter) -> None:
+    """Emit code to deallocate object by putting it to per-type free list.
+
+    The free "list" currently can have up to one object.
+    """
+    prefix = cl.name_prefix(emitter.names)
+    emitter.emit_line(f"if ({prefix}_free_instance == NULL) {{")
+    emitter.emit_line(f"{prefix}_free_instance = self;")
+
+    # Clear attributes and free referenced objects.
+
+    emit_clear_bitmaps(cl, emitter)
+
+    for base in reversed(cl.base_mro):
+        for attr, rtype in base.attributes.items():
+            emitter.emit_reuse_clear(f"self->{emitter.attr(attr)}", rtype)
+
+    emitter.emit_line("return;")
+    emitter.emit_line("}")
+
+
+def generate_finalize_for_class(
+    del_method: FuncIR, finalize_func_name: str, emitter: Emitter
+) -> None:
+    emitter.emit_line("static void")
+    emitter.emit_line(f"{finalize_func_name}(PyObject *self)")
+    emitter.emit_line("{")
+    emitter.emit_line(
+        "{}{}{}(self);".format(
+            emitter.get_group_prefix(del_method.decl),
+            NATIVE_PREFIX,
+            del_method.cname(emitter.names),
+        )
+    )
+    emitter.emit_line("}")
+
+
+def generate_methods_table(
+    cl: ClassIR, name: str, setup_name: str | None, emitter: Emitter
+) -> None:
+    emitter.emit_line(f"static PyMethodDef {name}[] = {{")
+    if setup_name:
+        # Store pointer to the setup function so it can be resolved dynamically
+        # in case of instance creation in __new__.
+        # CPy_SetupObject expects this method to be the first one in tp_methods.
+        emitter.emit_line(
+            f'{{"__internal_mypyc_setup", (PyCFunction){setup_name}, METH_O, NULL}},'
+        )
+    for fn in cl.methods.values():
+        if fn.decl.is_prop_setter or fn.decl.is_prop_getter or fn.internal:
+            continue
+        emitter.emit_line(f'{{"{fn.name}",')
+        emitter.emit_line(f" (PyCFunction){PREFIX}{fn.cname(emitter.names)},")
+        flags = ["METH_FASTCALL", "METH_KEYWORDS"]
+        if fn.decl.kind == FUNC_STATICMETHOD:
+            flags.append("METH_STATIC")
+        elif fn.decl.kind == FUNC_CLASSMETHOD:
+            flags.append("METH_CLASS")
+
+        doc = native_function_doc_initializer(fn)
+        emitter.emit_line(" {}, PyDoc_STR({})}},".format(" | ".join(flags), doc))
+
+    # Provide a default __getstate__ and __setstate__
+    if not cl.has_method("__setstate__") and not cl.has_method("__getstate__"):
+        emitter.emit_lines(
+            '{"__setstate__", (PyCFunction)CPyPickle_SetState, METH_O, NULL},',
+            '{"__getstate__", (PyCFunction)CPyPickle_GetState, METH_NOARGS, NULL},',
+        )
+
+    emitter.emit_line("{NULL}  /* Sentinel */")
+    emitter.emit_line("};")
+
+
+def generate_side_table_for_class(
+    cl: ClassIR, name: str, type: str, slots: dict[str, str], emitter: Emitter
+) -> str | None:
+    name = f"{cl.name_prefix(emitter.names)}_{name}"
+    emitter.emit_line(f"static {type} {name} = {{")
+    for field, value in slots.items():
+        emitter.emit_line(f".{field} = {value},")
+    emitter.emit_line("};")
+    return name
+
+
+def generate_getseter_declarations(cl: ClassIR, emitter: Emitter) -> None:
+    if not cl.is_trait:
+        for attr in cl.attributes:
+            emitter.emit_line("static PyObject *")
+            emitter.emit_line(
+                "{}({} *self, void *closure);".format(
+                    getter_name(cl, attr, emitter.names), cl.struct_name(emitter.names)
+                )
+            )
+            emitter.emit_line("static int")
+            emitter.emit_line(
+                "{}({} *self, PyObject *value, void *closure);".format(
+                    setter_name(cl, attr, emitter.names), cl.struct_name(emitter.names)
+                )
+            )
+
+    for prop, (getter, setter) in cl.properties.items():
+        if getter.decl.implicit:
+            continue
+
+        # Generate getter declaration
+        emitter.emit_line("static PyObject *")
+        emitter.emit_line(
+            "{}({} *self, void *closure);".format(
+                getter_name(cl, prop, emitter.names), cl.struct_name(emitter.names)
+            )
+        )
+
+        # Generate property setter declaration if a setter exists
+        if setter:
+            emitter.emit_line("static int")
+            emitter.emit_line(
+                "{}({} *self, PyObject *value, void *closure);".format(
+                    setter_name(cl, prop, emitter.names), cl.struct_name(emitter.names)
+                )
+            )
+
+
+def generate_getseters_table(cl: ClassIR, name: str, emitter: Emitter) -> None:
+    emitter.emit_line(f"static PyGetSetDef {name}[] = {{")
+    if not cl.is_trait:
+        for attr in cl.attributes:
+            emitter.emit_line(f'{{"{attr}",')
+            emitter.emit_line(
+                " (getter){}, (setter){},".format(
+                    getter_name(cl, attr, emitter.names), setter_name(cl, attr, emitter.names)
+                )
+            )
+            emitter.emit_line(" NULL, NULL},")
+    for prop, (getter, setter) in cl.properties.items():
+        if getter.decl.implicit:
+            continue
+
+        emitter.emit_line(f'{{"{prop}",')
+        emitter.emit_line(f" (getter){getter_name(cl, prop, emitter.names)},")
+
+        if setter:
+            emitter.emit_line(f" (setter){setter_name(cl, prop, emitter.names)},")
+            emitter.emit_line("NULL, NULL},")
+        else:
+            emitter.emit_line("NULL, NULL, NULL},")
+
+    if cl.has_dict:
+        emitter.emit_line('{"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict},')
+
+    emitter.emit_line("{NULL}  /* Sentinel */")
+    emitter.emit_line("};")
+
+
+def generate_getseters(cl: ClassIR, emitter: Emitter) -> None:
+    if not cl.is_trait:
+        for i, (attr, rtype) in enumerate(cl.attributes.items()):
+            generate_getter(cl, attr, rtype, emitter)
+            emitter.emit_line("")
+            generate_setter(cl, attr, rtype, emitter)
+            if i < len(cl.attributes) - 1:
+                emitter.emit_line("")
+    for prop, (getter, setter) in cl.properties.items():
+        if getter.decl.implicit:
+            continue
+
+        rtype = getter.sig.ret_type
+        emitter.emit_line("")
+        generate_readonly_getter(cl, prop, rtype, getter, emitter)
+        if setter:
+            arg_type = setter.sig.args[1].type
+            emitter.emit_line("")
+            generate_property_setter(cl, prop, arg_type, setter, emitter)
+
+
+def generate_getter(cl: ClassIR, attr: str, rtype: RType, emitter: Emitter) -> None:
+    attr_field = emitter.attr(attr)
+    emitter.emit_line("static PyObject *")
+    emitter.emit_line(
+        "{}({} *self, void *closure)".format(
+            getter_name(cl, attr, emitter.names), cl.struct_name(emitter.names)
+        )
+    )
+    emitter.emit_line("{")
+    attr_expr = f"self->{attr_field}"
+
+    # HACK: Don't consider refcounted values as always defined, since it's possible to
+    #       access uninitialized values via 'gc.get_objects()'. Accessing non-refcounted
+    #       values is benign.
+    always_defined = cl.is_always_defined(attr) and not rtype.is_refcounted
+
+    if not always_defined:
+        emitter.emit_undefined_attr_check(rtype, attr_expr, "==", "self", attr, cl, unlikely=True)
+        emitter.emit_line("PyErr_SetString(PyExc_AttributeError,")
+        emitter.emit_line(f'    "attribute {repr(attr)} of {repr(cl.name)} undefined");')
+        emitter.emit_line("return NULL;")
+        emitter.emit_line("}")
+    emitter.emit_inc_ref(f"self->{attr_field}", rtype)
+    emitter.emit_box(f"self->{attr_field}", "retval", rtype, declare_dest=True)
+    emitter.emit_line("return retval;")
+    emitter.emit_line("}")
+
+
+def generate_setter(cl: ClassIR, attr: str, rtype: RType, emitter: Emitter) -> None:
+    attr_field = emitter.attr(attr)
+    emitter.emit_line("static int")
+    emitter.emit_line(
+        "{}({} *self, PyObject *value, void *closure)".format(
+            setter_name(cl, attr, emitter.names), cl.struct_name(emitter.names)
+        )
+    )
+    emitter.emit_line("{")
+
+    deletable = cl.is_deletable(attr)
+    if not deletable:
+        emitter.emit_line("if (value == NULL) {")
+        emitter.emit_line("PyErr_SetString(PyExc_AttributeError,")
+        emitter.emit_line(
+            f'    "{repr(cl.name)} object attribute {repr(attr)} cannot be deleted");'
+        )
+        emitter.emit_line("return -1;")
+        emitter.emit_line("}")
+
+    # HACK: Don't consider refcounted values as always defined, since it's possible to
+    #       access uninitialized values via 'gc.get_objects()'. Accessing non-refcounted
+    #       values is benign.
+    always_defined = cl.is_always_defined(attr) and not rtype.is_refcounted
+
+    if rtype.is_refcounted:
+        attr_expr = f"self->{attr_field}"
+        if not always_defined:
+            emitter.emit_undefined_attr_check(rtype, attr_expr, "!=", "self", attr, cl)
+        emitter.emit_dec_ref(f"self->{attr_field}", rtype)
+        if not always_defined:
+            emitter.emit_line("}")
+
+    if deletable:
+        emitter.emit_line("if (value != NULL) {")
+
+    if rtype.is_unboxed:
+        emitter.emit_unbox("value", "tmp", rtype, error=ReturnHandler("-1"), declare_dest=True)
+    elif is_same_type(rtype, object_rprimitive):
+        emitter.emit_line("PyObject *tmp = value;")
+    else:
+        emitter.emit_cast("value", "tmp", rtype, declare_dest=True)
+        emitter.emit_lines("if (!tmp)", "    return -1;")
+    emitter.emit_inc_ref("tmp", rtype)
+    emitter.emit_line(f"self->{attr_field} = tmp;")
+    if rtype.error_overlap and not always_defined:
+        emitter.emit_attr_bitmap_set("tmp", "self", rtype, cl, attr)
+
+    if deletable:
+        emitter.emit_line("} else {")
+        emitter.set_undefined_value(f"self->{attr_field}", rtype)
+        if rtype.error_overlap:
+            emitter.emit_attr_bitmap_clear("self", rtype, cl, attr)
+        emitter.emit_line("}")
+    emitter.emit_line("return 0;")
+    emitter.emit_line("}")
+
+
+def generate_readonly_getter(
+    cl: ClassIR, attr: str, rtype: RType, func_ir: FuncIR, emitter: Emitter
+) -> None:
+    emitter.emit_line("static PyObject *")
+    emitter.emit_line(
+        "{}({} *self, void *closure)".format(
+            getter_name(cl, attr, emitter.names), cl.struct_name(emitter.names)
+        )
+    )
+    emitter.emit_line("{")
+    if rtype.is_unboxed:
+        emitter.emit_line(
+            "{}retval = {}{}((PyObject *) self);".format(
+                emitter.ctype_spaced(rtype), NATIVE_PREFIX, func_ir.cname(emitter.names)
+            )
+        )
+        emitter.emit_error_check("retval", rtype, "return NULL;")
+        emitter.emit_box("retval", "retbox", rtype, declare_dest=True)
+        emitter.emit_line("return retbox;")
+    else:
+        emitter.emit_line(
+            f"return {NATIVE_PREFIX}{func_ir.cname(emitter.names)}((PyObject *) self);"
+        )
+    emitter.emit_line("}")
+
+
+def generate_property_setter(
+    cl: ClassIR, attr: str, arg_type: RType, func_ir: FuncIR, emitter: Emitter
+) -> None:
+    emitter.emit_line("static int")
+    emitter.emit_line(
+        "{}({} *self, PyObject *value, void *closure)".format(
+            setter_name(cl, attr, emitter.names), cl.struct_name(emitter.names)
+        )
+    )
+    emitter.emit_line("{")
+    if arg_type.is_unboxed:
+        emitter.emit_unbox("value", "tmp", arg_type, error=ReturnHandler("-1"), declare_dest=True)
+        emitter.emit_line(
+            f"{NATIVE_PREFIX}{func_ir.cname(emitter.names)}((PyObject *) self, tmp);"
+        )
+    else:
+        emitter.emit_line(
+            f"{NATIVE_PREFIX}{func_ir.cname(emitter.names)}((PyObject *) self, value);"
+        )
+    emitter.emit_line("return 0;")
+    emitter.emit_line("}")
+
+
+def has_managed_dict(cl: ClassIR, emitter: Emitter) -> bool:
+    """Should the class get the Py_TPFLAGS_MANAGED_DICT flag?"""
+    # On 3.11 and earlier the flag doesn't exist and we use
+    # tp_dictoffset instead.  If a class inherits from Exception, the
+    # flag conflicts with tp_dictoffset set in the base class.
+    return (
+        emitter.capi_version >= (3, 12)
+        and cl.has_dict
+        and cl.builtin_base != "PyBaseExceptionObject"
+    )
+
+
+def native_class_doc_initializer(cl: ClassIR) -> str:
+    init_fn = cl.get_method("__init__")
+    if init_fn is not None:
+        text_sig = get_text_signature(init_fn, bound=True)
+        if text_sig is None:
+            return "NULL"
+        text_sig = text_sig.replace("__init__", cl.name, 1)
+    else:
+        text_sig = f"{cl.name}()"
+    docstring = f"{text_sig}\n--\n\n"
+    return c_string_initializer(docstring.encode("ascii", errors="backslashreplace"))
+
+
+def generate_coroutine_setup(
+    cl: ClassIR, coroutine_setup_name: str, module_name: str, emitter: Emitter
+) -> None:
+    emitter.emit_line("static bool")
+    emitter.emit_line(f"{NATIVE_PREFIX}{coroutine_setup_name}(PyObject *type)")
+    emitter.emit_line("{")
+
+    error_stmt = "    return 2;"
+
+    def emit_instance(fn: FuncIR, fn_name: str) -> str:
+        filepath = emitter.filepath or ""
+        return emitter.emit_cpyfunction_instance(fn, fn_name, filepath, error_stmt)
+
+    def success() -> None:
+        emitter.emit_line("return 1;")
+        emitter.emit_line("}")
+
+    if cl.coroutine_name:
+        # Callable class generated for a coroutine. It stores its function wrapper as an attribute.
+        wrapper_name = emit_instance(cl.methods["__call__"], cl.coroutine_name)
+        struct_name = cl.struct_name(emitter.names)
+        attr = emitter.attr(CPYFUNCTION_NAME)
+        emitter.emit_line(f"(({struct_name} *)type)->{attr} = {wrapper_name};")
+        return success()
+
+    if not any(fn.decl.is_coroutine for fn in cl.methods.values()):
+        return success()
+
+    emitter.emit_line("PyTypeObject *tp = (PyTypeObject *)type;")
+
+    for fn in cl.methods.values():
+        if not fn.decl.is_coroutine:
+            continue
+
+        name = short_id_from_name(fn.name, fn.decl.shortname, fn.line)
+        wrapper_name = emit_instance(fn, name)
+        name_obj = f"{wrapper_name}_name"
+        emitter.emit_line(f'PyObject *{name_obj} = PyUnicode_FromString("{fn.name}");')
+        emitter.emit_line(f"if (unlikely(!{name_obj}))")
+        emitter.emit_line(error_stmt)
+        emitter.emit_line(f"if (PyDict_SetItem(tp->tp_dict, {name_obj}, {wrapper_name}) < 0)")
+        emitter.emit_line(error_stmt)
+
+    return success()

micromamba_root/Lib/site-packages/mypyc/codegen/emitfunc.py

@@ -0,0 +1,993 @@
+"""Code generation for native function bodies."""
+
+from __future__ import annotations
+
+from typing import Final
+
+from mypyc.analysis.blockfreq import frequently_executed_blocks
+from mypyc.codegen.emit import (
+    DEBUG_ERRORS,
+    PREFIX_MAP,
+    Emitter,
+    TracebackAndGotoHandler,
+    c_array_initializer,
+)
+from mypyc.common import GENERATOR_ATTRIBUTE_PREFIX, HAVE_IMMORTAL, NATIVE_PREFIX, REG_PREFIX
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.func_ir import FUNC_CLASSMETHOD, FUNC_STATICMETHOD, FuncDecl, FuncIR, all_values
+from mypyc.ir.ops import (
+    ERR_FALSE,
+    NAMESPACE_TYPE,
+    Assign,
+    AssignMulti,
+    BasicBlock,
+    Box,
+    Branch,
+    Call,
+    CallC,
+    Cast,
+    ComparisonOp,
+    ControlOp,
+    CString,
+    DecRef,
+    Extend,
+    Float,
+    FloatComparisonOp,
+    FloatNeg,
+    FloatOp,
+    GetAttr,
+    GetElement,
+    GetElementPtr,
+    Goto,
+    IncRef,
+    InitStatic,
+    Integer,
+    IntOp,
+    KeepAlive,
+    LoadAddress,
+    LoadErrorValue,
+    LoadGlobal,
+    LoadLiteral,
+    LoadMem,
+    LoadStatic,
+    MethodCall,
+    Op,
+    OpVisitor,
+    PrimitiveOp,
+    RaiseStandardError,
+    Register,
+    Return,
+    SetAttr,
+    SetElement,
+    SetMem,
+    Truncate,
+    TupleGet,
+    TupleSet,
+    Unborrow,
+    Unbox,
+    Undef,
+    Unreachable,
+    Value,
+)
+from mypyc.ir.pprint import generate_names_for_ir
+from mypyc.ir.rtypes import (
+    RArray,
+    RInstance,
+    RStruct,
+    RTuple,
+    RType,
+    RVec,
+    is_bool_or_bit_rprimitive,
+    is_int32_rprimitive,
+    is_int64_rprimitive,
+    is_int_rprimitive,
+    is_none_rprimitive,
+    is_pointer_rprimitive,
+    is_tagged,
+)
+
+
+def native_function_type(fn: FuncIR, emitter: Emitter) -> str:
+    args = ", ".join(emitter.ctype(arg.type) for arg in fn.args) or "void"
+    ret = emitter.ctype(fn.ret_type)
+    return f"{ret} (*)({args})"
+
+
+def native_function_header(fn: FuncDecl, emitter: Emitter) -> str:
+    args = []
+    for arg in fn.sig.args:
+        args.append(f"{emitter.ctype_spaced(arg.type)}{REG_PREFIX}{arg.name}")
+
+    return "{ret_type}{name}({args})".format(
+        ret_type=emitter.ctype_spaced(fn.sig.ret_type),
+        name=emitter.native_function_name(fn),
+        args=", ".join(args) or "void",
+    )
+
+
+def generate_native_function(
+    fn: FuncIR, emitter: Emitter, source_path: str, module_name: str
+) -> None:
+    declarations = Emitter(emitter.context)
+    names = generate_names_for_ir(fn.arg_regs, fn.blocks)
+    body = Emitter(emitter.context, names)
+    visitor = FunctionEmitterVisitor(body, declarations, source_path, module_name)
+
+    declarations.emit_line(f"{native_function_header(fn.decl, emitter)} {{")
+    body.indent()
+
+    for r in all_values(fn.arg_regs, fn.blocks):
+        if isinstance(r.type, RTuple):
+            emitter.declare_tuple_struct(r.type)
+        if isinstance(r.type, RArray):
+            continue  # Special: declared on first assignment
+
+        if r in fn.arg_regs:
+            continue  # Skip the arguments
+
+        ctype = emitter.ctype_spaced(r.type)
+        init = ""
+        declarations.emit_line(
+            "{ctype}{prefix}{name}{init};".format(
+                ctype=ctype, prefix=REG_PREFIX, name=names[r], init=init
+            )
+        )
+
+    # Before we emit the blocks, give them all labels
+    blocks = fn.blocks
+    for i, block in enumerate(blocks):
+        block.label = i
+
+    # Find blocks that are never jumped to or are only jumped to from the
+    # block directly above it. This allows for more labels and gotos to be
+    # eliminated during code generation.
+    for block in fn.blocks:
+        terminator = block.terminator
+        assert isinstance(terminator, ControlOp), terminator
+
+        for target in terminator.targets():
+            is_next_block = target.label == block.label + 1
+
+            # Always emit labels for GetAttr error checks since the emit code that
+            # generates them will add instructions between the branch and the
+            # next label, causing the label to be wrongly removed. A better
+            # solution would be to change the IR so that it adds a basic block
+            # in between the calls.
+            is_problematic_op = isinstance(terminator, Branch) and any(
+                isinstance(s, GetAttr) for s in terminator.sources()
+            )
+
+            if not is_next_block or is_problematic_op:
+                fn.blocks[target.label].referenced = True
+
+    common = frequently_executed_blocks(fn.blocks[0])
+
+    for i in range(len(blocks)):
+        block = blocks[i]
+        visitor.rare = block not in common
+        next_block = None
+        if i + 1 < len(blocks):
+            next_block = blocks[i + 1]
+        body.emit_label(block)
+        visitor.next_block = next_block
+
+        ops = block.ops
+        visitor.ops = ops
+        visitor.op_index = 0
+        while visitor.op_index < len(ops):
+            ops[visitor.op_index].accept(visitor)
+            visitor.op_index += 1
+
+    body.emit_line("}")
+
+    emitter.emit_from_emitter(declarations)
+    emitter.emit_from_emitter(body)
+
+
+class FunctionEmitterVisitor(OpVisitor[None]):
+    def __init__(
+        self, emitter: Emitter, declarations: Emitter, source_path: str, module_name: str
+    ) -> None:
+        self.emitter = emitter
+        self.names = emitter.names
+        self.declarations = declarations
+        self.source_path = source_path
+        self.module_name = module_name
+        self.literals = emitter.context.literals
+        self.rare = False
+        # Next basic block to be processed after the current one (if any), set by caller
+        self.next_block: BasicBlock | None = None
+        # Ops in the basic block currently being processed, set by caller
+        self.ops: list[Op] = []
+        # Current index within ops; visit methods can increment this to skip/merge ops
+        self.op_index = 0
+
+    def temp_name(self) -> str:
+        return self.emitter.temp_name()
+
+    def visit_goto(self, op: Goto) -> None:
+        if op.label is not self.next_block:
+            self.emit_line("goto %s;" % self.label(op.label))
+
+    def error_value_check(self, value: Value, compare: str) -> str:
+        typ = value.type
+        if isinstance(typ, RTuple):
+            # TODO: What about empty tuple?
+            return self.emitter.tuple_undefined_check_cond(
+                typ, self.reg(value), self.c_error_value, compare
+            )
+        elif isinstance(typ, RVec):
+            # Error values for vecs are represented by a negative length.
+            vec_compare = ">=" if compare == "!=" else "<"
+            return f"{self.reg(value)}.len {vec_compare} 0"
+        else:
+            return f"{self.reg(value)} {compare} {self.c_error_value(typ)}"
+
+    def visit_branch(self, op: Branch) -> None:
+        true, false = op.true, op.false
+        negated = op.negated
+        negated_rare = False
+        if true is self.next_block and op.traceback_entry is None:
+            # Switch true/false since it avoids an else block.
+            true, false = false, true
+            negated = not negated
+            negated_rare = True
+
+        neg = "!" if negated else ""
+        cond = ""
+        if op.op == Branch.BOOL:
+            expr_result = self.reg(op.value)
+            cond = f"{neg}{expr_result}"
+        elif op.op == Branch.IS_ERROR:
+            compare = "!=" if negated else "=="
+            cond = self.error_value_check(op.value, compare)
+        else:
+            assert False, "Invalid branch"
+
+        # For error checks, tell the compiler the branch is unlikely
+        if op.traceback_entry is not None or op.rare:
+            if not negated_rare:
+                cond = f"unlikely({cond})"
+            else:
+                cond = f"likely({cond})"
+
+        if false is self.next_block:
+            if op.traceback_entry is None:
+                if true is not self.next_block:
+                    self.emit_line(f"if ({cond}) goto {self.label(true)};")
+            else:
+                self.emit_line(f"if ({cond}) {{")
+                self.emit_traceback(op)
+                self.emit_lines("goto %s;" % self.label(true), "}")
+        else:
+            self.emit_line(f"if ({cond}) {{")
+            self.emit_traceback(op)
+
+            if true is not self.next_block:
+                self.emit_line("goto %s;" % self.label(true))
+
+            self.emit_lines("} else", "    goto %s;" % self.label(false))
+
+    def visit_return(self, op: Return) -> None:
+        value_str = self.reg(op.value)
+        self.emit_line("return %s;" % value_str)
+
+    def visit_tuple_set(self, op: TupleSet) -> None:
+        dest = self.reg(op)
+        tuple_type = op.tuple_type
+        self.emitter.declare_tuple_struct(tuple_type)
+        if len(op.items) == 0:  # empty tuple
+            self.emit_line(f"{dest}.empty_struct_error_flag = 0;")
+        else:
+            for i, item in enumerate(op.items):
+                self.emit_line(f"{dest}.f{i} = {self.reg(item)};")
+
+    def visit_assign(self, op: Assign) -> None:
+        dest = self.reg(op.dest)
+        src = self.reg(op.src)
+        # clang whines about self assignment (which we might generate
+        # for some casts), so don't emit it.
+        if dest != src:
+            src_type = op.src.type
+            dest_type = op.dest.type
+            if src_type.is_unboxed and not dest_type.is_unboxed:
+                # We sometimes assign from an integer prepresentation of a pointer
+                # to a real pointer, and C compilers insist on a cast.
+                src = f"(void *){src}"
+            elif not src_type.is_unboxed and dest_type.is_unboxed:
+                # We sometimes assign a pointer to an integer type (e.g. to create
+                # tagged pointers), and here we need an explicit cast.
+                src = f"({self.emitter.ctype(dest_type)}){src}"
+            self.emit_line(f"{dest} = {src};")
+
+    def visit_assign_multi(self, op: AssignMulti) -> None:
+        typ = op.dest.type
+        assert isinstance(typ, RArray), typ
+        dest = self.reg(op.dest)
+        # RArray values can only be assigned to once, so we can always
+        # declare them on initialization.
+        self.emit_line(
+            "%s%s[%d] = %s;"
+            % (
+                self.emitter.ctype_spaced(typ.item_type),
+                dest,
+                len(op.src),
+                c_array_initializer([self.reg(s) for s in op.src], indented=True),
+            )
+        )
+
+    def visit_load_error_value(self, op: LoadErrorValue) -> None:
+        reg = self.reg(op)
+        if isinstance(op.type, RTuple):
+            values = [self.c_undefined_value(item) for item in op.type.types]
+            tmp = self.temp_name()
+            self.emit_line("{} {} = {{ {} }};".format(self.ctype(op.type), tmp, ", ".join(values)))
+            self.emit_line(f"{reg} = {tmp};")
+        elif isinstance(op.type, RVec):
+            self.emitter.set_undefined_value(reg, op.type)
+        else:
+            self.emit_line(f"{self.reg(op)} = {self.c_error_value(op.type)};")
+
+    def visit_load_literal(self, op: LoadLiteral) -> None:
+        index = self.literals.literal_index(op.value)
+        if not is_int_rprimitive(op.type):
+            self.emit_line("%s = CPyStatics[%d];" % (self.reg(op), index), ann=op.value)
+        else:
+            self.emit_line(
+                "%s = (CPyTagged)CPyStatics[%d] | 1;" % (self.reg(op), index), ann=op.value
+            )
+
+    def get_attr_expr(self, obj: str, op: GetAttr | SetAttr, decl_cl: ClassIR) -> str:
+        """Generate attribute accessor for normal (non-property) access.
+
+        This either has a form like obj->attr_name for attributes defined in non-trait
+        classes, and *(obj + attr_offset) for attributes defined by traits. We also
+        insert all necessary C casts here.
+        """
+        cast = f"({op.class_type.struct_name(self.emitter.names)} *)"
+        if decl_cl.is_trait and op.class_type.class_ir.is_trait:
+            # For pure trait access find the offset first, offsets
+            # are ordered by attribute position in the cl.attributes dict.
+            # TODO: pre-calculate the mapping to make this faster.
+            trait_attr_index = list(decl_cl.attributes).index(op.attr)
+            # TODO: reuse these names somehow?
+            offset = self.emitter.temp_name()
+            self.declarations.emit_line(f"size_t {offset};")
+            self.emitter.emit_line(
+                "{} = {};".format(
+                    offset,
+                    "CPy_FindAttrOffset({}, {}, {})".format(
+                        self.emitter.type_struct_name(decl_cl),
+                        f"({cast}{obj})->vtable",
+                        trait_attr_index,
+                    ),
+                )
+            )
+            attr_cast = f"({self.ctype(op.class_type.attr_type(op.attr))} *)"
+            return f"*{attr_cast}((char *){obj} + {offset})"
+        else:
+            # Cast to something non-trait. Note: for this to work, all struct
+            # members for non-trait classes must obey monotonic linear growth.
+            if op.class_type.class_ir.is_trait:
+                assert not decl_cl.is_trait
+                cast = f"({decl_cl.struct_name(self.emitter.names)} *)"
+            return f"({cast}{obj})->{self.emitter.attr(op.attr)}"
+
+    def visit_get_attr(self, op: GetAttr) -> None:
+        if op.allow_error_value:
+            self.get_attr_with_allow_error_value(op)
+            return
+        dest = self.reg(op)
+        obj = self.reg(op.obj)
+        rtype = op.class_type
+        cl = rtype.class_ir
+        attr_rtype, decl_cl = cl.attr_details(op.attr)
+        prefer_method = cl.is_trait and attr_rtype.error_overlap
+        if cl.get_method(op.attr, prefer_method=prefer_method):
+            # Properties are essentially methods, so use vtable access for them.
+            if cl.is_method_final(op.attr):
+                self.emit_method_call(f"{dest} = ", op.obj, op.attr, [])
+            else:
+                version = "_TRAIT" if cl.is_trait else ""
+                self.emit_line(
+                    "%s = CPY_GET_ATTR%s(%s, %s, %d, %s, %s); /* %s */"
+                    % (
+                        dest,
+                        version,
+                        obj,
+                        self.emitter.type_struct_name(rtype.class_ir),
+                        rtype.getter_index(op.attr),
+                        rtype.struct_name(self.names),
+                        self.ctype(rtype.attr_type(op.attr)),
+                        op.attr,
+                    )
+                )
+        else:
+            # Otherwise, use direct or offset struct access.
+            attr_expr = self.get_attr_expr(obj, op, decl_cl)
+            self.emitter.emit_line(f"{dest} = {attr_expr};")
+            always_defined = cl.is_always_defined(op.attr)
+            merged_branch = None
+            if not always_defined:
+                self.emitter.emit_undefined_attr_check(
+                    attr_rtype, dest, "==", obj, op.attr, cl, unlikely=True
+                )
+                branch = self.next_branch()
+                if branch is not None:
+                    if (
+                        branch.value is op
+                        and branch.op == Branch.IS_ERROR
+                        and branch.traceback_entry is not None
+                        and not branch.negated
+                    ):
+                        # Generate code for the following branch here to avoid
+                        # redundant branches in the generated code.
+                        self.emit_attribute_error(branch, cl.name, op.attr)
+                        self.emit_line("goto %s;" % self.label(branch.true))
+                        merged_branch = branch
+                        self.emitter.emit_line("}")
+                if not merged_branch:
+                    exc_class = "PyExc_AttributeError"
+                    self.emitter.emit_line(
+                        'PyErr_SetString({}, "attribute {} of {} undefined");'.format(
+                            exc_class,
+                            repr(op.attr.removeprefix(GENERATOR_ATTRIBUTE_PREFIX)),
+                            repr(cl.name),
+                        )
+                    )
+
+            if attr_rtype.is_refcounted and not op.is_borrowed:
+                if not merged_branch and not always_defined:
+                    self.emitter.emit_line("} else {")
+                self.emitter.emit_inc_ref(dest, attr_rtype)
+            if merged_branch:
+                if merged_branch.false is not self.next_block:
+                    self.emit_line("goto %s;" % self.label(merged_branch.false))
+                self.op_index += 1
+            elif not always_defined:
+                self.emitter.emit_line("}")
+
+    def get_attr_with_allow_error_value(self, op: GetAttr) -> None:
+        """Handle GetAttr with allow_error_value=True.
+
+        This allows NULL or other error value without raising AttributeError.
+        """
+        dest = self.reg(op)
+        obj = self.reg(op.obj)
+        rtype = op.class_type
+        cl = rtype.class_ir
+        attr_rtype, decl_cl = cl.attr_details(op.attr)
+
+        # Direct struct access without NULL check
+        attr_expr = self.get_attr_expr(obj, op, decl_cl)
+        self.emitter.emit_line(f"{dest} = {attr_expr};")
+
+        # Only emit inc_ref if not NULL
+        if attr_rtype.is_refcounted and not op.is_borrowed:
+            check = self.error_value_check(op, "!=")
+            self.emitter.emit_line(f"if ({check}) {{")
+            self.emitter.emit_inc_ref(dest, attr_rtype)
+            self.emitter.emit_line("}")
+
+    def next_branch(self) -> Branch | None:
+        if self.op_index + 1 < len(self.ops):
+            next_op = self.ops[self.op_index + 1]
+            if isinstance(next_op, Branch):
+                return next_op
+        return None
+
+    def visit_set_attr(self, op: SetAttr) -> None:
+        if op.error_kind == ERR_FALSE:
+            dest = self.reg(op)
+        obj = self.reg(op.obj)
+        src = self.reg(op.src)
+        rtype = op.class_type
+        cl = rtype.class_ir
+        attr_rtype, decl_cl = cl.attr_details(op.attr)
+        if op.is_propset:
+            # Again, use vtable access for properties...
+            assert not op.is_init and op.error_kind == ERR_FALSE, "%s %d %d %s" % (
+                op.attr,
+                op.is_init,
+                op.error_kind,
+                rtype,
+            )
+            version = "_TRAIT" if cl.is_trait else ""
+            self.emit_line(
+                "%s = CPY_SET_ATTR%s(%s, %s, %d, %s, %s, %s); /* %s */"
+                % (
+                    dest,
+                    version,
+                    obj,
+                    self.emitter.type_struct_name(rtype.class_ir),
+                    rtype.setter_index(op.attr),
+                    src,
+                    rtype.struct_name(self.names),
+                    self.ctype(rtype.attr_type(op.attr)),
+                    op.attr,
+                )
+            )
+        else:
+            # ...and struct access for normal attributes.
+            attr_expr = self.get_attr_expr(obj, op, decl_cl)
+            if not op.is_init and attr_rtype.is_refcounted:
+                # This is not an initialization (where we know that the attribute was
+                # previously undefined), so decref the old value.
+                always_defined = cl.is_always_defined(op.attr)
+                if not always_defined:
+                    self.emitter.emit_undefined_attr_check(
+                        attr_rtype, attr_expr, "!=", obj, op.attr, cl
+                    )
+                self.emitter.emit_dec_ref(attr_expr, attr_rtype)
+                if not always_defined:
+                    self.emitter.emit_line("}")
+            elif attr_rtype.error_overlap and not cl.is_always_defined(op.attr):
+                # If there is overlap with the error value, update bitmap to mark
+                # attribute as defined.
+                self.emitter.emit_attr_bitmap_set(src, obj, attr_rtype, cl, op.attr)
+
+            # This steals the reference to src, so we don't need to increment the arg
+            self.emitter.emit_line(f"{attr_expr} = {src};")
+            if op.error_kind == ERR_FALSE:
+                self.emitter.emit_line(f"{dest} = 1;")
+
+    def visit_load_static(self, op: LoadStatic) -> None:
+        dest = self.reg(op)
+        prefix = PREFIX_MAP[op.namespace]
+        name = self.emitter.static_name(op.identifier, op.module_name, prefix)
+        if op.namespace == NAMESPACE_TYPE:
+            name = "(PyObject *)%s" % name
+        self.emit_line(f"{dest} = {name};", ann=op.ann)
+
+    def visit_init_static(self, op: InitStatic) -> None:
+        value = self.reg(op.value)
+        prefix = PREFIX_MAP[op.namespace]
+        name = self.emitter.static_name(op.identifier, op.module_name, prefix)
+        if op.namespace == NAMESPACE_TYPE:
+            value = "(PyTypeObject *)%s" % value
+        self.emit_line(f"{name} = {value};")
+        self.emit_inc_ref(name, op.value.type)
+
+    def visit_tuple_get(self, op: TupleGet) -> None:
+        dest = self.reg(op)
+        src = self.reg(op.src)
+        self.emit_line(f"{dest} = {src}.f{op.index};")
+        if not op.is_borrowed:
+            self.emit_inc_ref(dest, op.type)
+
+    def get_dest_assign(self, dest: Value) -> str:
+        if not dest.is_void:
+            return self.reg(dest) + " = "
+        else:
+            return ""
+
+    def visit_call(self, op: Call) -> None:
+        """Call native function."""
+        dest = self.get_dest_assign(op)
+        args = ", ".join(self.reg(arg) for arg in op.args)
+        lib = self.emitter.get_group_prefix(op.fn)
+        cname = op.fn.cname(self.names)
+        self.emit_line(f"{dest}{lib}{NATIVE_PREFIX}{cname}({args});")
+
+    def visit_method_call(self, op: MethodCall) -> None:
+        """Call native method."""
+        dest = self.get_dest_assign(op)
+        self.emit_method_call(dest, op.obj, op.method, op.args)
+
+    def emit_method_call(self, dest: str, op_obj: Value, name: str, op_args: list[Value]) -> None:
+        obj = self.reg(op_obj)
+        rtype = op_obj.type
+        assert isinstance(rtype, RInstance), rtype
+        class_ir = rtype.class_ir
+        method = rtype.class_ir.get_method(name)
+        assert method is not None
+
+        # Can we call the method directly, bypassing vtable?
+        is_direct = class_ir.is_method_final(name)
+
+        # The first argument gets omitted for static methods and
+        # turned into the class for class methods
+        obj_args = (
+            []
+            if method.decl.kind == FUNC_STATICMETHOD
+            else [f"(PyObject *)Py_TYPE({obj})"] if method.decl.kind == FUNC_CLASSMETHOD else [obj]
+        )
+        args = ", ".join(obj_args + [self.reg(arg) for arg in op_args])
+        mtype = native_function_type(method, self.emitter)
+        version = "_TRAIT" if rtype.class_ir.is_trait else ""
+        if is_direct:
+            # Directly call method, without going through the vtable.
+            lib = self.emitter.get_group_prefix(method.decl)
+            self.emit_line(f"{dest}{lib}{NATIVE_PREFIX}{method.cname(self.names)}({args});")
+        else:
+            # Call using vtable.
+            method_idx = rtype.method_index(name)
+            self.emit_line(
+                "{}CPY_GET_METHOD{}({}, {}, {}, {}, {})({}); /* {} */".format(
+                    dest,
+                    version,
+                    obj,
+                    self.emitter.type_struct_name(rtype.class_ir),
+                    method_idx,
+                    rtype.struct_name(self.names),
+                    mtype,
+                    args,
+                    name,
+                )
+            )
+
+    def visit_inc_ref(self, op: IncRef) -> None:
+        if (
+            isinstance(op.src, Box)
+            and (is_none_rprimitive(op.src.src.type) or is_bool_or_bit_rprimitive(op.src.src.type))
+            and HAVE_IMMORTAL
+        ):
+            # On Python 3.12+, None/True/False are immortal, and we can skip inc ref
+            return
+
+        if isinstance(op.src, LoadLiteral) and HAVE_IMMORTAL:
+            value = op.src.value
+            # We can skip inc ref for immortal literals on Python 3.12+
+            if type(value) is int and -5 <= value <= 256:
+                # Small integers are immortal
+                return
+
+        src = self.reg(op.src)
+        self.emit_inc_ref(src, op.src.type)
+
+    def visit_dec_ref(self, op: DecRef) -> None:
+        src = self.reg(op.src)
+        self.emit_dec_ref(src, op.src.type, is_xdec=op.is_xdec)
+
+    def visit_box(self, op: Box) -> None:
+        self.emitter.emit_box(self.reg(op.src), self.reg(op), op.src.type, can_borrow=True)
+
+    def visit_cast(self, op: Cast) -> None:
+        if op.is_unchecked and op.is_borrowed:
+            self.emit_line(f"{self.reg(op)} = {self.reg(op.src)};")
+            return
+        branch = self.next_branch()
+        handler = None
+        if branch is not None:
+            if (
+                branch.value is op
+                and branch.op == Branch.IS_ERROR
+                and branch.traceback_entry is not None
+                and not branch.negated
+                and branch.false is self.next_block
+            ):
+                # Generate code also for the following branch here to avoid
+                # redundant branches in the generated code.
+                handler = TracebackAndGotoHandler(
+                    self.label(branch.true),
+                    self.source_path,
+                    self.module_name,
+                    branch.traceback_entry,
+                )
+                self.op_index += 1
+
+        self.emitter.emit_cast(
+            self.reg(op.src), self.reg(op), op.type, src_type=op.src.type, error=handler
+        )
+
+    def visit_unbox(self, op: Unbox) -> None:
+        self.emitter.emit_unbox(self.reg(op.src), self.reg(op), op.type)
+
+    def visit_unreachable(self, op: Unreachable) -> None:
+        self.emitter.emit_line("CPy_Unreachable();")
+
+    def visit_raise_standard_error(self, op: RaiseStandardError) -> None:
+        # TODO: Better escaping of backspaces and such
+        if op.value is not None:
+            if isinstance(op.value, str):
+                message = op.value.replace('"', '\\"')
+                self.emitter.emit_line(f'PyErr_SetString(PyExc_{op.class_name}, "{message}");')
+            elif isinstance(op.value, Value):
+                self.emitter.emit_line(
+                    "PyErr_SetObject(PyExc_{}, {});".format(
+                        op.class_name, self.emitter.reg(op.value)
+                    )
+                )
+            else:
+                assert False, "op value type must be either str or Value"
+        else:
+            self.emitter.emit_line(f"PyErr_SetNone(PyExc_{op.class_name});")
+        self.emitter.emit_line(f"{self.reg(op)} = 0;")
+
+    def visit_call_c(self, op: CallC) -> None:
+        if op.is_void:
+            dest = ""
+        else:
+            dest = self.get_dest_assign(op)
+        args = ", ".join(self.reg(arg) for arg in op.args)
+        self.emitter.emit_line(f"{dest}{op.function_name}({args});")
+
+    def visit_primitive_op(self, op: PrimitiveOp) -> None:
+        raise RuntimeError(
+            f"unexpected PrimitiveOp {op.desc.name}: they must be lowered before codegen"
+        )
+
+    def visit_truncate(self, op: Truncate) -> None:
+        dest = self.reg(op)
+        value = self.reg(op.src)
+        # for C backend the generated code are straight assignments
+        self.emit_line(f"{dest} = {value};")
+
+    def visit_extend(self, op: Extend) -> None:
+        dest = self.reg(op)
+        value = self.reg(op.src)
+        if op.signed:
+            src_cast = self.emit_signed_int_cast(op.src.type)
+        else:
+            src_cast = self.emit_unsigned_int_cast(op.src.type)
+        self.emit_line(f"{dest} = {src_cast}{value};")
+
+    def visit_load_global(self, op: LoadGlobal) -> None:
+        dest = self.reg(op)
+        self.emit_line(f"{dest} = {op.identifier};", ann=op.ann)
+
+    def visit_int_op(self, op: IntOp) -> None:
+        dest = self.reg(op)
+        lhs = self.reg(op.lhs)
+        rhs = self.reg(op.rhs)
+        if op.op == IntOp.RIGHT_SHIFT:
+            # Signed right shift
+            lhs = self.emit_signed_int_cast(op.lhs.type) + lhs
+            rhs = self.emit_signed_int_cast(op.rhs.type) + rhs
+        self.emit_line(f"{dest} = {lhs} {op.op_str[op.op]} {rhs};")
+
+    def visit_comparison_op(self, op: ComparisonOp) -> None:
+        dest = self.reg(op)
+        lhs = self.reg(op.lhs)
+        rhs = self.reg(op.rhs)
+        lhs_cast = ""
+        rhs_cast = ""
+        if op.op in (ComparisonOp.SLT, ComparisonOp.SGT, ComparisonOp.SLE, ComparisonOp.SGE):
+            # Always signed comparison op
+            lhs_cast = self.emit_signed_int_cast(op.lhs.type)
+            rhs_cast = self.emit_signed_int_cast(op.rhs.type)
+        elif op.op in (ComparisonOp.ULT, ComparisonOp.UGT, ComparisonOp.ULE, ComparisonOp.UGE):
+            # Always unsigned comparison op
+            lhs_cast = self.emit_unsigned_int_cast(op.lhs.type)
+            rhs_cast = self.emit_unsigned_int_cast(op.rhs.type)
+        elif isinstance(op.lhs, Integer) and op.lhs.value < 0:
+            # Force signed ==/!= with negative operand
+            rhs_cast = self.emit_signed_int_cast(op.rhs.type)
+        elif isinstance(op.rhs, Integer) and op.rhs.value < 0:
+            # Force signed ==/!= with negative operand
+            lhs_cast = self.emit_signed_int_cast(op.lhs.type)
+        self.emit_line(f"{dest} = {lhs_cast}{lhs} {op.op_str[op.op]} {rhs_cast}{rhs};")
+
+    def visit_float_op(self, op: FloatOp) -> None:
+        dest = self.reg(op)
+        lhs = self.reg(op.lhs)
+        rhs = self.reg(op.rhs)
+        if op.op != FloatOp.MOD:
+            self.emit_line(f"{dest} = {lhs} {op.op_str[op.op]} {rhs};")
+        else:
+            # TODO: This may set errno as a side effect, that is a little sketchy.
+            self.emit_line(f"{dest} = fmod({lhs}, {rhs});")
+
+    def visit_float_neg(self, op: FloatNeg) -> None:
+        dest = self.reg(op)
+        src = self.reg(op.src)
+        self.emit_line(f"{dest} = -{src};")
+
+    def visit_float_comparison_op(self, op: FloatComparisonOp) -> None:
+        dest = self.reg(op)
+        lhs = self.reg(op.lhs)
+        rhs = self.reg(op.rhs)
+        self.emit_line(f"{dest} = {lhs} {op.op_str[op.op]} {rhs};")
+
+    def visit_load_mem(self, op: LoadMem) -> None:
+        dest = self.reg(op)
+        src = self.reg(op.src)
+        # TODO: we shouldn't dereference to type that are pointer type so far
+        type = self.ctype(op.type)
+        self.emit_line(f"{dest} = *({type} *){src};")
+        if not op.is_borrowed:
+            self.emit_inc_ref(dest, op.type)
+
+    def visit_set_mem(self, op: SetMem) -> None:
+        dest = self.reg(op.dest)
+        src = self.reg(op.src)
+        dest_type = self.ctype(op.dest_type)
+        # clang whines about self assignment (which we might generate
+        # for some casts), so don't emit it.
+        if dest != src:
+            self.emit_line(f"*({dest_type} *){dest} = {src};")
+
+    def visit_get_element(self, op: GetElement) -> None:
+        dest = self.reg(op)
+        src = self.reg(op.src)
+        dest_type = self.ctype(op.type)
+        self.emit_line(f"{dest} = ({dest_type}){src}.{op.field};")
+
+    def visit_get_element_ptr(self, op: GetElementPtr) -> None:
+        dest = self.reg(op)
+        src = self.reg(op.src)
+        # TODO: support tuple type
+        assert isinstance(op.src_type, RStruct), op.src_type
+        assert op.field in op.src_type.names, "Invalid field name."
+        # Use offsetof to avoid undefined behavior when src is NULL
+        # (e.g., vec buf pointer for empty vecs). The &((T*)p)->field
+        # pattern is UB when p is NULL, which GCC -O3 can exploit.
+        self.emit_line(
+            "{} = ({})((CPyPtr){} + offsetof({}, {}));".format(
+                dest, op.type._ctype, src, op.src_type.name, op.field
+            )
+        )
+
+    def visit_set_element(self, op: SetElement) -> None:
+        dest = self.reg(op)
+        item = self.reg(op.item)
+        field = op.field
+        if isinstance(op.src, Undef):
+            # First assignment to an undefined struct is trivial.
+            self.emit_line(f"{dest}.{field} = {item};")
+        else:
+            # In the general case create a copy of the struct with a single
+            # item modified.
+            #
+            # TODO: Can we do better if only a subset of fields are initialized?
+            # TODO: Make this less verbose in the common case
+            # TODO: Support tuples (or use RStruct for tuples)?
+            src = self.reg(op.src)
+            src_type = op.src.type
+            assert isinstance(src_type, RStruct), src_type
+            init_items = []
+            for n in src_type.names:
+                if n != field:
+                    init_items.append(f"{src}.{n}")
+                else:
+                    init_items.append(item)
+            self.emit_line(f"{dest} = ({self.ctype(src_type)}) {{ {', '.join(init_items)} }};")
+
+    def visit_load_address(self, op: LoadAddress) -> None:
+        typ = op.type
+        dest = self.reg(op)
+        if isinstance(op.src, Register):
+            src = self.reg(op.src)
+        elif isinstance(op.src, LoadStatic):
+            prefix = PREFIX_MAP[op.src.namespace]
+            src = self.emitter.static_name(op.src.identifier, op.src.module_name, prefix)
+        else:
+            src = op.src
+        self.emit_line(f"{dest} = ({typ._ctype})&{src};")
+
+    def visit_keep_alive(self, op: KeepAlive) -> None:
+        # This is a no-op.
+        pass
+
+    def visit_unborrow(self, op: Unborrow) -> None:
+        # This is a no-op that propagates the source value.
+        dest = self.reg(op)
+        src = self.reg(op.src)
+        self.emit_line(f"{dest} = {src};")
+
+    # Helpers
+
+    def label(self, label: BasicBlock) -> str:
+        return self.emitter.label(label)
+
+    def reg(self, reg: Value) -> str:
+        if isinstance(reg, Integer):
+            val = reg.value
+            if val == 0 and is_pointer_rprimitive(reg.type):
+                return "NULL"
+            s = str(val)
+            if val >= (1 << 31):
+                # Avoid overflowing signed 32-bit int
+                if val >= (1 << 63):
+                    s += "ULL"
+                else:
+                    s += "LL"
+            elif val == -(1 << 63):
+                # Avoid overflowing C integer literal
+                s = "(-9223372036854775807LL - 1)"
+            elif val <= -(1 << 31):
+                s += "LL"
+            return s
+        elif isinstance(reg, Float):
+            r = repr(reg.value)
+            if r == "inf":
+                return "INFINITY"
+            elif r == "-inf":
+                return "-INFINITY"
+            elif r == "nan":
+                return "NAN"
+            return r
+        elif isinstance(reg, CString):
+            return '"' + encode_c_string_literal(reg.value) + '"'
+        else:
+            return self.emitter.reg(reg)
+
+    def ctype(self, rtype: RType) -> str:
+        return self.emitter.ctype(rtype)
+
+    def c_error_value(self, rtype: RType) -> str:
+        return self.emitter.c_error_value(rtype)
+
+    def c_undefined_value(self, rtype: RType) -> str:
+        return self.emitter.c_undefined_value(rtype)
+
+    def emit_line(self, line: str, *, ann: object = None) -> None:
+        self.emitter.emit_line(line, ann=ann)
+
+    def emit_lines(self, *lines: str) -> None:
+        self.emitter.emit_lines(*lines)
+
+    def emit_inc_ref(self, dest: str, rtype: RType) -> None:
+        self.emitter.emit_inc_ref(dest, rtype, rare=self.rare)
+
+    def emit_dec_ref(self, dest: str, rtype: RType, is_xdec: bool) -> None:
+        self.emitter.emit_dec_ref(dest, rtype, is_xdec=is_xdec, rare=self.rare)
+
+    def emit_declaration(self, line: str) -> None:
+        self.declarations.emit_line(line)
+
+    def emit_traceback(self, op: Branch) -> None:
+        if op.traceback_entry is not None:
+            self.emitter.emit_traceback(self.source_path, self.module_name, op.traceback_entry)
+
+    def emit_attribute_error(self, op: Branch, class_name: str, attr: str) -> None:
+        assert op.traceback_entry is not None
+        if self.emitter.context.strict_traceback_checks:
+            assert (
+                op.traceback_entry[1] >= 0
+            ), "AttributeError traceback cannot have a negative line number"
+        globals_static = self.emitter.static_name("globals", self.module_name)
+        self.emit_line(
+            'CPy_AttributeError("%s", "%s", "%s", "%s", %d, %s);'
+            % (
+                self.source_path.replace("\\", "\\\\"),
+                op.traceback_entry[0],
+                class_name,
+                attr.removeprefix(GENERATOR_ATTRIBUTE_PREFIX),
+                op.traceback_entry[1],
+                globals_static,
+            )
+        )
+        if DEBUG_ERRORS:
+            self.emit_line('assert(PyErr_Occurred() != NULL && "failure w/o err!");')
+
+    def emit_signed_int_cast(self, type: RType) -> str:
+        if is_tagged(type):
+            return "(Py_ssize_t)"
+        else:
+            return ""
+
+    def emit_unsigned_int_cast(self, type: RType) -> str:
+        if is_int32_rprimitive(type):
+            return "(uint32_t)"
+        elif is_int64_rprimitive(type):
+            return "(uint64_t)"
+        else:
+            return ""
+
+
+_translation_table: Final[dict[int, str]] = {}
+
+
+def encode_c_string_literal(b: bytes) -> str:
+    """Convert bytestring to the C string literal syntax (with necessary escaping).
+
+    For example, b'foo\n' gets converted to 'foo\\n' (note that double quotes are not added).
+    """
+    if not _translation_table:
+        # Initialize the translation table on the first call.
+        d = {
+            ord("\n"): "\\n",
+            ord("\r"): "\\r",
+            ord("\t"): "\\t",
+            ord('"'): '\\"',
+            ord("\\"): "\\\\",
+        }
+        for i in range(256):
+            if i not in d:
+                if i < 32 or i >= 127:
+                    d[i] = "\\x%.2x" % i
+                else:
+                    d[i] = chr(i)
+        _translation_table.update(str.maketrans(d))
+    return b.decode("latin1").translate(_translation_table)

micromamba_root/Lib/site-packages/mypyc/codegen/emitmodule.py

@@ -0,0 +1,1494 @@
+"""Generate C code for a Python C extension module from Python source code."""
+
+# FIXME: Basically nothing in this file operates on the level of a
+#        single module and it should be renamed.
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from collections.abc import Iterable
+from typing import TypeVar
+
+from mypy.build import (
+    BuildResult,
+    BuildSource,
+    State,
+    build,
+    compute_hash,
+    create_metastore,
+    get_cache_names,
+    sorted_components,
+)
+from mypy.errors import CompileError
+from mypy.fscache import FileSystemCache
+from mypy.nodes import MypyFile
+from mypy.options import Options
+from mypy.plugin import Plugin, ReportConfigContext
+from mypy.util import hash_digest, json_dumps
+from mypyc.analysis.capsule_deps import find_class_dependencies, find_implicit_op_dependencies
+from mypyc.codegen.cstring import c_string_initializer
+from mypyc.codegen.emit import (
+    Emitter,
+    EmitterContext,
+    HeaderDeclaration,
+    c_array_initializer,
+    native_function_doc_initializer,
+)
+from mypyc.codegen.emitclass import generate_class, generate_class_reuse, generate_class_type_decl
+from mypyc.codegen.emitfunc import generate_native_function, native_function_header
+from mypyc.codegen.emitwrapper import (
+    generate_legacy_wrapper_function,
+    generate_wrapper_function,
+    legacy_wrapper_function_header,
+    wrapper_function_header,
+)
+from mypyc.codegen.literals import Literals
+from mypyc.common import (
+    EXT_SUFFIX,
+    IS_FREE_THREADED,
+    MODULE_PREFIX,
+    PREFIX,
+    RUNTIME_C_FILES,
+    TOP_LEVEL_NAME,
+    TYPE_VAR_PREFIX,
+    shared_lib_name,
+    short_id_from_name,
+)
+from mypyc.errors import Errors
+from mypyc.ir.deps import LIBRT_BASE64, LIBRT_STRINGS, LIBRT_TIME, LIBRT_VECS, SourceDep
+from mypyc.ir.func_ir import FuncIR
+from mypyc.ir.module_ir import ModuleIR, ModuleIRs, deserialize_modules
+from mypyc.ir.ops import DeserMaps, LoadLiteral
+from mypyc.ir.rtypes import RType
+from mypyc.irbuild.main import build_ir
+from mypyc.irbuild.mapper import Mapper
+from mypyc.irbuild.prepare import load_type_map
+from mypyc.namegen import NameGenerator, exported_name
+from mypyc.options import CompilerOptions
+from mypyc.transform.copy_propagation import do_copy_propagation
+from mypyc.transform.exceptions import insert_exception_handling
+from mypyc.transform.flag_elimination import do_flag_elimination
+from mypyc.transform.log_trace import insert_event_trace_logging
+from mypyc.transform.lower import lower_ir
+from mypyc.transform.refcount import insert_ref_count_opcodes
+from mypyc.transform.spill import insert_spills
+from mypyc.transform.uninit import insert_uninit_checks
+
+# All the modules being compiled are divided into "groups". A group
+# is a set of modules that are placed into the same shared library.
+# Two common configurations are that every module is placed in a group
+# by itself (fully separate compilation) and that every module is
+# placed in the same group (fully whole-program compilation), but we
+# support finer-grained control of the group as well.
+#
+# In fully whole-program compilation, we will generate N+1 extension
+# modules: one shim per module and one shared library containing all
+# the actual code.
+# In fully separate compilation, we (unfortunately) will generate 2*N
+# extension modules: one shim per module and also one library containing
+# each module's actual code. (This might be fixable in the future,
+# but allows a clean separation between setup of the export tables
+# (see generate_export_table) and running module top levels.)
+#
+# A group is represented as a list of BuildSources containing all of
+# its modules along with the name of the group. (Which can be None
+# only if we are compiling only a single group with a single file in it
+# and not using shared libraries).
+Group = tuple[list[BuildSource], str | None]
+Groups = list[Group]
+
+# A list of (file name, file contents) pairs.
+FileContents = list[tuple[str, str]]
+
+
+class MarkedDeclaration:
+    """Add a mark, useful for topological sort."""
+
+    def __init__(self, declaration: HeaderDeclaration, mark: bool) -> None:
+        self.declaration = declaration
+        self.mark = False
+
+
+class MypycPlugin(Plugin):
+    """Plugin for making mypyc interoperate properly with mypy incremental mode.
+
+    Basically the point of this plugin is to force mypy to recheck things
+    based on the demands of mypyc in a couple situations:
+      * Any modules in the same group must be compiled together, so we
+        tell mypy that modules depend on all their groupmates.
+      * If the IR metadata is missing or stale or any of the generated
+        C source files associated missing or stale, then we need to
+        recompile the module so we mark it as stale.
+    """
+
+    def __init__(
+        self, options: Options, compiler_options: CompilerOptions, groups: Groups
+    ) -> None:
+        super().__init__(options)
+        self.group_map: dict[str, tuple[str | None, list[str]]] = {}
+        for sources, name in groups:
+            modules = sorted(source.module for source in sources)
+            for id in modules:
+                self.group_map[id] = (name, modules)
+
+        self.compiler_options = compiler_options
+        self.metastore = create_metastore(options, parallel_worker=False)
+
+    def report_config_data(self, ctx: ReportConfigContext) -> tuple[str | None, list[str]] | None:
+        # The config data we report is the group map entry for the module.
+        # If the data is being used to check validity, we do additional checks
+        # that the IR cache exists and matches the metadata cache and all
+        # output source files exist and are up to date.
+
+        id, path, is_check = ctx.id, ctx.path, ctx.is_check
+
+        if id not in self.group_map:
+            return None
+
+        # If we aren't doing validity checks, just return the cache data
+        if not is_check:
+            return self.group_map[id]
+
+        # Load the metadata and IR cache
+        meta_path, _, _ = get_cache_names(id, path, self.options)
+        ir_path = get_ir_cache_name(id, path, self.options)
+        try:
+            meta_json = self.metastore.read(meta_path)
+            ir_json = self.metastore.read(ir_path)
+        except FileNotFoundError:
+            # This could happen if mypyc failed after mypy succeeded
+            # in the previous run or if some cache files got
+            # deleted. No big deal, just fail to load the cache.
+            return None
+
+        ir_data = json.loads(ir_json)
+
+        # Check that the IR cache matches the metadata cache
+        if hash_digest(meta_json) != ir_data["meta_hash"]:
+            return None
+
+        # Check that all the source files are present and as
+        # expected. The main situation where this would come up is the
+        # user deleting the build directory without deleting
+        # .mypy_cache, which we should handle gracefully.
+        for path, hash in ir_data["src_hashes"].items():
+            try:
+                with open(os.path.join(self.compiler_options.target_dir, path), "rb") as f:
+                    contents = f.read()
+            except FileNotFoundError:
+                return None
+            real_hash = hash_digest(contents)
+            if hash != real_hash:
+                return None
+
+        return self.group_map[id]
+
+    def get_additional_deps(self, file: MypyFile) -> list[tuple[int, str, int]]:
+        # Report dependency on modules in the module's group
+        return [(10, id, -1) for id in self.group_map.get(file.fullname, (None, []))[1]]
+
+
+def parse_and_typecheck(
+    sources: list[BuildSource],
+    options: Options,
+    compiler_options: CompilerOptions,
+    groups: Groups,
+    fscache: FileSystemCache | None = None,
+    alt_lib_path: str | None = None,
+) -> BuildResult:
+    assert options.strict_optional, "strict_optional must be turned on"
+    mypyc_plugin = MypycPlugin(options, compiler_options, groups)
+    result = build(
+        sources=sources,
+        options=options,
+        alt_lib_path=alt_lib_path,
+        fscache=fscache,
+        extra_plugins=[mypyc_plugin],
+    )
+    mypyc_plugin.metastore.close()
+    if result.errors:
+        raise CompileError(result.errors)
+    return result
+
+
+def compile_scc_to_ir(
+    scc: list[MypyFile],
+    result: BuildResult,
+    mapper: Mapper,
+    compiler_options: CompilerOptions,
+    errors: Errors,
+) -> ModuleIRs:
+    """Compile an SCC into ModuleIRs.
+
+    Any modules that this SCC depends on must have either been compiled,
+    type checked, or loaded from a cache into mapper.
+
+    Arguments:
+        scc: The list of MypyFiles to compile
+        result: The BuildResult from the mypy front-end
+        mapper: The Mapper object mapping mypy ASTs to class and func IRs
+        compiler_options: The compilation options
+        errors: Where to report any errors encountered
+
+    Returns the IR of the modules.
+    """
+
+    if compiler_options.verbose:
+        print("Compiling {}".format(", ".join(x.name for x in scc)))
+
+    # Generate basic IR, with missing exception and refcount handling.
+    modules = build_ir(scc, result.graph, result.types, mapper, compiler_options, errors)
+    if errors.num_errors > 0:
+        return modules
+
+    env_user_functions = {}
+    for module in modules.values():
+        for cls in module.classes:
+            if cls.env_user_function:
+                env_user_functions[cls.env_user_function] = cls
+
+    for module in modules.values():
+        for fn in module.functions:
+            # Insert checks for uninitialized values.
+            insert_uninit_checks(fn, compiler_options.strict_traceback_checks)
+            # Insert exception handling.
+            insert_exception_handling(fn, compiler_options.strict_traceback_checks)
+            # Insert reference count handling.
+            insert_ref_count_opcodes(fn)
+
+            if fn in env_user_functions:
+                insert_spills(fn, env_user_functions[fn])
+
+            if compiler_options.log_trace:
+                insert_event_trace_logging(fn, compiler_options)
+
+            # Switch to lower abstraction level IR.
+            lower_ir(fn, compiler_options)
+            # Calculate implicit module dependencies (needed for librt)
+            deps = find_implicit_op_dependencies(fn)
+            if deps is not None:
+                module.dependencies.update(deps)
+            # Perform optimizations.
+            do_copy_propagation(fn, compiler_options)
+            do_flag_elimination(fn, compiler_options)
+
+        # Calculate implicit dependencies from class attribute types
+        for cl in module.classes:
+            deps = find_class_dependencies(cl)
+            if deps is not None:
+                module.dependencies.update(deps)
+
+    return modules
+
+
+def compile_modules_to_ir(
+    result: BuildResult, mapper: Mapper, compiler_options: CompilerOptions, errors: Errors
+) -> ModuleIRs:
+    """Compile a collection of modules into ModuleIRs.
+
+    The modules to compile are specified as part of mapper's group_map.
+
+    Returns the IR of the modules.
+    """
+    deser_ctx = DeserMaps({}, {})
+    modules = {}
+
+    # Process the graph by SCC in topological order, like we do in mypy.build
+    for scc in sorted_components(result.graph):
+        scc_states = [result.graph[id] for id in scc.mod_ids]
+        trees = [st.tree for st in scc_states if st.id in mapper.group_map and st.tree]
+
+        if not trees:
+            continue
+
+        fresh = all(id not in result.manager.rechecked_modules for id in scc.mod_ids)
+        if fresh:
+            load_scc_from_cache(trees, result, mapper, deser_ctx)
+        else:
+            scc_ir = compile_scc_to_ir(trees, result, mapper, compiler_options, errors)
+            modules.update(scc_ir)
+
+    return modules
+
+
+def compile_ir_to_c(
+    groups: Groups,
+    modules: ModuleIRs,
+    result: BuildResult,
+    mapper: Mapper,
+    compiler_options: CompilerOptions,
+) -> dict[str | None, list[tuple[str, str]]]:
+    """Compile a collection of ModuleIRs to C source text.
+
+    Returns a dictionary mapping group names to a list of (file name,
+    file text) pairs.
+    """
+    source_paths = {
+        source.module: result.graph[source.module].xpath
+        for sources, _ in groups
+        for source in sources
+    }
+
+    names = NameGenerator(
+        [[source.module for source in sources] for sources, _ in groups],
+        separate=compiler_options.separate,
+    )
+
+    # Generate C code for each compilation group. Each group will be
+    # compiled into a separate extension module.
+    ctext: dict[str | None, list[tuple[str, str]]] = {}
+    for group_sources, group_name in groups:
+        group_modules = {
+            source.module: modules[source.module]
+            for source in group_sources
+            if source.module in modules
+        }
+        if not group_modules:
+            ctext[group_name] = []
+            continue
+        generator = GroupGenerator(
+            group_modules, source_paths, group_name, mapper.group_map, names, compiler_options
+        )
+        ctext[group_name] = generator.generate_c_for_modules()
+
+    return ctext
+
+
+def get_ir_cache_name(id: str, path: str, options: Options) -> str:
+    meta_path, _, _ = get_cache_names(id, path, options)
+    # Mypyc uses JSON cache even with --fixed-format-cache (for now).
+    return meta_path.replace(".meta.json", ".ir.json").replace(".meta.ff", ".ir.json")
+
+
+def get_state_ir_cache_name(state: State) -> str:
+    return get_ir_cache_name(state.id, state.xpath, state.options)
+
+
+def write_cache(
+    modules: ModuleIRs,
+    result: BuildResult,
+    group_map: dict[str, str | None],
+    ctext: dict[str | None, list[tuple[str, str]]],
+) -> None:
+    """Write out the cache information for modules.
+
+    Each module has the following cache information written (which is
+    in addition to the cache information written by mypy itself):
+      * A serialized version of its mypyc IR, minus the bodies of
+        functions. This allows code that depends on it to use
+        these serialized data structures when compiling against it
+        instead of needing to recompile it. (Compiling against a
+        module requires access to both its mypy and mypyc data
+        structures.)
+      * The hash of the mypy metadata cache file for the module.
+        This is used to ensure that the mypyc cache and the mypy
+        cache are in sync and refer to the same version of the code.
+        This is particularly important if mypyc crashes/errors/is
+        stopped after mypy has written its cache but before mypyc has.
+      * The hashes of all the source file outputs for the group
+        the module is in. This is so that the module will be
+        recompiled if the source outputs are missing.
+    """
+
+    hashes = {}
+    for name, files in ctext.items():
+        hashes[name] = {file: compute_hash(data) for file, data in files}
+
+    # Write out cache data
+    for id, module in modules.items():
+        st = result.graph[id]
+
+        meta_path, _, _ = get_cache_names(id, st.xpath, result.manager.options)
+        # If the metadata isn't there, skip writing the cache.
+        try:
+            meta_data = result.manager.metastore.read(meta_path)
+        except OSError:
+            continue
+
+        newpath = get_state_ir_cache_name(st)
+        ir_data = {
+            "ir": module.serialize(),
+            "meta_hash": hash_digest(meta_data),
+            "src_hashes": hashes[group_map[id]],
+        }
+
+        result.manager.metastore.write(newpath, json_dumps(ir_data))
+
+    result.manager.metastore.commit()
+
+
+def load_scc_from_cache(
+    scc: list[MypyFile], result: BuildResult, mapper: Mapper, ctx: DeserMaps
+) -> ModuleIRs:
+    """Load IR for an SCC of modules from the cache.
+
+    Arguments and return are as compile_scc_to_ir.
+    """
+    cache_data = {
+        k.fullname: json.loads(
+            result.manager.metastore.read(get_state_ir_cache_name(result.graph[k.fullname]))
+        )["ir"]
+        for k in scc
+    }
+    modules = deserialize_modules(cache_data, ctx)
+    load_type_map(mapper, scc, ctx)
+    return modules
+
+
+def collect_source_dependencies(modules: dict[str, ModuleIR]) -> set[SourceDep]:
+    """Collect all SourceDep dependencies from all modules."""
+    source_deps: set[SourceDep] = set()
+    for module in modules.values():
+        for dep in module.dependencies:
+            if isinstance(dep, SourceDep):
+                source_deps.add(dep)
+    return source_deps
+
+
+def compile_modules_to_c(
+    result: BuildResult, compiler_options: CompilerOptions, errors: Errors, groups: Groups
+) -> tuple[ModuleIRs, list[FileContents], Mapper]:
+    """Compile Python module(s) to the source of Python C extension modules.
+
+    This generates the source code for the "shared library" module
+    for each group. The shim modules are generated in mypyc.build.
+    Each shared library module provides, for each module in its group,
+    a PyCapsule containing an initialization function.
+    Additionally, it provides a capsule containing an export table of
+    pointers to all the group's functions and static variables.
+
+    Arguments:
+        result: The BuildResult from the mypy front-end
+        compiler_options: The compilation options
+        errors: Where to report any errors encountered
+        groups: The groups that we are compiling. See documentation of Groups type above.
+
+    Returns the IR of the modules and a list containing the generated files for each group.
+    """
+    # Construct a map from modules to what group they belong to
+    group_map = {source.module: lib_name for group, lib_name in groups for source in group}
+    mapper = Mapper(group_map)
+
+    # Sometimes when we call back into mypy, there might be errors.
+    # We don't want to crash when that happens.
+    result.manager.errors.set_file(
+        "<mypyc>", module=None, scope=None, options=result.manager.options
+    )
+
+    modules = compile_modules_to_ir(result, mapper, compiler_options, errors)
+    if errors.num_errors > 0:
+        return {}, [], Mapper({})
+
+    ctext = compile_ir_to_c(groups, modules, result, mapper, compiler_options)
+    write_cache(modules, result, group_map, ctext)
+
+    return modules, [ctext[name] for _, name in groups], mapper
+
+
+def generate_function_declaration(fn: FuncIR, emitter: Emitter) -> None:
+    emitter.context.declarations[emitter.native_function_name(fn.decl)] = HeaderDeclaration(
+        f"{native_function_header(fn.decl, emitter)};", needs_export=True
+    )
+    if fn.name != TOP_LEVEL_NAME and not fn.internal:
+        if is_fastcall_supported(fn, emitter.capi_version):
+            emitter.context.declarations[PREFIX + fn.cname(emitter.names)] = HeaderDeclaration(
+                f"{wrapper_function_header(fn, emitter.names)};"
+            )
+        else:
+            emitter.context.declarations[PREFIX + fn.cname(emitter.names)] = HeaderDeclaration(
+                f"{legacy_wrapper_function_header(fn, emitter.names)};"
+            )
+
+
+def pointerize(decl: str, name: str) -> str:
+    """Given a C decl and its name, modify it to be a declaration to a pointer."""
+    # This doesn't work in general but does work for all our types...
+    if "(" in decl:
+        # Function pointer. Stick an * in front of the name and wrap it in parens.
+        return decl.replace(name, f"(*{name})")
+    else:
+        # Non-function pointer. Just stick an * in front of the name.
+        return decl.replace(name, f"*{name}")
+
+
+def group_dir(group_name: str) -> str:
+    """Given a group name, return the relative directory path for it."""
+    return os.sep.join(group_name.split(".")[:-1])
+
+
+class GroupGenerator:
+    def __init__(
+        self,
+        modules: dict[str, ModuleIR],
+        source_paths: dict[str, str],
+        group_name: str | None,
+        group_map: dict[str, str | None],
+        names: NameGenerator,
+        compiler_options: CompilerOptions,
+    ) -> None:
+        """Generator for C source for a compilation group.
+
+        The code for a compilation group contains an internal and an
+        external .h file, and then one .c if not in multi_file mode or
+        one .c file per module if in multi_file mode.
+
+        Arguments:
+            modules: (name, ir) pairs for each module in the group
+            source_paths: Map from module names to source file paths
+            group_name: The name of the group (or None if this is single-module compilation)
+            group_map: A map of modules to their group names
+            names: The name generator for the compilation
+            compiler_options: Mypyc specific options, including multi_file mode
+        """
+        self.modules = modules
+        self.source_paths = source_paths
+        self.context = EmitterContext(
+            names, compiler_options.strict_traceback_checks, group_name, group_map
+        )
+        self.names = names
+        # Initializations of globals to simple values that we can't
+        # do statically because the windows loader is bad.
+        self.simple_inits: list[tuple[str, str]] = []
+        self.group_name = group_name
+        self.use_shared_lib = group_name is not None
+        self.compiler_options = compiler_options
+        self.multi_file = compiler_options.multi_file
+        # Multi-phase init is needed to enable free-threading. In the future we'll
+        # probably want to enable it always, but we'll wait until it's stable.
+        self.multi_phase_init = IS_FREE_THREADED
+
+    @property
+    def group_suffix(self) -> str:
+        return "_" + exported_name(self.group_name) if self.group_name else ""
+
+    @property
+    def short_group_suffix(self) -> str:
+        return "_" + exported_name(self.group_name.split(".")[-1]) if self.group_name else ""
+
+    def generate_c_for_modules(self) -> list[tuple[str, str]]:
+        file_contents = []
+        multi_file = self.use_shared_lib and self.multi_file
+
+        # Collect all literal refs in IR.
+        for module in self.modules.values():
+            for fn in module.functions:
+                collect_literals(fn, self.context.literals)
+
+        base_emitter = Emitter(self.context)
+        # Optionally just include the runtime library c files to
+        # reduce the number of compiler invocations needed
+        if self.compiler_options.include_runtime_files:
+            for name in RUNTIME_C_FILES:
+                base_emitter.emit_line(f'#include "{name}"')
+            # Include conditional source files
+            source_deps = collect_source_dependencies(self.modules)
+            for source_dep in sorted(source_deps, key=lambda d: d.path):
+                base_emitter.emit_line(f'#include "{source_dep.path}"')
+        base_emitter.emit_line(f'#include "__native{self.short_group_suffix}.h"')
+        base_emitter.emit_line(f'#include "__native_internal{self.short_group_suffix}.h"')
+        emitter = base_emitter
+
+        self.generate_literal_tables()
+
+        for module_name, module in self.modules.items():
+            if multi_file:
+                emitter = Emitter(self.context, filepath=self.source_paths[module_name])
+                emitter.emit_line(f'#include "__native{self.short_group_suffix}.h"')
+                emitter.emit_line(f'#include "__native_internal{self.short_group_suffix}.h"')
+
+            self.declare_module(module_name, emitter)
+            self.declare_internal_globals(module_name, emitter)
+            self.declare_imports(module.imports, emitter)
+
+            for cl in module.classes:
+                if cl.is_ext_class:
+                    generate_class(cl, module_name, emitter)
+
+            # Generate Python extension module definitions and module initialization functions.
+            self.generate_module_def(emitter, module_name, module)
+
+            for fn in module.functions:
+                emitter.emit_line()
+                generate_native_function(fn, emitter, self.source_paths[module_name], module_name)
+                if fn.name != TOP_LEVEL_NAME and not fn.internal:
+                    emitter.emit_line()
+                    if is_fastcall_supported(fn, emitter.capi_version):
+                        generate_wrapper_function(
+                            fn, emitter, self.source_paths[module_name], module_name
+                        )
+                    else:
+                        generate_legacy_wrapper_function(
+                            fn, emitter, self.source_paths[module_name], module_name
+                        )
+            if multi_file:
+                name = f"__native_{exported_name(module_name)}.c"
+                file_contents.append((name, "".join(emitter.fragments)))
+
+        # The external header file contains type declarations while
+        # the internal contains declarations of functions and objects
+        # (which are shared between shared libraries via dynamic
+        # exports tables and not accessed directly.)
+        ext_declarations = Emitter(self.context)
+        ext_declarations.emit_line(f"#ifndef MYPYC_NATIVE{self.group_suffix}_H")
+        ext_declarations.emit_line(f"#define MYPYC_NATIVE{self.group_suffix}_H")
+        ext_declarations.emit_line("#include <Python.h>")
+        ext_declarations.emit_line("#include <CPy.h>")
+        if self.compiler_options.depends_on_librt_internal:
+            ext_declarations.emit_line("#include <internal/librt_internal.h>")
+        if any(LIBRT_BASE64 in mod.dependencies for mod in self.modules.values()):
+            ext_declarations.emit_line("#include <base64/librt_base64.h>")
+        if any(LIBRT_STRINGS in mod.dependencies for mod in self.modules.values()):
+            ext_declarations.emit_line("#include <strings/librt_strings.h>")
+        if any(LIBRT_TIME in mod.dependencies for mod in self.modules.values()):
+            ext_declarations.emit_line("#include <time/librt_time.h>")
+        if any(LIBRT_VECS in mod.dependencies for mod in self.modules.values()):
+            ext_declarations.emit_line("#include <vecs/librt_vecs.h>")
+        # Include headers for conditional source files
+        source_deps = collect_source_dependencies(self.modules)
+        for source_dep in sorted(source_deps, key=lambda d: d.path):
+            ext_declarations.emit_line(f'#include "{source_dep.get_header()}"')
+
+        declarations = Emitter(self.context)
+        declarations.emit_line(f"#ifndef MYPYC_LIBRT_INTERNAL{self.group_suffix}_H")
+        declarations.emit_line(f"#define MYPYC_LIBRT_INTERNAL{self.group_suffix}_H")
+        declarations.emit_line("#include <Python.h>")
+        declarations.emit_line("#include <CPy.h>")
+        declarations.emit_line(f'#include "__native{self.short_group_suffix}.h"')
+        declarations.emit_line()
+        declarations.emit_line("int CPyGlobalsInit(void);")
+        declarations.emit_line()
+
+        for module_name, module in self.modules.items():
+            self.declare_finals(module_name, module.final_names, declarations)
+            for cl in module.classes:
+                generate_class_type_decl(cl, emitter, ext_declarations, declarations)
+                if cl.reuse_freed_instance:
+                    generate_class_reuse(cl, emitter, ext_declarations, declarations)
+            self.declare_type_vars(module_name, module.type_var_names, declarations)
+            for fn in module.functions:
+                generate_function_declaration(fn, declarations)
+
+        for lib in sorted(self.context.group_deps):
+            elib = exported_name(lib)
+            short_lib = exported_name(lib.split(".")[-1])
+            declarations.emit_lines(
+                "#include <{}>".format(os.path.join(group_dir(lib), f"__native_{short_lib}.h")),
+                f"struct export_table_{elib} exports_{elib};",
+            )
+
+        sorted_decls = self.toposort_declarations()
+
+        emitter = base_emitter
+        self.generate_globals_init(emitter)
+
+        emitter.emit_line()
+
+        for declaration in sorted_decls:
+            decls = ext_declarations if declaration.is_type else declarations
+            if not declaration.is_type:
+                decls.emit_lines(f"extern {declaration.decl[0]}", *declaration.decl[1:])
+                # If there is a definition, emit it. Otherwise, repeat the declaration
+                # (without an extern).
+                if declaration.defn:
+                    emitter.emit_lines(*declaration.defn)
+                else:
+                    emitter.emit_lines(*declaration.decl)
+            else:
+                decls.emit_lines(*declaration.decl)
+
+        if self.group_name:
+            if self.compiler_options.separate:
+                self.generate_export_table(ext_declarations, emitter)
+
+            self.generate_shared_lib_init(emitter)
+
+        ext_declarations.emit_line("#endif")
+        declarations.emit_line("#endif")
+
+        output_dir = group_dir(self.group_name) if self.group_name else ""
+        return file_contents + [
+            (
+                os.path.join(output_dir, f"__native{self.short_group_suffix}.c"),
+                "".join(emitter.fragments),
+            ),
+            (
+                os.path.join(output_dir, f"__native_internal{self.short_group_suffix}.h"),
+                "".join(declarations.fragments),
+            ),
+            (
+                os.path.join(output_dir, f"__native{self.short_group_suffix}.h"),
+                "".join(ext_declarations.fragments),
+            ),
+        ]
+
+    def generate_literal_tables(self) -> None:
+        """Generate tables containing descriptions of Python literals to construct.
+
+        We will store the constructed literals in a single array that contains
+        literals of all types. This way we can refer to an arbitrary literal by
+        its index.
+        """
+        literals = self.context.literals
+        # During module initialization we store all the constructed objects here
+        self.declare_global("PyObject *[%d]" % literals.num_literals(), "CPyStatics")
+        # Descriptions of str literals
+        init_str = c_string_array_initializer(literals.encoded_str_values())
+        self.declare_global("const char * const []", "CPyLit_Str", initializer=init_str)
+        # Descriptions of bytes literals
+        init_bytes = c_string_array_initializer(literals.encoded_bytes_values())
+        self.declare_global("const char * const []", "CPyLit_Bytes", initializer=init_bytes)
+        # Descriptions of int literals
+        init_int = c_string_array_initializer(literals.encoded_int_values())
+        self.declare_global("const char * const []", "CPyLit_Int", initializer=init_int)
+        # Descriptions of float literals
+        init_floats = c_array_initializer(literals.encoded_float_values())
+        self.declare_global("const double []", "CPyLit_Float", initializer=init_floats)
+        # Descriptions of complex literals
+        init_complex = c_array_initializer(literals.encoded_complex_values())
+        self.declare_global("const double []", "CPyLit_Complex", initializer=init_complex)
+        # Descriptions of tuple literals
+        init_tuple = c_array_initializer(literals.encoded_tuple_values())
+        self.declare_global("const int []", "CPyLit_Tuple", initializer=init_tuple)
+        # Descriptions of frozenset literals
+        init_frozenset = c_array_initializer(literals.encoded_frozenset_values())
+        self.declare_global("const int []", "CPyLit_FrozenSet", initializer=init_frozenset)
+
+    def generate_export_table(self, decl_emitter: Emitter, code_emitter: Emitter) -> None:
+        """Generate the declaration and definition of the group's export struct.
+
+        To avoid needing to deal with deeply platform specific issues
+        involving dynamic library linking (and some possibly
+        insurmountable issues involving cyclic dependencies), compiled
+        code accesses functions and data in other compilation groups
+        via an explicit "export struct".
+
+        Each group declares a struct type that contains a pointer to
+        every function and static variable it exports. It then
+        populates this struct and stores a pointer to it in a capsule
+        stored as an attribute named 'exports' on the group's shared
+        library's python module.
+
+        On load, a group's init function will import all of its
+        dependencies' exports tables using the capsule mechanism and
+        copy the contents into a local copy of the table (to eliminate
+        the need for a pointer indirection when accessing it).
+
+        Then, all calls to functions in another group and accesses to statics
+        from another group are done indirectly via the export table.
+
+        For example, a group containing a module b, where b contains a class B
+        and a function bar, would declare an export table like:
+            struct export_table_b {
+                PyTypeObject **CPyType_B;
+                PyObject *(*CPyDef_B)(CPyTagged cpy_r_x);
+                CPyTagged (*CPyDef_B___foo)(PyObject *cpy_r_self, CPyTagged cpy_r_y);
+                tuple_T2OI (*CPyDef_bar)(PyObject *cpy_r_x);
+                char (*CPyDef___top_level__)(void);
+            };
+        that would be initialized with:
+            static struct export_table_b exports = {
+                &CPyType_B,
+                &CPyDef_B,
+                &CPyDef_B___foo,
+                &CPyDef_bar,
+                &CPyDef___top_level__,
+            };
+        To call `b.foo`, then, a function in another group would do
+        `exports_b.CPyDef_bar(...)`.
+        """
+
+        decls = decl_emitter.context.declarations
+
+        decl_emitter.emit_lines("", f"struct export_table{self.group_suffix} {{")
+        for name, decl in decls.items():
+            if decl.needs_export:
+                decl_emitter.emit_line(pointerize("\n".join(decl.decl), name))
+
+        decl_emitter.emit_line("};")
+
+        code_emitter.emit_lines("", f"static struct export_table{self.group_suffix} exports = {{")
+        for name, decl in decls.items():
+            if decl.needs_export:
+                code_emitter.emit_line(f"&{name},")
+
+        code_emitter.emit_line("};")
+
+    def generate_shared_lib_init(self, emitter: Emitter) -> None:
+        """Generate the init function for a shared library.
+
+        A shared library contains all the actual code for a
+        compilation group.
+
+        The init function is responsible for creating Capsules that
+        wrap pointers to the initialization function of all the real
+        init functions for modules in this shared library as well as
+        the export table containing all the exported functions and
+        values from all the modules.
+
+        These capsules are stored in attributes of the shared library.
+        """
+        assert self.group_name is not None
+
+        emitter.emit_line()
+
+        short_name = shared_lib_name(self.group_name).split(".")[-1]
+
+        emitter.emit_lines(
+            f"static int exec_{short_name}(PyObject *module)",
+            "{",
+            "int res;",
+            "PyObject *capsule;",
+            "PyObject *tmp;",
+            "",
+        )
+
+        if self.compiler_options.separate:
+            emitter.emit_lines(
+                'capsule = PyCapsule_New(&exports, "{}.exports", NULL);'.format(
+                    shared_lib_name(self.group_name)
+                ),
+                "if (!capsule) {",
+                "goto fail;",
+                "}",
+                'res = PyObject_SetAttrString(module, "exports", capsule);',
+                "Py_DECREF(capsule);",
+                "if (res < 0) {",
+                "goto fail;",
+                "}",
+                "",
+            )
+
+        for mod in self.modules:
+            name = exported_name(mod)
+            if self.multi_phase_init:
+                capsule_func_prefix = "CPyExec_"
+                capsule_name_prefix = "exec_"
+                emitter.emit_line(f"extern int CPyExec_{name}(PyObject *);")
+            else:
+                capsule_func_prefix = "CPyInit_"
+                capsule_name_prefix = "init_"
+                emitter.emit_line(f"extern PyObject *CPyInit_{name}(void);")
+            emitter.emit_lines(
+                'capsule = PyCapsule_New((void *){}{}, "{}.{}{}", NULL);'.format(
+                    capsule_func_prefix,
+                    name,
+                    shared_lib_name(self.group_name),
+                    capsule_name_prefix,
+                    name,
+                ),
+                "if (!capsule) {",
+                "goto fail;",
+                "}",
+                f'res = PyObject_SetAttrString(module, "{capsule_name_prefix}{name}", capsule);',
+                "Py_DECREF(capsule);",
+                "if (res < 0) {",
+                "goto fail;",
+                "}",
+                "",
+            )
+
+        for group in sorted(self.context.group_deps):
+            egroup = exported_name(group)
+            emitter.emit_lines(
+                'tmp = PyImport_ImportModule("{}"); if (!tmp) goto fail; Py_DECREF(tmp);'.format(
+                    shared_lib_name(group)
+                ),
+                'struct export_table_{} *pexports_{} = PyCapsule_Import("{}.exports", 0);'.format(
+                    egroup, egroup, shared_lib_name(group)
+                ),
+                f"if (!pexports_{egroup}) {{",
+                "goto fail;",
+                "}",
+                "memcpy(&exports_{group}, pexports_{group}, sizeof(exports_{group}));".format(
+                    group=egroup
+                ),
+                "",
+            )
+
+        emitter.emit_lines("return 0;", "fail:", "return -1;", "}")
+
+        if self.multi_phase_init:
+            emitter.emit_lines(
+                f"static PyModuleDef_Slot slots_{short_name}[] = {{",
+                f"{{Py_mod_exec, exec_{short_name}}},",
+                "{Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED},",
+                "{Py_mod_gil, Py_MOD_GIL_NOT_USED},",
+                "{0, NULL},",
+                "};",
+            )
+
+        size = 0 if self.multi_phase_init else -1
+        emitter.emit_lines(
+            f"static PyModuleDef module_def_{short_name} = {{",
+            "PyModuleDef_HEAD_INIT,",
+            f'.m_name = "{shared_lib_name(self.group_name)}",',
+            ".m_doc = NULL,",
+            f".m_size = {size},",
+            ".m_methods = NULL,",
+        )
+        if self.multi_phase_init:
+            emitter.emit_line(f".m_slots = slots_{short_name},")
+        emitter.emit_line("};")
+
+        if self.multi_phase_init:
+            emitter.emit_lines(
+                f"PyMODINIT_FUNC PyInit_{short_name}(void) {{",
+                f"return PyModuleDef_Init(&module_def_{short_name});",
+                "}",
+            )
+        else:
+            emitter.emit_lines(
+                f"PyMODINIT_FUNC PyInit_{short_name}(void) {{",
+                "static PyObject *module = NULL;",
+                "if (module) {",
+                "Py_INCREF(module);",
+                "return module;",
+                "}",
+                f"module = PyModule_Create(&module_def_{short_name});",
+                "if (!module) {",
+                "return NULL;",
+                "}",
+                f"if (exec_{short_name}(module) < 0) {{",
+                "Py_DECREF(module);",
+                "return NULL;",
+                "}",
+                "return module;",
+                "}",
+            )
+
+    def generate_globals_init(self, emitter: Emitter) -> None:
+        emitter.emit_lines(
+            "",
+            "int CPyGlobalsInit(void)",
+            "{",
+            "static int is_initialized = 0;",
+            "if (is_initialized) return 0;",
+            "",
+        )
+
+        emitter.emit_line("CPy_Init();")
+        for symbol, fixup in self.simple_inits:
+            emitter.emit_line(f"{symbol} = {fixup};")
+
+        values = "CPyLit_Str, CPyLit_Bytes, CPyLit_Int, CPyLit_Float, CPyLit_Complex, CPyLit_Tuple, CPyLit_FrozenSet"
+        emitter.emit_lines(
+            f"if (CPyStatics_Initialize(CPyStatics, {values}) < 0) {{", "return -1;", "}"
+        )
+
+        emitter.emit_lines("is_initialized = 1;", "return 0;", "}")
+
+    def generate_module_def(self, emitter: Emitter, module_name: str, module: ModuleIR) -> None:
+        """Emit the PyModuleDef struct for a module and the module init function."""
+        module_prefix = emitter.names.private_name(module_name)
+        self.emit_module_methods(emitter, module_name, module_prefix, module)
+        self.emit_module_exec_func(emitter, module_name, module_prefix, module)
+
+        # If using multi-phase init and a shared lib, parts of module definition
+        # will happen in the shim modules, so we skip some steps here.
+        if not (self.multi_phase_init and self.use_shared_lib):
+            if self.multi_phase_init:
+                self.emit_module_def_slots(emitter, module_prefix, module_name)
+            self.emit_module_def_struct(emitter, module_name, module_prefix)
+            self.emit_module_init_func(emitter, module_name, module_prefix)
+        elif self.use_shared_lib:
+            # Multi-phase init with shared lib: shims handle PyInit_*, but we
+            # still need CPyInitOnly_* for same-group native imports, and the
+            # PyModuleDef struct it depends on.
+            self.emit_module_def_struct(emitter, module_name, module_prefix)
+            self.emit_init_only_func(emitter, module_name, module_prefix)
+
+    def emit_module_def_slots(
+        self, emitter: Emitter, module_prefix: str, module_name: str
+    ) -> None:
+        name = f"{module_prefix}_slots"
+        exec_name = f"CPyExec_{exported_name(module_name)}"
+
+        emitter.emit_line(f"static PyModuleDef_Slot {name}[] = {{")
+        emitter.emit_line(f"{{Py_mod_exec, {exec_name}}},")
+        if sys.version_info >= (3, 12):
+            # Multiple interpreter support requires not using any C global state,
+            # which we don't support yet.
+            emitter.emit_line(
+                "{Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED},"
+            )
+        if sys.version_info >= (3, 13):
+            # Declare support for free-threading to enable experimentation,
+            # even if we don't properly support it.
+            emitter.emit_line("{Py_mod_gil, Py_MOD_GIL_NOT_USED},")
+        emitter.emit_line("{0, NULL},")
+        emitter.emit_line("};")
+
+    def emit_module_methods(
+        self, emitter: Emitter, module_name: str, module_prefix: str, module: ModuleIR
+    ) -> None:
+        """Emit module methods (the static PyMethodDef table)."""
+        emitter.emit_line(f"static PyMethodDef {module_prefix}module_methods[] = {{")
+        for fn in module.functions:
+            if fn.class_name is not None or fn.name == TOP_LEVEL_NAME:
+                continue
+            # Coroutines are added to the module dict when the module is initialized.
+            if fn.decl.is_coroutine:
+                continue
+            name = short_id_from_name(fn.name, fn.decl.shortname, fn.line)
+            if is_fastcall_supported(fn, emitter.capi_version):
+                flag = "METH_FASTCALL"
+            else:
+                flag = "METH_VARARGS"
+            doc = native_function_doc_initializer(fn)
+            emitter.emit_line(
+                (
+                    '{{"{name}", (PyCFunction){prefix}{cname}, {flag} | METH_KEYWORDS, '
+                    "PyDoc_STR({doc}) /* docstring */}},"
+                ).format(
+                    name=name, cname=fn.cname(emitter.names), prefix=PREFIX, flag=flag, doc=doc
+                )
+            )
+        emitter.emit_line("{NULL, NULL, 0, NULL}")
+        emitter.emit_line("};")
+        emitter.emit_line()
+
+    def emit_module_def_struct(
+        self, emitter: Emitter, module_name: str, module_prefix: str
+    ) -> None:
+        """Emit the static module definition struct (PyModuleDef)."""
+        emitter.emit_lines(
+            f"static struct PyModuleDef {module_prefix}module = {{",
+            "PyModuleDef_HEAD_INIT,",
+            f'"{module_name}",',
+            "NULL, /* docstring */",
+            "0,       /* size of per-interpreter state of the module */",
+        )
+        if self.multi_phase_init:
+            # Methods are added later via PyModule_AddFunctions in CPyExec_*.
+            emitter.emit_line("NULL, /* m_methods */")
+        else:
+            emitter.emit_line(f"{module_prefix}module_methods,")
+        if self.multi_phase_init and not self.use_shared_lib:
+            slots_name = f"{module_prefix}_slots"
+            emitter.emit_line(f"{slots_name}, /* m_slots */")
+        else:
+            emitter.emit_line("NULL,")
+        emitter.emit_line("};")
+        emitter.emit_line()
+
+    def emit_coroutine_wrappers(self, emitter: Emitter, module: ModuleIR, globals: str) -> None:
+        """Emit insertion of coroutines into the module dict when the module is initialized.
+        Coroutines are wrapped in CPyFunction objects to enable introspection by functions like
+        inspect.iscoroutinefunction(fn).
+        """
+        for fn in module.functions:
+            if fn.class_name is not None or fn.name == TOP_LEVEL_NAME:
+                continue
+            if not fn.decl.is_coroutine:
+                continue
+
+            filepath = self.source_paths[module.fullname]
+            error_stmt = "    goto fail;"
+            name = short_id_from_name(fn.name, fn.decl.shortname, fn.line)
+            wrapper_name = emitter.emit_cpyfunction_instance(fn, name, filepath, error_stmt)
+            name_obj = f"{wrapper_name}_name"
+            emitter.emit_line(f'PyObject *{name_obj} = PyUnicode_FromString("{fn.name}");')
+            emitter.emit_line(f"if (unlikely(!{name_obj}))")
+            emitter.emit_line(error_stmt)
+            emitter.emit_line(
+                f"if (PyDict_SetItem({globals}, {name_obj}, (PyObject *){wrapper_name}) < 0)"
+            )
+            emitter.emit_line(error_stmt)
+
+    def emit_module_exec_func(
+        self, emitter: Emitter, module_name: str, module_prefix: str, module: ModuleIR
+    ) -> None:
+        """Emit the module exec function.
+
+        If we are compiling just one module, this will be the normal C API
+        exec function. If we are compiling 2+ modules, we generate a shared
+        library for the modules and shims that call into the shared
+        library, and in this case the shared module defines an internal
+        exec function for each module and these will be called by the shims
+        via Capsules.
+        """
+        exec_name = f"CPyExec_{exported_name(module_name)}"
+        declaration = f"int {exec_name}(PyObject *module)"
+        emitter.context.declarations[exec_name] = HeaderDeclaration(declaration + ";")
+        module_static = self.module_internal_static_name(module_name, emitter)
+        emitter.emit_lines(declaration, "{")
+        emitter.emit_line("intern_strings();")
+        if self.compiler_options.depends_on_librt_internal:
+            emitter.emit_line("if (import_librt_internal() < 0) {")
+            emitter.emit_line("return -1;")
+            emitter.emit_line("}")
+        if LIBRT_BASE64 in module.dependencies:
+            emitter.emit_line("if (import_librt_base64() < 0) {")
+            emitter.emit_line("return -1;")
+            emitter.emit_line("}")
+        if LIBRT_STRINGS in module.dependencies:
+            emitter.emit_line("if (import_librt_strings() < 0) {")
+            emitter.emit_line("return -1;")
+            emitter.emit_line("}")
+        if LIBRT_TIME in module.dependencies:
+            emitter.emit_line("if (import_librt_time() < 0) {")
+            emitter.emit_line("return -1;")
+            emitter.emit_line("}")
+        if LIBRT_VECS in module.dependencies:
+            emitter.emit_line("if (import_librt_vecs() < 0) {")
+            emitter.emit_line("return -1;")
+            emitter.emit_line("}")
+        emitter.emit_line("PyObject* modname = NULL;")
+        if self.multi_phase_init:
+            emitter.emit_line(f"{module_static} = module;")
+        emitter.emit_line(
+            f'modname = PyObject_GetAttrString((PyObject *){module_static}, "__name__");'
+        )
+
+        module_globals = emitter.static_name("globals", module_name)
+        emitter.emit_lines(
+            f"{module_globals} = PyModule_GetDict({module_static});",
+            f"if (unlikely({module_globals} == NULL))",
+            "    goto fail;",
+        )
+
+        if self.multi_phase_init:
+            emitter.emit_lines(
+                f"if (PyModule_AddFunctions(module, {module_prefix}module_methods) < 0)",
+                "    goto fail;",
+            )
+
+        self.emit_coroutine_wrappers(emitter, module, module_globals)
+
+        # HACK: Manually instantiate generated classes here
+        type_structs: list[str] = []
+        for cl in module.classes:
+            type_struct = emitter.type_struct_name(cl)
+            type_structs.append(type_struct)
+            if cl.is_generated:
+                error_stmt = "    goto fail;"
+                emitter.emit_lines(
+                    "{t} = (PyTypeObject *)CPyType_FromTemplate("
+                    "(PyObject *){t}_template, NULL, modname);".format(t=type_struct)
+                )
+                emitter.emit_lines(f"if (unlikely(!{type_struct}))", error_stmt)
+                name_prefix = cl.name_prefix(emitter.names)
+                emitter.emit_line(f"CPyDef_{name_prefix}_trait_vtable_setup();")
+
+        emitter.emit_lines("if (CPyGlobalsInit() < 0)", "    goto fail;")
+
+        self.generate_top_level_call(module, emitter)
+
+        emitter.emit_lines("Py_DECREF(modname);")
+
+        emitter.emit_line("return 0;")
+        emitter.emit_lines("fail:")
+        if self.multi_phase_init:
+            emitter.emit_lines(f"{module_static} = NULL;", "Py_CLEAR(modname);")
+        else:
+            emitter.emit_lines(f"Py_CLEAR({module_static});", "Py_CLEAR(modname);")
+        for name, typ in module.final_names:
+            static_name = emitter.static_name(name, module_name)
+            emitter.emit_dec_ref(static_name, typ, is_xdec=True)
+            undef = emitter.c_undefined_value(typ)
+            emitter.emit_line(f"{static_name} = {undef};")
+        # the type objects returned from CPyType_FromTemplate are all new references
+        # so we have to decref them
+        for t in type_structs:
+            emitter.emit_line(f"Py_CLEAR({t});")
+        emitter.emit_line("return -1;")
+        emitter.emit_line("}")
+
+    def emit_init_only_func(self, emitter: Emitter, module_name: str, module_prefix: str) -> None:
+        """Emit CPyInitOnly_* which creates the module object without executing the body.
+
+        This allows the caller to set up attributes like __file__ and __package__
+        before the module body runs. Used for same-group native imports.
+        """
+        init_only_name = f"CPyInitOnly_{exported_name(module_name)}"
+        init_only_decl = f"PyObject *{init_only_name}(void)"
+        emitter.context.declarations[init_only_name] = HeaderDeclaration(init_only_decl + ";")
+        module_static = self.module_internal_static_name(module_name, emitter)
+        emitter.emit_lines(init_only_decl, "{")
+        emitter.emit_lines(
+            f"if ({module_static}) {{",
+            f"Py_INCREF({module_static});",
+            f"return {module_static};",
+            "}",
+        )
+        emitter.emit_lines(
+            f"{module_static} = PyModule_Create(&{module_prefix}module);",
+            f"return {module_static};",
+        )
+        emitter.emit_lines("}")
+        emitter.emit_line("")
+
+    def emit_module_init_func(
+        self, emitter: Emitter, module_name: str, module_prefix: str
+    ) -> None:
+        if not self.use_shared_lib:
+            declaration = f"PyMODINIT_FUNC PyInit_{module_name}(void)"
+        else:
+            n = f"CPyInit_{exported_name(module_name)}"
+            declaration = f"PyObject *{n}(void)"
+            emitter.context.declarations[n] = HeaderDeclaration(declaration + ";")
+
+        if self.multi_phase_init:
+            emitter.emit_lines(declaration, "{")
+            def_name = f"{module_prefix}module"
+            emitter.emit_line(f"return PyModuleDef_Init(&{def_name});")
+            emitter.emit_line("}")
+            return
+
+        exec_func = f"CPyExec_{exported_name(module_name)}"
+
+        if self.use_shared_lib:
+            self.emit_init_only_func(emitter, module_name, module_prefix)
+
+        # Emit CPyInit_* / PyInit_* which creates the module and executes the body.
+        emitter.emit_lines(declaration, "{")
+        module_static = self.module_internal_static_name(module_name, emitter)
+
+        emitter.emit_line("PyObject* modname = NULL;")
+        emitter.emit_lines(
+            f"if ({module_static}) {{",
+            f"Py_INCREF({module_static});",
+            f"return {module_static};",
+            "}",
+        )
+
+        emitter.emit_lines(
+            f"{module_static} = PyModule_Create(&{module_prefix}module);",
+            f"if (unlikely({module_static} == NULL))",
+            "    goto fail;",
+        )
+
+        emitter.emit_line(f'modname = PyUnicode_FromString("{module_name}");')
+        emitter.emit_line("if (modname == NULL) CPyError_OutOfMemory();")
+        emitter.emit_line("int rv = 0;")
+        if self.group_name:
+            shared_lib_mod_name = shared_lib_name(self.group_name)
+            emitter.emit_line("PyObject *mod_dict = PyImport_GetModuleDict();")
+            emitter.emit_line("PyObject *shared_lib = NULL;")
+            emitter.emit_line(
+                f'rv = PyDict_GetItemStringRef(mod_dict, "{shared_lib_mod_name}", &shared_lib);'
+            )
+            emitter.emit_line("if (rv < 0) goto fail;")
+            emitter.emit_line(
+                'PyObject *shared_lib_file = PyObject_GetAttrString(shared_lib, "__file__");'
+            )
+            emitter.emit_line("if (shared_lib_file == NULL) goto fail;")
+        else:
+            emitter.emit_line(
+                f'PyObject *shared_lib_file = PyUnicode_FromString("{module_name + EXT_SUFFIX}");'
+            )
+            emitter.emit_line("if (shared_lib_file == NULL) CPyError_OutOfMemory();")
+        emitter.emit_line(f'PyObject *ext_suffix = PyUnicode_FromString("{EXT_SUFFIX}");')
+        emitter.emit_line("if (ext_suffix == NULL) CPyError_OutOfMemory();")
+        is_pkg = int(self.source_paths[module_name].endswith("__init__.py"))
+        emitter.emit_line(f"Py_ssize_t is_pkg = {is_pkg};")
+
+        emitter.emit_line(
+            f"rv = CPyImport_SetDunderAttrs({module_static}, modname, shared_lib_file, ext_suffix, is_pkg);"
+        )
+        emitter.emit_line("Py_DECREF(ext_suffix);")
+        emitter.emit_line("Py_DECREF(shared_lib_file);")
+        emitter.emit_line("if (rv < 0) goto fail;")
+
+        # Register in sys.modules early so that circular imports via
+        # CPyImport_ImportNative can detect that this module is already
+        # being initialized and avoid re-executing the module body.
+        emitter.emit_line(
+            f"if (PyObject_SetItem(PyImport_GetModuleDict(), modname, {module_static}) < 0)"
+        )
+        emitter.emit_line("    goto fail;")
+        emitter.emit_line("Py_CLEAR(modname);")
+        emitter.emit_lines(f"if ({exec_func}({module_static}) != 0)", "    goto fail;")
+        emitter.emit_line(f"return {module_static};")
+        emitter.emit_lines("fail:")
+        # Clean up on failure: remove from sys.modules and clear the static
+        # so that a subsequent import attempt will retry initialization.
+        emitter.emit_line("{")
+        emitter.emit_line("    PyObject *exc_type, *exc_val, *exc_tb;")
+        emitter.emit_line("    PyErr_Fetch(&exc_type, &exc_val, &exc_tb);")
+        emitter.emit_line("    if (modname == NULL) {")
+        emitter.emit_line(f'        modname = PyUnicode_FromString("{module_name}");')
+        emitter.emit_line("        if (modname == NULL) CPyError_OutOfMemory();")
+        emitter.emit_line("    }")
+        emitter.emit_line("    PyObject_DelItem(PyImport_GetModuleDict(), modname);")
+        emitter.emit_line("    PyErr_Clear();")
+        emitter.emit_line("    Py_DECREF(modname);")
+        emitter.emit_line(f"    Py_CLEAR({module_static});")
+        emitter.emit_line("    PyErr_Restore(exc_type, exc_val, exc_tb);")
+        emitter.emit_line("}")
+        emitter.emit_line("return NULL;")
+        emitter.emit_lines("}")
+
+    def generate_top_level_call(self, module: ModuleIR, emitter: Emitter) -> None:
+        """Generate call to function representing module top level."""
+        # Optimization: we tend to put the top level last, so reverse iterate
+        for fn in reversed(module.functions):
+            if fn.name == TOP_LEVEL_NAME:
+                emitter.emit_lines(
+                    f"char result = {emitter.native_function_name(fn.decl)}();",
+                    "if (result == 2)",
+                    "    goto fail;",
+                )
+                break
+
+    def toposort_declarations(self) -> list[HeaderDeclaration]:
+        """Topologically sort the declaration dict by dependencies.
+
+        Declarations can require other declarations to come prior in C (such as declaring structs).
+        In order to guarantee that the C output will compile the declarations will thus need to
+        be properly ordered. This simple DFS guarantees that we have a proper ordering.
+
+        This runs in O(V + E).
+        """
+        result = []
+        marked_declarations: dict[str, MarkedDeclaration] = {}
+        for k, v in self.context.declarations.items():
+            marked_declarations[k] = MarkedDeclaration(v, False)
+
+        def _toposort_visit(name: str) -> None:
+            decl = marked_declarations[name]
+            if decl.mark:
+                return
+
+            for child in decl.declaration.dependencies:
+                _toposort_visit(child)
+
+            result.append(decl.declaration)
+            decl.mark = True
+
+        for name in marked_declarations:
+            _toposort_visit(name)
+
+        return result
+
+    def declare_global(
+        self, type_spaced: str, name: str, *, initializer: str | None = None
+    ) -> None:
+        if "[" not in type_spaced:
+            base = f"{type_spaced}{name}"
+        else:
+            a, b = type_spaced.split("[", 1)
+            base = f"{a}{name}[{b}"
+
+        if not initializer:
+            defn = None
+        else:
+            defn = [f"{base} = {initializer};"]
+        if name not in self.context.declarations:
+            self.context.declarations[name] = HeaderDeclaration(f"{base};", defn=defn)
+
+    def declare_internal_globals(self, module_name: str, emitter: Emitter) -> None:
+        static_name = emitter.static_name("globals", module_name)
+        if static_name not in self.context.declarations:
+            self.context.declarations[static_name] = HeaderDeclaration(
+                f"PyObject *{static_name};", needs_export=True
+            )
+
+    def module_internal_static_name(self, module_name: str, emitter: Emitter) -> str:
+        return emitter.static_name(module_name + "__internal", None, prefix=MODULE_PREFIX)
+
+    def declare_module(self, module_name: str, emitter: Emitter) -> None:
+        # We declare two globals for each compiled module:
+        # one used internally in the implementation of module init to cache results
+        # and prevent infinite recursion in import cycles, and one used
+        # by other modules to refer to it.
+        if module_name in self.modules:
+            internal_static_name = self.module_internal_static_name(module_name, emitter)
+            self.declare_global("CPyModule *", internal_static_name, initializer="NULL")
+        static_name = emitter.static_name(module_name, None, prefix=MODULE_PREFIX)
+        self.declare_global("CPyModule *", static_name)
+        self.simple_inits.append((static_name, "Py_None"))
+
+    def declare_imports(self, imps: Iterable[str], emitter: Emitter) -> None:
+        for imp in imps:
+            self.declare_module(imp, emitter)
+
+    def declare_finals(
+        self, module: str, final_names: Iterable[tuple[str, RType]], emitter: Emitter
+    ) -> None:
+        for name, typ in final_names:
+            static_name = emitter.static_name(name, module)
+            emitter.context.declarations[static_name] = HeaderDeclaration(
+                f"{emitter.ctype_spaced(typ)}{static_name};",
+                [self.final_definition(module, name, typ, emitter)],
+                needs_export=True,
+            )
+
+    def final_definition(self, module: str, name: str, typ: RType, emitter: Emitter) -> str:
+        static_name = emitter.static_name(name, module)
+        # Here we rely on the fact that undefined value and error value are always the same
+        undefined = emitter.c_initializer_undefined_value(typ)
+        return f"{emitter.ctype_spaced(typ)}{static_name} = {undefined};"
+
+    def declare_static_pyobject(self, identifier: str, emitter: Emitter) -> None:
+        symbol = emitter.static_name(identifier, None)
+        self.declare_global("PyObject *", symbol)
+
+    def declare_type_vars(self, module: str, type_var_names: list[str], emitter: Emitter) -> None:
+        for name in type_var_names:
+            static_name = emitter.static_name(name, module, prefix=TYPE_VAR_PREFIX)
+            emitter.context.declarations[static_name] = HeaderDeclaration(
+                f"PyObject *{static_name};",
+                [f"PyObject *{static_name} = NULL;"],
+                needs_export=False,
+            )
+
+
+T = TypeVar("T")
+
+
+def toposort(deps: dict[T, set[T]]) -> list[T]:
+    """Topologically sort a dict from item to dependencies.
+
+    This runs in O(V + E).
+    """
+    result = []
+    visited: set[T] = set()
+
+    def visit(item: T) -> None:
+        if item in visited:
+            return
+
+        for child in deps[item]:
+            visit(child)
+
+        result.append(item)
+        visited.add(item)
+
+    for item in deps:
+        visit(item)
+
+    return result
+
+
+def is_fastcall_supported(fn: FuncIR, capi_version: tuple[int, int]) -> bool:
+    if fn.class_name is not None:
+        if fn.name == "__call__":
+            # We can use vectorcalls (PEP 590) when supported
+            return True
+        # TODO: Support fastcall for __init__ and __new__.
+        return fn.name != "__init__" and fn.name != "__new__"
+    return True
+
+
+def collect_literals(fn: FuncIR, literals: Literals) -> None:
+    """Store all Python literal object refs in fn.
+
+    Collecting literals must happen only after we have the final IR.
+    This way we won't include literals that have been optimized away.
+    """
+    for block in fn.blocks:
+        for op in block.ops:
+            if isinstance(op, LoadLiteral):
+                literals.record_literal(op.value)
+
+
+def c_string_array_initializer(components: list[bytes]) -> str:
+    result = []
+    result.append("{\n")
+    for s in components:
+        result.append("    " + c_string_initializer(s) + ",\n")
+    result.append("}")
+    return "".join(result)

micromamba_root/Lib/site-packages/mypyc/codegen/emitwrapper.py

@@ -0,0 +1,978 @@
+"""Generate CPython API wrapper functions for native functions.
+
+The wrapper functions are used by the CPython runtime when calling
+native functions from interpreted code, and when the called function
+can't be determined statically in compiled code. They validate, match,
+unbox and type check function arguments, and box return values as
+needed. All wrappers accept and return 'PyObject *' (boxed) values.
+
+The wrappers aren't used for most calls between two native functions
+or methods in a single compilation unit.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from mypy.nodes import ARG_NAMED, ARG_NAMED_OPT, ARG_OPT, ARG_POS, ARG_STAR, ARG_STAR2, ArgKind
+from mypy.operators import op_methods_to_symbols, reverse_op_method_names, reverse_op_methods
+from mypyc.codegen.emit import AssignHandler, Emitter, ErrorHandler, GotoHandler, ReturnHandler
+from mypyc.common import (
+    BITMAP_BITS,
+    BITMAP_TYPE,
+    DUNDER_PREFIX,
+    NATIVE_PREFIX,
+    PREFIX,
+    bitmap_name,
+)
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.func_ir import FUNC_STATICMETHOD, FuncIR, RuntimeArg
+from mypyc.ir.rtypes import (
+    RInstance,
+    RType,
+    is_bool_rprimitive,
+    is_int_rprimitive,
+    is_object_rprimitive,
+    object_rprimitive,
+)
+from mypyc.namegen import NameGenerator
+
+# Generic vectorcall wrapper functions (Python 3.7+)
+#
+# A wrapper function has a signature like this:
+#
+# PyObject *fn(PyObject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+#
+# The function takes a self object, pointer to an array of arguments,
+# the number of positional arguments, and a tuple of keyword argument
+# names (that are stored starting in args[nargs]).
+#
+# It returns the returned object, or NULL on an exception.
+#
+# These are more efficient than legacy wrapper functions, since
+# usually no tuple or dict objects need to be created for the
+# arguments. Vectorcalls also use pre-constructed str objects for
+# keyword argument names and other pre-computed information, instead
+# of processing the argument format string on each call.
+
+
+def wrapper_function_header(fn: FuncIR, names: NameGenerator) -> str:
+    """Return header of a vectorcall wrapper function.
+
+    See comment above for a summary of the arguments.
+    """
+    assert not fn.internal
+    return (
+        "PyObject *{prefix}{name}("
+        "PyObject *self, PyObject *const *args, size_t nargs, PyObject *kwnames)"
+    ).format(prefix=PREFIX, name=fn.cname(names))
+
+
+def generate_traceback_code(
+    fn: FuncIR, emitter: Emitter, source_path: str, module_name: str
+) -> str:
+    # If we hit an error while processing arguments, then we emit a
+    # traceback frame to make it possible to debug where it happened.
+    # Unlike traceback frames added for exceptions seen in IR, we do this
+    # even if there is no `traceback_name`. This is because the error will
+    # have originated here and so we need it in the traceback.
+    globals_static = emitter.static_name("globals", module_name)
+    traceback_code = 'CPy_AddTraceback("%s", "%s", %d, %s);' % (
+        source_path.replace("\\", "\\\\"),
+        fn.traceback_name or fn.name,
+        fn.line,
+        globals_static,
+    )
+    return traceback_code
+
+
+def make_arg_groups(args: list[RuntimeArg]) -> dict[ArgKind, list[RuntimeArg]]:
+    """Group arguments by kind."""
+    return {k: [arg for arg in args if arg.kind == k] for k in ArgKind}
+
+
+def reorder_arg_groups(groups: dict[ArgKind, list[RuntimeArg]]) -> list[RuntimeArg]:
+    """Reorder argument groups to match their order in a format string."""
+    return groups[ARG_POS] + groups[ARG_OPT] + groups[ARG_NAMED_OPT] + groups[ARG_NAMED]
+
+
+def make_static_kwlist(args: list[RuntimeArg]) -> str:
+    arg_names = "".join(f'"{arg.name}", ' for arg in args)
+    return f"static const char * const kwlist[] = {{{arg_names}0}};"
+
+
+def make_format_string(func_name: str | None, groups: dict[ArgKind, list[RuntimeArg]]) -> str:
+    """Return a format string that specifies the accepted arguments.
+
+    The format string is an extended subset of what is supported by
+    PyArg_ParseTupleAndKeywords(). Only the type 'O' is used, and we
+    also support some extensions:
+
+    - Required keyword-only arguments are introduced after '@'
+    - If the function receives *args or **kwargs, we add a '%' prefix
+
+    Each group requires the previous groups' delimiters to be present
+    first.
+
+    These are used by both vectorcall and legacy wrapper functions.
+    """
+    format = ""
+    if groups[ARG_STAR] or groups[ARG_STAR2]:
+        format += "%"
+    format += "O" * len(groups[ARG_POS])
+    if groups[ARG_OPT] or groups[ARG_NAMED_OPT] or groups[ARG_NAMED]:
+        format += "|" + "O" * len(groups[ARG_OPT])
+    if groups[ARG_NAMED_OPT] or groups[ARG_NAMED]:
+        format += "$" + "O" * len(groups[ARG_NAMED_OPT])
+    if groups[ARG_NAMED]:
+        format += "@" + "O" * len(groups[ARG_NAMED])
+    if func_name is not None:
+        format += f":{func_name}"
+    return format
+
+
+def generate_wrapper_function(
+    fn: FuncIR, emitter: Emitter, source_path: str, module_name: str
+) -> None:
+    """Generate a CPython-compatible vectorcall wrapper for a native function.
+
+    In particular, this handles unboxing the arguments, calling the native function, and
+    then boxing the return value.
+    """
+    emitter.emit_line(f"{wrapper_function_header(fn, emitter.names)} {{")
+
+    # If fn is a method, then the first argument is a self param
+    real_args = list(fn.args)
+    if fn.sig.num_bitmap_args:
+        real_args = real_args[: -fn.sig.num_bitmap_args]
+    if fn.class_name and fn.decl.kind != FUNC_STATICMETHOD:
+        arg = real_args.pop(0)
+        emitter.emit_line(f"PyObject *obj_{arg.name} = self;")
+
+    # Need to order args as: required, optional, kwonly optional, kwonly required
+    # This is because CPyArg_ParseStackAndKeywords format string requires
+    # them grouped in that way.
+    groups = make_arg_groups(real_args)
+    reordered_args = reorder_arg_groups(groups)
+
+    emitter.emit_line(make_static_kwlist(reordered_args))
+    fmt = make_format_string(fn.name, groups)
+    # Define the arguments the function accepts (but no types yet)
+    emitter.emit_line(f'static CPyArg_Parser parser = {{"{fmt}", kwlist, 0}};')
+
+    for arg in real_args:
+        emitter.emit_line(
+            "PyObject *obj_{}{};".format(arg.name, " = NULL" if arg.optional else "")
+        )
+
+    cleanups = [f"CPy_DECREF(obj_{arg.name});" for arg in groups[ARG_STAR] + groups[ARG_STAR2]]
+
+    arg_ptrs: list[str] = []
+    if groups[ARG_STAR] or groups[ARG_STAR2]:
+        arg_ptrs += [f"&obj_{groups[ARG_STAR][0].name}" if groups[ARG_STAR] else "NULL"]
+        arg_ptrs += [f"&obj_{groups[ARG_STAR2][0].name}" if groups[ARG_STAR2] else "NULL"]
+    arg_ptrs += [f"&obj_{arg.name}" for arg in reordered_args]
+
+    if fn.name == "__call__":
+        nargs = "PyVectorcall_NARGS(nargs)"
+    else:
+        nargs = "nargs"
+    parse_fn = "CPyArg_ParseStackAndKeywords"
+    # Special case some common signatures
+    if not real_args:
+        # No args
+        parse_fn = "CPyArg_ParseStackAndKeywordsNoArgs"
+    elif len(real_args) == 1 and len(groups[ARG_POS]) == 1:
+        # Single positional arg
+        parse_fn = "CPyArg_ParseStackAndKeywordsOneArg"
+    elif len(real_args) == len(groups[ARG_POS]) + len(groups[ARG_OPT]):
+        # No keyword-only args, *args or **kwargs
+        parse_fn = "CPyArg_ParseStackAndKeywordsSimple"
+    emitter.emit_lines(
+        "if (!{}(args, {}, kwnames, &parser{})) {{".format(
+            parse_fn, nargs, "".join(", " + n for n in arg_ptrs)
+        ),
+        "return NULL;",
+        "}",
+    )
+    for i in range(fn.sig.num_bitmap_args):
+        name = bitmap_name(i)
+        emitter.emit_line(f"{BITMAP_TYPE} {name} = 0;")
+    traceback_code = generate_traceback_code(fn, emitter, source_path, module_name)
+    generate_wrapper_core(
+        fn,
+        emitter,
+        groups[ARG_OPT] + groups[ARG_NAMED_OPT],
+        cleanups=cleanups,
+        traceback_code=traceback_code,
+    )
+
+    emitter.emit_line("}")
+
+
+# Legacy generic wrapper functions
+#
+# These take a self object, a Python tuple of positional arguments,
+# and a dict of keyword arguments. These are a lot slower than
+# vectorcall wrappers, especially in calls involving keyword
+# arguments.
+
+
+def legacy_wrapper_function_header(fn: FuncIR, names: NameGenerator) -> str:
+    return "PyObject *{prefix}{name}(PyObject *self, PyObject *args, PyObject *kw)".format(
+        prefix=PREFIX, name=fn.cname(names)
+    )
+
+
+def generate_legacy_wrapper_function(
+    fn: FuncIR, emitter: Emitter, source_path: str, module_name: str
+) -> None:
+    """Generates a CPython-compatible legacy wrapper for a native function.
+
+    In particular, this handles unboxing the arguments, calling the native function, and
+    then boxing the return value.
+    """
+    emitter.emit_line(f"{legacy_wrapper_function_header(fn, emitter.names)} {{")
+
+    # If fn is a method, then the first argument is a self param
+    real_args = list(fn.args)
+    if fn.sig.num_bitmap_args:
+        real_args = real_args[: -fn.sig.num_bitmap_args]
+    if fn.class_name and (fn.decl.name == "__new__" or fn.decl.kind != FUNC_STATICMETHOD):
+        arg = real_args.pop(0)
+        emitter.emit_line(f"PyObject *obj_{arg.name} = self;")
+
+    # Need to order args as: required, optional, kwonly optional, kwonly required
+    # This is because CPyArg_ParseTupleAndKeywords format string requires
+    # them grouped in that way.
+    groups = make_arg_groups(real_args)
+    reordered_args = reorder_arg_groups(groups)
+
+    emitter.emit_line(make_static_kwlist(reordered_args))
+    for arg in real_args:
+        emitter.emit_line(
+            "PyObject *obj_{}{};".format(arg.name, " = NULL" if arg.optional else "")
+        )
+
+    cleanups = [f"CPy_DECREF(obj_{arg.name});" for arg in groups[ARG_STAR] + groups[ARG_STAR2]]
+
+    arg_ptrs: list[str] = []
+    if groups[ARG_STAR] or groups[ARG_STAR2]:
+        arg_ptrs += [f"&obj_{groups[ARG_STAR][0].name}" if groups[ARG_STAR] else "NULL"]
+        arg_ptrs += [f"&obj_{groups[ARG_STAR2][0].name}" if groups[ARG_STAR2] else "NULL"]
+    arg_ptrs += [f"&obj_{arg.name}" for arg in reordered_args]
+
+    emitter.emit_lines(
+        'if (!CPyArg_ParseTupleAndKeywords(args, kw, "{}", "{}", kwlist{})) {{'.format(
+            make_format_string(None, groups), fn.name, "".join(", " + n for n in arg_ptrs)
+        ),
+        "return NULL;",
+        "}",
+    )
+    for i in range(fn.sig.num_bitmap_args):
+        name = bitmap_name(i)
+        emitter.emit_line(f"{BITMAP_TYPE} {name} = 0;")
+    traceback_code = generate_traceback_code(fn, emitter, source_path, module_name)
+    generate_wrapper_core(
+        fn,
+        emitter,
+        groups[ARG_OPT] + groups[ARG_NAMED_OPT],
+        cleanups=cleanups,
+        traceback_code=traceback_code,
+    )
+
+    emitter.emit_line("}")
+
+
+# Specialized wrapper functions
+
+
+def generate_dunder_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generates a wrapper for native __dunder__ methods to be able to fit into the mapping
+    protocol slot. This specifically means that the arguments are taken as *PyObjects and returned
+    as *PyObjects.
+    """
+    gen = WrapperGenerator(cl, emitter)
+    gen.set_target(fn)
+    gen.emit_header()
+    gen.emit_arg_processing()
+    gen.emit_call()
+    gen.finish()
+    return gen.wrapper_name()
+
+
+def generate_ipow_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generate a wrapper for native __ipow__.
+
+    Since __ipow__ fills a ternary slot, but almost no one defines __ipow__ to take three
+    arguments, the wrapper needs to tweaked to force it to accept three arguments.
+    """
+    gen = WrapperGenerator(cl, emitter)
+    gen.set_target(fn)
+    assert len(fn.args) in (2, 3), "__ipow__ should only take 2 or 3 arguments"
+    gen.arg_names = ["self", "exp", "mod"]
+    gen.emit_header()
+    gen.emit_arg_processing()
+    handle_third_pow_argument(
+        fn,
+        emitter,
+        gen,
+        if_unsupported=[
+            'PyErr_SetString(PyExc_TypeError, "__ipow__ takes 2 positional arguments but 3 were given");',
+            "return NULL;",
+        ],
+    )
+    gen.emit_call()
+    gen.finish()
+    return gen.wrapper_name()
+
+
+def generate_bin_op_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generates a wrapper for a native binary dunder method.
+
+    The same wrapper that handles the forward method (e.g. __add__) also handles
+    the corresponding reverse method (e.g. __radd__), if defined.
+
+    Both arguments and the return value are PyObject *.
+    """
+    gen = WrapperGenerator(cl, emitter)
+    gen.set_target(fn)
+    if fn.name in ("__pow__", "__rpow__"):
+        gen.arg_names = ["left", "right", "mod"]
+    else:
+        gen.arg_names = ["left", "right"]
+    wrapper_name = gen.wrapper_name()
+
+    gen.emit_header()
+    if fn.name not in reverse_op_methods and fn.name in reverse_op_method_names:
+        # There's only a reverse operator method.
+        generate_bin_op_reverse_only_wrapper(fn, emitter, gen)
+    else:
+        rmethod = reverse_op_methods[fn.name]
+        fn_rev = cl.get_method(rmethod)
+        if fn_rev is None:
+            # There's only a forward operator method.
+            generate_bin_op_forward_only_wrapper(fn, emitter, gen)
+        else:
+            # There's both a forward and a reverse operator method.
+            generate_bin_op_both_wrappers(cl, fn, fn_rev, emitter, gen)
+    return wrapper_name
+
+
+def generate_bin_op_forward_only_wrapper(
+    fn: FuncIR, emitter: Emitter, gen: WrapperGenerator
+) -> None:
+    gen.emit_arg_processing(error=GotoHandler("typefail"), raise_exception=False)
+    handle_third_pow_argument(fn, emitter, gen, if_unsupported=["goto typefail;"])
+    gen.emit_call(not_implemented_handler="goto typefail;")
+    gen.emit_error_handling()
+    emitter.emit_label("typefail")
+    # If some argument has an incompatible type, treat this the same as
+    # returning NotImplemented, and try to call the reverse operator method.
+    #
+    # Note that in normal Python you'd instead of an explicit
+    # return of NotImplemented, but it doesn't generally work here
+    # the body won't be executed at all if there is an argument
+    # type check failure.
+    #
+    # The recommended way is to still use a type check in the
+    # body. This will only be used in interpreted mode:
+    #
+    #    def __add__(self, other: int) -> Foo:
+    #        if not isinstance(other, int):
+    #            return NotImplemented
+    #        ...
+    generate_bin_op_reverse_dunder_call(fn, emitter, reverse_op_methods[fn.name])
+    gen.finish()
+
+
+def generate_bin_op_reverse_only_wrapper(
+    fn: FuncIR, emitter: Emitter, gen: WrapperGenerator
+) -> None:
+    gen.arg_names = ["right", "left"]
+    gen.emit_arg_processing(error=GotoHandler("typefail"), raise_exception=False)
+    handle_third_pow_argument(fn, emitter, gen, if_unsupported=["goto typefail;"])
+    gen.emit_call()
+    gen.emit_error_handling()
+    emitter.emit_label("typefail")
+    emitter.emit_line("Py_INCREF(Py_NotImplemented);")
+    emitter.emit_line("return Py_NotImplemented;")
+    gen.finish()
+
+
+def generate_bin_op_both_wrappers(
+    cl: ClassIR, fn: FuncIR, fn_rev: FuncIR, emitter: Emitter, gen: WrapperGenerator
+) -> None:
+    # There's both a forward and a reverse operator method. First
+    # check if we should try calling the forward one. If the
+    # argument type check fails, fall back to the reverse method.
+    #
+    # Similar to above, we can't perfectly match Python semantics.
+    # In regular Python code you'd return NotImplemented if the
+    # operand has the wrong type, but in compiled code we'll never
+    # get to execute the type check.
+    emitter.emit_line(
+        "if (PyObject_IsInstance(obj_left, (PyObject *){})) {{".format(
+            emitter.type_struct_name(cl)
+        )
+    )
+    gen.emit_arg_processing(error=GotoHandler("typefail"), raise_exception=False)
+    handle_third_pow_argument(fn, emitter, gen, if_unsupported=["goto typefail2;"])
+    # Ternary __rpow__ calls aren't a thing so immediately bail
+    # if ternary __pow__ returns NotImplemented.
+    if fn.name == "__pow__" and len(fn.args) == 3:
+        fwd_not_implemented_handler = "goto typefail2;"
+    else:
+        fwd_not_implemented_handler = "goto typefail;"
+    gen.emit_call(not_implemented_handler=fwd_not_implemented_handler)
+    gen.emit_error_handling()
+    emitter.emit_line("}")
+    emitter.emit_label("typefail")
+    emitter.emit_line(
+        "if (PyObject_IsInstance(obj_right, (PyObject *){})) {{".format(
+            emitter.type_struct_name(cl)
+        )
+    )
+    gen.set_target(fn_rev)
+    gen.arg_names = ["right", "left"]
+    gen.emit_arg_processing(error=GotoHandler("typefail2"), raise_exception=False)
+    handle_third_pow_argument(fn_rev, emitter, gen, if_unsupported=["goto typefail2;"])
+    gen.emit_call()
+    gen.emit_error_handling()
+    emitter.emit_line("} else {")
+    generate_bin_op_reverse_dunder_call(fn, emitter, fn_rev.name)
+    emitter.emit_line("}")
+    emitter.emit_label("typefail2")
+    emitter.emit_line("Py_INCREF(Py_NotImplemented);")
+    emitter.emit_line("return Py_NotImplemented;")
+    gen.finish()
+
+
+def generate_bin_op_reverse_dunder_call(fn: FuncIR, emitter: Emitter, rmethod: str) -> None:
+    if fn.name in ("__pow__", "__rpow__"):
+        # Ternary pow() will never call the reverse dunder.
+        emitter.emit_line("if (obj_mod == Py_None) {")
+    emitter.emit_line(
+        'return CPy_CallReverseOpMethod(obj_left, obj_right, "{}", mypyc_interned_str.{});'.format(
+            op_methods_to_symbols[fn.name], rmethod
+        )
+    )
+    if fn.name in ("__pow__", "__rpow__"):
+        emitter.emit_line("} else {")
+        emitter.emit_line("Py_INCREF(Py_NotImplemented);")
+        emitter.emit_line("return Py_NotImplemented;")
+        emitter.emit_line("}")
+
+
+def handle_third_pow_argument(
+    fn: FuncIR, emitter: Emitter, gen: WrapperGenerator, *, if_unsupported: list[str]
+) -> None:
+    if fn.name not in ("__pow__", "__rpow__", "__ipow__"):
+        return
+
+    if (fn.name in ("__pow__", "__ipow__") and len(fn.args) == 2) or fn.name == "__rpow__":
+        # If the power dunder only supports two arguments and the third
+        # argument (AKA mod) is set to a non-default value, simply bail.
+        #
+        # Importantly, this prevents any ternary __rpow__ calls from
+        # happening (as per the language specification).
+        emitter.emit_line("if (obj_mod != Py_None) {")
+        for line in if_unsupported:
+            emitter.emit_line(line)
+        emitter.emit_line("}")
+        # The slot wrapper will receive three arguments, but the call only
+        # supports two so make sure that the third argument isn't passed
+        # along. This is needed as two-argument __(i)pow__ is allowed and
+        # rather common.
+        if len(gen.arg_names) == 3:
+            gen.arg_names.pop()
+
+
+RICHCOMPARE_OPS = {
+    "__lt__": "Py_LT",
+    "__gt__": "Py_GT",
+    "__le__": "Py_LE",
+    "__ge__": "Py_GE",
+    "__eq__": "Py_EQ",
+    "__ne__": "Py_NE",
+}
+
+
+def generate_richcompare_wrapper(cl: ClassIR, emitter: Emitter) -> str | None:
+    """Generates a wrapper for richcompare dunder methods."""
+    # Sort for determinism on Python 3.5
+    matches = sorted(name for name in RICHCOMPARE_OPS if cl.has_method(name))
+    if not matches:
+        return None
+
+    name = f"{DUNDER_PREFIX}_RichCompare_{cl.name_prefix(emitter.names)}"
+    emitter.emit_line(
+        "static PyObject *{name}(PyObject *obj_lhs, PyObject *obj_rhs, int op) {{".format(
+            name=name
+        )
+    )
+    emitter.emit_line("switch (op) {")
+    for func in matches:
+        emitter.emit_line(f"case {RICHCOMPARE_OPS[func]}: {{")
+        method = cl.get_method(func)
+        assert method is not None
+        generate_wrapper_core(method, emitter, arg_names=["lhs", "rhs"])
+        emitter.emit_line("}")
+    emitter.emit_line("}")
+
+    emitter.emit_line("Py_INCREF(Py_NotImplemented);")
+    emitter.emit_line("return Py_NotImplemented;")
+
+    emitter.emit_line("}")
+
+    return name
+
+
+def generate_get_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generates a wrapper for native __get__ methods."""
+    name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"
+    emitter.emit_line(
+        "static PyObject *{name}(PyObject *self, PyObject *instance, PyObject *owner) {{".format(
+            name=name
+        )
+    )
+    emitter.emit_line("instance = instance ? instance : Py_None;")
+    emitter.emit_line(f"return {NATIVE_PREFIX}{fn.cname(emitter.names)}(self, instance, owner);")
+    emitter.emit_line("}")
+
+    return name
+
+
+def generate_hash_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generates a wrapper for native __hash__ methods."""
+    name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"
+    emitter.emit_line(f"static Py_ssize_t {name}(PyObject *self) {{")
+    emitter.emit_line(
+        "{}retval = {}{}{}(self);".format(
+            emitter.ctype_spaced(fn.ret_type),
+            emitter.get_group_prefix(fn.decl),
+            NATIVE_PREFIX,
+            fn.cname(emitter.names),
+        )
+    )
+    emitter.emit_error_check("retval", fn.ret_type, "return -1;")
+    if is_int_rprimitive(fn.ret_type):
+        emitter.emit_line("Py_ssize_t val = CPyTagged_AsSsize_t(retval);")
+    else:
+        emitter.emit_line("Py_ssize_t val = PyLong_AsSsize_t(retval);")
+    emitter.emit_dec_ref("retval", fn.ret_type)
+    emitter.emit_line("if (PyErr_Occurred()) return -1;")
+    # We can't return -1 from a hash function..
+    emitter.emit_line("if (val == -1) return -2;")
+    emitter.emit_line("return val;")
+    emitter.emit_line("}")
+
+    return name
+
+
+def generate_len_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generates a wrapper for native __len__ methods."""
+    name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"
+    emitter.emit_line(f"static Py_ssize_t {name}(PyObject *self) {{")
+    emitter.emit_line(
+        "{}retval = {}{}{}(self);".format(
+            emitter.ctype_spaced(fn.ret_type),
+            emitter.get_group_prefix(fn.decl),
+            NATIVE_PREFIX,
+            fn.cname(emitter.names),
+        )
+    )
+    emitter.emit_error_check("retval", fn.ret_type, "return -1;")
+    if is_int_rprimitive(fn.ret_type):
+        emitter.emit_line("Py_ssize_t val = CPyTagged_AsSsize_t(retval);")
+    else:
+        emitter.emit_line("Py_ssize_t val = PyLong_AsSsize_t(retval);")
+    emitter.emit_dec_ref("retval", fn.ret_type)
+    emitter.emit_line("if (PyErr_Occurred()) return -1;")
+    emitter.emit_line("return val;")
+    emitter.emit_line("}")
+
+    return name
+
+
+def generate_bool_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generates a wrapper for native __bool__ methods."""
+    name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"
+    emitter.emit_line(f"static int {name}(PyObject *self) {{")
+    emitter.emit_line(
+        "{}val = {}{}(self);".format(
+            emitter.ctype_spaced(fn.ret_type), NATIVE_PREFIX, fn.cname(emitter.names)
+        )
+    )
+    emitter.emit_error_check("val", fn.ret_type, "return -1;")
+    # This wouldn't be that hard to fix but it seems unimportant and
+    # getting error handling and unboxing right would be fiddly. (And
+    # way easier to do in IR!)
+    assert is_bool_rprimitive(fn.ret_type), "Only bool return supported for __bool__"
+    emitter.emit_line("return val;")
+    emitter.emit_line("}")
+
+    return name
+
+
+def generate_del_item_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generates a wrapper for native __delitem__.
+
+    This is only called from a combined __delitem__/__setitem__ wrapper.
+    """
+    name = "{}{}{}".format(DUNDER_PREFIX, "__delitem__", cl.name_prefix(emitter.names))
+    input_args = ", ".join(f"PyObject *obj_{arg.name}" for arg in fn.args)
+    emitter.emit_line(f"static int {name}({input_args}) {{")
+    generate_set_del_item_wrapper_inner(fn, emitter, fn.args)
+    return name
+
+
+def generate_set_del_item_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generates a wrapper for native __setitem__ method (also works for __delitem__).
+
+    This is used with the mapping protocol slot. Arguments are taken as *PyObjects and we
+    return a negative C int on error.
+
+    Create a separate wrapper function for __delitem__ as needed and have the
+    __setitem__ wrapper call it if the value is NULL. Return the name
+    of the outer (__setitem__) wrapper.
+    """
+    method_cls = cl.get_method_and_class("__delitem__")
+    del_name = None
+    if method_cls and method_cls[1] == cl:
+        # Generate a separate wrapper for __delitem__
+        del_name = generate_del_item_wrapper(cl, method_cls[0], emitter)
+
+    args = fn.args
+    if fn.name == "__delitem__":
+        # Add an extra argument for value that we expect to be NULL.
+        args = list(args) + [RuntimeArg("___value", object_rprimitive, ARG_POS)]
+
+    name = "{}{}{}".format(DUNDER_PREFIX, "__setitem__", cl.name_prefix(emitter.names))
+    input_args = ", ".join(f"PyObject *obj_{arg.name}" for arg in args)
+    emitter.emit_line(f"static int {name}({input_args}) {{")
+
+    # First check if this is __delitem__
+    emitter.emit_line(f"if (obj_{args[2].name} == NULL) {{")
+    if del_name is not None:
+        # We have a native implementation, so call it
+        emitter.emit_line(f"return {del_name}(obj_{args[0].name}, obj_{args[1].name});")
+    else:
+        # Try to call superclass method instead
+        emitter.emit_line(f"PyObject *super = CPy_Super(CPyModule_builtins, obj_{args[0].name});")
+        emitter.emit_line("if (super == NULL) return -1;")
+        emitter.emit_line(
+            'PyObject *result = PyObject_CallMethod(super, "__delitem__", "O", obj_{});'.format(
+                args[1].name
+            )
+        )
+        emitter.emit_line("Py_DECREF(super);")
+        emitter.emit_line("Py_XDECREF(result);")
+        emitter.emit_line("return result == NULL ? -1 : 0;")
+    emitter.emit_line("}")
+
+    method_cls = cl.get_method_and_class("__setitem__")
+    if method_cls and method_cls[1] == cl:
+        generate_set_del_item_wrapper_inner(fn, emitter, args)
+    else:
+        emitter.emit_line(f"PyObject *super = CPy_Super(CPyModule_builtins, obj_{args[0].name});")
+        emitter.emit_line("if (super == NULL) return -1;")
+        emitter.emit_line("PyObject *result;")
+
+        if method_cls is None and cl.builtin_base is None:
+            msg = f"'{cl.name}' object does not support item assignment"
+            emitter.emit_line(f'PyErr_SetString(PyExc_TypeError, "{msg}");')
+            emitter.emit_line("result = NULL;")
+        else:
+            # A base class may have __setitem__
+            emitter.emit_line(
+                'result = PyObject_CallMethod(super, "__setitem__", "OO", obj_{}, obj_{});'.format(
+                    args[1].name, args[2].name
+                )
+            )
+        emitter.emit_line("Py_DECREF(super);")
+        emitter.emit_line("Py_XDECREF(result);")
+        emitter.emit_line("return result == NULL ? -1 : 0;")
+        emitter.emit_line("}")
+    return name
+
+
+def generate_set_del_item_wrapper_inner(
+    fn: FuncIR, emitter: Emitter, args: Sequence[RuntimeArg]
+) -> None:
+    for arg in args:
+        generate_arg_check(arg.name, arg.type, emitter, GotoHandler("fail"))
+    native_args = ", ".join(f"arg_{arg.name}" for arg in args)
+    emitter.emit_line(
+        "{}val = {}{}({});".format(
+            emitter.ctype_spaced(fn.ret_type), NATIVE_PREFIX, fn.cname(emitter.names), native_args
+        )
+    )
+    emitter.emit_error_check("val", fn.ret_type, "goto fail;")
+    emitter.emit_dec_ref("val", fn.ret_type)
+    emitter.emit_line("return 0;")
+    emitter.emit_label("fail")
+    emitter.emit_line("return -1;")
+    emitter.emit_line("}")
+
+
+def generate_contains_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generates a wrapper for a native __contains__ method."""
+    name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"
+    emitter.emit_line(f"static int {name}(PyObject *self, PyObject *obj_item) {{")
+    generate_arg_check("item", fn.args[1].type, emitter, ReturnHandler("-1"))
+    emitter.emit_line(
+        "{}val = {}{}(self, arg_item);".format(
+            emitter.ctype_spaced(fn.ret_type), NATIVE_PREFIX, fn.cname(emitter.names)
+        )
+    )
+    emitter.emit_error_check("val", fn.ret_type, "return -1;")
+    if is_bool_rprimitive(fn.ret_type):
+        emitter.emit_line("return val;")
+    else:
+        emitter.emit_line("int boolval = PyObject_IsTrue(val);")
+        emitter.emit_dec_ref("val", fn.ret_type)
+        emitter.emit_line("return boolval;")
+    emitter.emit_line("}")
+
+    return name
+
+
+# Helpers
+
+
+def generate_wrapper_core(
+    fn: FuncIR,
+    emitter: Emitter,
+    optional_args: list[RuntimeArg] | None = None,
+    arg_names: list[str] | None = None,
+    cleanups: list[str] | None = None,
+    traceback_code: str | None = None,
+) -> None:
+    """Generates the core part of a wrapper function for a native function.
+
+    This expects each argument as a PyObject * named obj_{arg} as a precondition.
+    It converts the PyObject *s to the necessary types, checking and unboxing if necessary,
+    makes the call, then boxes the result if necessary and returns it.
+    """
+    gen = WrapperGenerator(None, emitter)
+    gen.set_target(fn)
+    if arg_names:
+        gen.arg_names = arg_names
+    gen.cleanups = cleanups or []
+    gen.optional_args = optional_args or []
+    gen.traceback_code = traceback_code or ""
+
+    error = ReturnHandler("NULL") if not gen.use_goto() else GotoHandler("fail")
+    gen.emit_arg_processing(error=error)
+    gen.emit_call()
+    gen.emit_error_handling()
+
+
+def generate_arg_check(
+    name: str,
+    typ: RType,
+    emitter: Emitter,
+    error: ErrorHandler | None = None,
+    *,
+    optional: bool = False,
+    raise_exception: bool = True,
+    bitmap_arg_index: int = 0,
+) -> None:
+    """Insert a runtime check for argument and unbox if necessary.
+
+    The object is named PyObject *obj_{}. This is expected to generate
+    a value of name arg_{} (unboxed if necessary). For each primitive a runtime
+    check ensures the correct type.
+    """
+    error = error or AssignHandler()
+    if typ.is_unboxed:
+        if typ.error_overlap and optional:
+            # Update bitmap is value is provided.
+            init = emitter.c_undefined_value(typ)
+            emitter.emit_line(f"{emitter.ctype(typ)} arg_{name} = {init};")
+            emitter.emit_line(f"if (obj_{name} != NULL) {{")
+            bitmap = bitmap_name(bitmap_arg_index // BITMAP_BITS)
+            emitter.emit_line(f"{bitmap} |= 1 << {bitmap_arg_index & (BITMAP_BITS - 1)};")
+            emitter.emit_unbox(
+                f"obj_{name}",
+                f"arg_{name}",
+                typ,
+                declare_dest=False,
+                raise_exception=raise_exception,
+                error=error,
+                borrow=True,
+            )
+            emitter.emit_line("}")
+        else:
+            # Borrow when unboxing to avoid reference count manipulation.
+            emitter.emit_unbox(
+                f"obj_{name}",
+                f"arg_{name}",
+                typ,
+                declare_dest=True,
+                raise_exception=raise_exception,
+                error=error,
+                borrow=True,
+                optional=optional,
+            )
+    elif is_object_rprimitive(typ):
+        # Object is trivial since any object is valid
+        if optional:
+            emitter.emit_line(f"PyObject *arg_{name};")
+            emitter.emit_line(f"if (obj_{name} == NULL) {{")
+            emitter.emit_line(f"arg_{name} = {emitter.c_error_value(typ)};")
+            emitter.emit_lines("} else {", f"arg_{name} = obj_{name}; ", "}")
+        else:
+            emitter.emit_line(f"PyObject *arg_{name} = obj_{name};")
+    else:
+        emitter.emit_cast(
+            f"obj_{name}",
+            f"arg_{name}",
+            typ,
+            declare_dest=True,
+            raise_exception=raise_exception,
+            error=error,
+            optional=optional,
+        )
+
+
+class WrapperGenerator:
+    """Helper that simplifies the generation of wrapper functions."""
+
+    # TODO: Use this for more wrappers
+
+    def __init__(self, cl: ClassIR | None, emitter: Emitter) -> None:
+        self.cl = cl
+        self.emitter = emitter
+        self.cleanups: list[str] = []
+        self.optional_args: list[RuntimeArg] = []
+        self.traceback_code = ""
+
+    def set_target(self, fn: FuncIR) -> None:
+        """Set the wrapped function.
+
+        It's fine to modify the attributes initialized here later to customize
+        the wrapper function.
+        """
+        self.target_name = fn.name
+        self.target_cname = fn.cname(self.emitter.names)
+        self.num_bitmap_args = fn.sig.num_bitmap_args
+        if self.num_bitmap_args:
+            self.args = fn.args[: -self.num_bitmap_args]
+        else:
+            self.args = fn.args
+        self.arg_names = [arg.name for arg in self.args]
+        self.ret_type = fn.ret_type
+
+    def wrapper_name(self) -> str:
+        """Return the name of the wrapper function."""
+        return "{}{}{}".format(
+            DUNDER_PREFIX,
+            self.target_name,
+            self.cl.name_prefix(self.emitter.names) if self.cl else "",
+        )
+
+    def use_goto(self) -> bool:
+        """Do we use a goto for error handling (instead of straight return)?"""
+        return bool(self.cleanups or self.traceback_code)
+
+    def emit_header(self) -> None:
+        """Emit the function header of the wrapper implementation."""
+        input_args = ", ".join(f"PyObject *obj_{arg}" for arg in self.arg_names)
+        self.emitter.emit_line(
+            "static PyObject *{name}({input_args}) {{".format(
+                name=self.wrapper_name(), input_args=input_args
+            )
+        )
+
+    def emit_arg_processing(
+        self, error: ErrorHandler | None = None, raise_exception: bool = True
+    ) -> None:
+        """Emit validation and unboxing of arguments."""
+        error = error or self.error()
+        bitmap_arg_index = 0
+        for arg_name, arg in zip(self.arg_names, self.args):
+            # Suppress the argument check for *args/**kwargs, since we know it must be right.
+            typ = arg.type if arg.kind not in (ARG_STAR, ARG_STAR2) else object_rprimitive
+            optional = arg in self.optional_args
+            generate_arg_check(
+                arg_name,
+                typ,
+                self.emitter,
+                error,
+                raise_exception=raise_exception,
+                optional=optional,
+                bitmap_arg_index=bitmap_arg_index,
+            )
+            if optional and typ.error_overlap:
+                bitmap_arg_index += 1
+
+    def emit_call(self, not_implemented_handler: str = "") -> None:
+        """Emit call to the wrapper function.
+
+        If not_implemented_handler is non-empty, use this C code to handle
+        a NotImplemented return value (if it's possible based on the return type).
+        """
+        native_args = ", ".join(f"arg_{arg}" for arg in self.arg_names)
+        if self.num_bitmap_args:
+            bitmap_args = ", ".join(
+                [bitmap_name(i) for i in reversed(range(self.num_bitmap_args))]
+            )
+            native_args = f"{native_args}, {bitmap_args}"
+
+        ret_type = self.ret_type
+        emitter = self.emitter
+        if ret_type.is_unboxed or self.use_goto():
+            # TODO: The Py_RETURN macros return the correct PyObject * with reference count
+            #       handling. Are they relevant?
+            emitter.emit_line(
+                "{}retval = {}{}({});".format(
+                    emitter.ctype_spaced(ret_type), NATIVE_PREFIX, self.target_cname, native_args
+                )
+            )
+            emitter.emit_lines(*self.cleanups)
+            if ret_type.is_unboxed:
+                emitter.emit_error_check("retval", ret_type, "return NULL;")
+                emitter.emit_box("retval", "retbox", ret_type, declare_dest=True)
+
+            emitter.emit_line("return {};".format("retbox" if ret_type.is_unboxed else "retval"))
+        else:
+            if not_implemented_handler and not isinstance(ret_type, RInstance):
+                # The return value type may overlap with NotImplemented.
+                emitter.emit_line(
+                    "PyObject *retbox = {}{}({});".format(
+                        NATIVE_PREFIX, self.target_cname, native_args
+                    )
+                )
+                emitter.emit_lines(
+                    "if (retbox == Py_NotImplemented) {",
+                    not_implemented_handler,
+                    "}",
+                    "return retbox;",
+                )
+            else:
+                emitter.emit_line(f"return {NATIVE_PREFIX}{self.target_cname}({native_args});")
+            # TODO: Tracebacks?
+
+    def error(self) -> ErrorHandler:
+        """Figure out how to deal with errors in the wrapper."""
+        if self.cleanups or self.traceback_code:
+            # We'll have a label at the end with error handling code.
+            return GotoHandler("fail")
+        else:
+            # Nothing special needs to done to handle errors, so just return.
+            return ReturnHandler("NULL")
+
+    def emit_error_handling(self) -> None:
+        """Emit error handling block at the end of the wrapper, if needed."""
+        emitter = self.emitter
+        if self.use_goto():
+            emitter.emit_label("fail")
+            emitter.emit_lines(*self.cleanups)
+            if self.traceback_code:
+                emitter.emit_line(self.traceback_code)
+            emitter.emit_line("return NULL;")
+
+    def finish(self) -> None:
+        self.emitter.emit_line("}")

micromamba_root/Lib/site-packages/mypyc/codegen/literals.py

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+from typing import Final, TypeGuard
+
+# Supported Python literal types. All tuple / frozenset items must have supported
+# literal types as well, but we can't represent the type precisely.
+LiteralValue = (
+    str | bytes | int | bool | float | complex | tuple[object, ...] | frozenset[object] | None
+)
+
+
+def _is_literal_value(obj: object) -> TypeGuard[LiteralValue]:
+    return isinstance(obj, (str, bytes, int, float, complex, tuple, frozenset, type(None)))
+
+
+# Some literals are singletons and handled specially (None, False and True)
+NUM_SINGLETONS: Final = 3
+
+
+class Literals:
+    """Collection of literal values used in a compilation group and related helpers."""
+
+    def __init__(self) -> None:
+        # Each dict maps value to literal index (0, 1, ...)
+        self.str_literals: dict[str, int] = {}
+        self.bytes_literals: dict[bytes, int] = {}
+        self.int_literals: dict[int, int] = {}
+        self.float_literals: dict[float, int] = {}
+        self.complex_literals: dict[complex, int] = {}
+        self.tuple_literals: dict[tuple[object, ...], int] = {}
+        self.frozenset_literals: dict[frozenset[object], int] = {}
+
+    def record_literal(self, value: LiteralValue) -> None:
+        """Ensure that the literal value is available in generated code."""
+        if value is None or value is True or value is False:
+            # These are special cased and always present
+            return
+        if isinstance(value, str):
+            str_literals = self.str_literals
+            if value not in str_literals:
+                str_literals[value] = len(str_literals)
+        elif isinstance(value, bytes):
+            bytes_literals = self.bytes_literals
+            if value not in bytes_literals:
+                bytes_literals[value] = len(bytes_literals)
+        elif isinstance(value, int):
+            int_literals = self.int_literals
+            if value not in int_literals:
+                int_literals[value] = len(int_literals)
+        elif isinstance(value, float):
+            float_literals = self.float_literals
+            if value not in float_literals:
+                float_literals[value] = len(float_literals)
+        elif isinstance(value, complex):
+            complex_literals = self.complex_literals
+            if value not in complex_literals:
+                complex_literals[value] = len(complex_literals)
+        elif isinstance(value, tuple):
+            tuple_literals = self.tuple_literals
+            if value not in tuple_literals:
+                for item in value:
+                    assert _is_literal_value(item)
+                    self.record_literal(item)
+                tuple_literals[value] = len(tuple_literals)
+        elif isinstance(value, frozenset):
+            frozenset_literals = self.frozenset_literals
+            if value not in frozenset_literals:
+                for item in value:
+                    assert _is_literal_value(item)
+                    self.record_literal(item)
+                frozenset_literals[value] = len(frozenset_literals)
+        else:
+            assert False, "invalid literal: %r" % value
+
+    def literal_index(self, value: LiteralValue) -> int:
+        """Return the index to the literals array for given value."""
+        # The array contains first None and booleans, followed by all str values,
+        # followed by bytes values, etc.
+        if value is None:
+            return 0
+        elif value is False:
+            return 1
+        elif value is True:
+            return 2
+        n = NUM_SINGLETONS
+        if isinstance(value, str):
+            return n + self.str_literals[value]
+        n += len(self.str_literals)
+        if isinstance(value, bytes):
+            return n + self.bytes_literals[value]
+        n += len(self.bytes_literals)
+        if isinstance(value, int):
+            return n + self.int_literals[value]
+        n += len(self.int_literals)
+        if isinstance(value, float):
+            return n + self.float_literals[value]
+        n += len(self.float_literals)
+        if isinstance(value, complex):
+            return n + self.complex_literals[value]
+        n += len(self.complex_literals)
+        if isinstance(value, tuple):
+            return n + self.tuple_literals[value]
+        n += len(self.tuple_literals)
+        if isinstance(value, frozenset):
+            return n + self.frozenset_literals[value]
+        assert False, "invalid literal: %r" % value
+
+    def num_literals(self) -> int:
+        # The first three are for None, True and False
+        return (
+            NUM_SINGLETONS
+            + len(self.str_literals)
+            + len(self.bytes_literals)
+            + len(self.int_literals)
+            + len(self.float_literals)
+            + len(self.complex_literals)
+            + len(self.tuple_literals)
+            + len(self.frozenset_literals)
+        )
+
+    # The following methods return the C encodings of literal values
+    # of different types
+
+    def encoded_str_values(self) -> list[bytes]:
+        return _encode_str_values(self.str_literals)
+
+    def encoded_int_values(self) -> list[bytes]:
+        return _encode_int_values(self.int_literals)
+
+    def encoded_bytes_values(self) -> list[bytes]:
+        return _encode_bytes_values(self.bytes_literals)
+
+    def encoded_float_values(self) -> list[str]:
+        return _encode_float_values(self.float_literals)
+
+    def encoded_complex_values(self) -> list[str]:
+        return _encode_complex_values(self.complex_literals)
+
+    def encoded_tuple_values(self) -> list[str]:
+        return self._encode_collection_values(self.tuple_literals)
+
+    def encoded_frozenset_values(self) -> list[str]:
+        return self._encode_collection_values(self.frozenset_literals)
+
+    def _encode_collection_values(
+        self, values: dict[tuple[object, ...], int] | dict[frozenset[object], int]
+    ) -> list[str]:
+        """Encode tuple/frozenset values into a C array.
+
+        The format of the result is like this:
+
+           <number of collections>
+           <length of the first collection>
+           <literal index of first item>
+           ...
+           <literal index of last item>
+           <length of the second collection>
+           ...
+        """
+        value_by_index = {index: value for value, index in values.items()}
+        result = []
+        count = len(values)
+        result.append(str(count))
+        for i in range(count):
+            value = value_by_index[i]
+            result.append(str(len(value)))
+            for item in value:
+                assert _is_literal_value(item)
+                index = self.literal_index(item)
+                result.append(str(index))
+        return result
+
+
+def _encode_str_values(values: dict[str, int]) -> list[bytes]:
+    value_by_index = {index: value for value, index in values.items()}
+    result = []
+    line: list[bytes] = []
+    line_len = 0
+    for i in range(len(values)):
+        value = value_by_index[i]
+        c_literal = format_str_literal(value)
+        c_len = len(c_literal)
+        if line_len > 0 and line_len + c_len > 70:
+            result.append(format_int(len(line)) + b"".join(line))
+            line = []
+            line_len = 0
+        line.append(c_literal)
+        line_len += c_len
+    if line:
+        result.append(format_int(len(line)) + b"".join(line))
+    result.append(b"")
+    return result
+
+
+def _encode_bytes_values(values: dict[bytes, int]) -> list[bytes]:
+    value_by_index = {index: value for value, index in values.items()}
+    result = []
+    line: list[bytes] = []
+    line_len = 0
+    for i in range(len(values)):
+        value = value_by_index[i]
+        c_init = format_int(len(value))
+        c_len = len(c_init) + len(value)
+        if line_len > 0 and line_len + c_len > 70:
+            result.append(format_int(len(line)) + b"".join(line))
+            line = []
+            line_len = 0
+        line.append(c_init + value)
+        line_len += c_len
+    if line:
+        result.append(format_int(len(line)) + b"".join(line))
+    result.append(b"")
+    return result
+
+
+def format_int(n: int) -> bytes:
+    """Format an integer using a variable-length binary encoding."""
+    if n < 128:
+        a = [n]
+    else:
+        a = []
+        while n > 0:
+            a.insert(0, n & 0x7F)
+            n >>= 7
+        for i in range(len(a) - 1):
+            # If the highest bit is set, more 7-bit digits follow
+            a[i] |= 0x80
+    return bytes(a)
+
+
+def format_str_literal(s: str) -> bytes:
+    utf8 = s.encode("utf-8", errors="surrogatepass")
+    return format_int(len(utf8)) + utf8
+
+
+def _encode_int_values(values: dict[int, int]) -> list[bytes]:
+    """Encode int values into C strings.
+
+    Values are stored in base 10 and separated by 0 bytes.
+    """
+    value_by_index = {index: value for value, index in values.items()}
+    result = []
+    line: list[bytes] = []
+    line_len = 0
+    for i in range(len(values)):
+        value = value_by_index[i]
+        encoded = b"%d" % value
+        if line_len > 0 and line_len + len(encoded) > 70:
+            result.append(format_int(len(line)) + b"\0".join(line))
+            line = []
+            line_len = 0
+        line.append(encoded)
+        line_len += len(encoded)
+    if line:
+        result.append(format_int(len(line)) + b"\0".join(line))
+    result.append(b"")
+    return result
+
+
+def float_to_c(x: float) -> str:
+    """Return C literal representation of a float value."""
+    s = str(x)
+    if s == "inf":
+        return "INFINITY"
+    elif s == "-inf":
+        return "-INFINITY"
+    elif s == "nan":
+        return "NAN"
+    return s
+
+
+def _encode_float_values(values: dict[float, int]) -> list[str]:
+    """Encode float values into a C array values.
+
+    The result contains the number of values followed by individual values.
+    """
+    value_by_index = {index: value for value, index in values.items()}
+    result = []
+    num = len(values)
+    result.append(str(num))
+    for i in range(num):
+        value = value_by_index[i]
+        result.append(float_to_c(value))
+    return result
+
+
+def _encode_complex_values(values: dict[complex, int]) -> list[str]:
+    """Encode float values into a C array values.
+
+    The result contains the number of values followed by pairs of doubles
+    representing complex numbers.
+    """
+    value_by_index = {index: value for value, index in values.items()}
+    result = []
+    num = len(values)
+    result.append(str(num))
+    for i in range(num):
+        value = value_by_index[i]
+        result.append(float_to_c(value.real))
+        result.append(float_to_c(value.imag))
+    return result

micromamba_root/Lib/site-packages/mypyc/ir/class_ir.py

@@ -0,0 +1,550 @@
+"""Intermediate representation of classes."""
+
+from __future__ import annotations
+
+from typing import NamedTuple
+
+from mypyc.common import PROPSET_PREFIX, JsonDict
+from mypyc.ir.func_ir import FuncDecl, FuncIR, FuncSignature, RuntimeArg
+from mypyc.ir.ops import DeserMaps, Value
+from mypyc.ir.rtypes import RInstance, RType, deserialize_type, object_rprimitive
+from mypyc.namegen import NameGenerator, exported_name
+
+# Some notes on the vtable layout: Each concrete class has a vtable
+# that contains function pointers for its methods. So that subclasses
+# may be efficiently used when their parent class is expected, the
+# layout of child vtables must be an extension of their base class's
+# vtable.
+#
+# This makes multiple inheritance tricky, since obviously we cannot be
+# an extension of multiple parent classes. We solve this by requiring
+# all but one parent to be "traits", which we can operate on in a
+# somewhat less efficient way. For each trait implemented by a class,
+# we generate a separate vtable for the methods in that trait.
+# We then store an array of (trait type, trait vtable) pointers alongside
+# a class's main vtable. When we want to call a trait method, we
+# (at runtime!) search the array of trait vtables to find the correct one,
+# then call through it.
+# Trait vtables additionally need entries for attribute getters and setters,
+# since they can't always be in the same location.
+#
+# To keep down the number of indirections necessary, we store the
+# array of trait vtables in the memory *before* the class vtable, and
+# search it backwards.  (This is a trick we can only do once---there
+# are only two directions to store data in---but I don't think we'll
+# need it again.)
+# There are some tricks we could try in the future to store the trait
+# vtables inline in the trait table (which would cut down one indirection),
+# but this seems good enough for now.
+#
+# As an example:
+# Imagine that we have a class B that inherits from a concrete class A
+# and traits T1 and T2, and that A has methods foo() and
+# bar() and B overrides bar() with a more specific type.
+# Then B's vtable will look something like:
+#
+#      T1 type object
+#      ptr to B's T1 trait vtable
+#      T2 type object
+#      ptr to B's T2 trait vtable
+# -> | A.foo
+#    | Glue function that converts between A.bar's type and B.bar
+#      B.bar
+#      B.baz
+#
+# The arrow points to the "start" of the vtable (what vtable pointers
+# point to) and the bars indicate which parts correspond to the parent
+# class A's vtable layout.
+#
+# Classes that allow interpreted code to subclass them also have a
+# "shadow vtable" that contains implementations that delegate to
+# making a pycall, so that overridden methods in interpreted children
+# will be called. (A better strategy could dynamically generate these
+# vtables based on which methods are overridden in the children.)
+
+# Descriptions of method and attribute entries in class vtables.
+# The 'cls' field is the class that the method/attr was defined in,
+# which might be a parent class.
+# The 'shadow_method', if present, contains the method that should be
+# placed in the class's shadow vtable (if it has one).
+
+
+class VTableMethod(NamedTuple):
+    cls: "ClassIR"  # noqa: UP037
+    name: str
+    method: FuncIR
+    shadow_method: FuncIR | None
+
+
+VTableEntries = list[VTableMethod]
+
+
+class ClassIR:
+    """Intermediate representation of a class.
+
+    This also describes the runtime structure of native instances.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        module_name: str,
+        is_trait: bool = False,
+        is_generated: bool = False,
+        is_abstract: bool = False,
+        is_ext_class: bool = True,
+        is_final_class: bool = False,
+    ) -> None:
+        self.name = name
+        self.module_name = module_name
+        self.is_trait = is_trait
+        self.is_generated = is_generated
+        self.is_abstract = is_abstract
+        self.is_ext_class = is_ext_class
+        self.is_final_class = is_final_class
+        # An augmented class has additional methods separate from what mypyc generates.
+        # Right now the only one is dataclasses.
+        self.is_augmented = False
+        # Does this inherit from a Python class?
+        self.inherits_python = False
+        # Do instances of this class have __dict__?
+        self.has_dict = False
+        # Do we allow interpreted subclasses? Derived from a mypyc_attr.
+        self.allow_interpreted_subclasses = False
+        # Does this class need getseters to be generated for its attributes? (getseters are also
+        # added if is_generated is False)
+        self.needs_getseters = False
+        # Is this class declared as serializable (supports copy.copy
+        # and pickle) using @mypyc_attr(serializable=True)?
+        #
+        # Additionally, any class with this attribute False but with
+        # an __init__ that can be called without any arguments is
+        # *implicitly serializable*. In this case __init__ will be
+        # called during deserialization without arguments. If this is
+        # True, we match Python semantics and __init__ won't be called
+        # during deserialization.
+        #
+        # This impacts also all subclasses. Use is_serializable() to
+        # also consider base classes.
+        self._serializable = False
+        # If this a subclass of some built-in python class, the name
+        # of the object for that class. We currently only support this
+        # in a few ad-hoc cases.
+        self.builtin_base: str | None = None
+        # Default empty constructor
+        self.ctor = FuncDecl(name, None, module_name, FuncSignature([], RInstance(self)))
+        # Declare setup method that allocates and initializes an object. type is the
+        # type of the class being initialized, which could be another class if there
+        # is an interpreted subclass.
+        # TODO: Make it a regular method and generate its body in IR
+        self.setup = FuncDecl(
+            "__mypyc__" + name + "_setup",
+            None,
+            module_name,
+            FuncSignature([RuntimeArg("type", object_rprimitive)], RInstance(self)),
+        )
+        # Attributes defined in the class (not inherited)
+        self.attributes: dict[str, RType] = {}
+        # Deletable attributes
+        self.deletable: list[str] = []
+        # We populate method_types with the signatures of every method before
+        # we generate methods, and we rely on this information being present.
+        self.method_decls: dict[str, FuncDecl] = {}
+        # Map of methods that are actually present in an extension class
+        self.methods: dict[str, FuncIR] = {}
+        # Glue methods for boxing/unboxing when a class changes the type
+        # while overriding a method. Maps from (parent class overridden, method)
+        # to IR of glue method.
+        self.glue_methods: dict[tuple[ClassIR, str], FuncIR] = {}
+
+        # Properties are accessed like attributes, but have behavior like method calls.
+        # They don't belong in the methods dictionary, since we don't want to expose them to
+        # Python's method API. But we want to put them into our own vtable as methods, so that
+        # they are properly handled and overridden. The property dictionary values are a tuple
+        # containing a property getter and an optional property setter.
+        self.properties: dict[str, tuple[FuncIR, FuncIR | None]] = {}
+        # We generate these in prepare_class_def so that we have access to them when generating
+        # other methods and properties that rely on these types.
+        self.property_types: dict[str, RType] = {}
+
+        self.vtable: dict[str, int] | None = None
+        self.vtable_entries: VTableEntries = []
+        self.trait_vtables: dict[ClassIR, VTableEntries] = {}
+        # N.B: base might not actually quite be the direct base.
+        # It is the nearest concrete base, but we allow a trait in between.
+        self.base: ClassIR | None = None
+        self.traits: list[ClassIR] = []
+        # Supply a working mro for most generated classes. Real classes will need to
+        # fix it up.
+        self.mro: list[ClassIR] = [self]
+        # base_mro is the chain of concrete (non-trait) ancestors
+        self.base_mro: list[ClassIR] = [self]
+
+        # Direct subclasses of this class (use subclasses() to also include non-direct ones)
+        # None if separate compilation prevents this from working.
+        #
+        # Often it's better to use has_no_subclasses() or subclasses() instead.
+        self.children: list[ClassIR] | None = []
+
+        # Instance attributes that are initialized in the class body.
+        self.attrs_with_defaults: set[str] = set()
+
+        # Attributes that are always initialized in __init__ or class body
+        # (inferred in mypyc.analysis.attrdefined using interprocedural analysis).
+        # These can never raise AttributeError when accessed. If an attribute
+        # is *not* always initialized, we normally use the error value for
+        # an undefined value. If the attribute byte has an overlapping error value
+        # (the error_overlap attribute is true for the RType), we use a bitmap
+        # to track if the attribute is defined instead (see bitmap_attrs).
+        self._always_initialized_attrs: set[str] = set()
+
+        # Attributes that are sometimes initialized in __init__
+        self._sometimes_initialized_attrs: set[str] = set()
+
+        # If True, __init__ can make 'self' visible to unanalyzed/arbitrary code
+        self.init_self_leak = False
+
+        # Definedness of these attributes is backed by a bitmap. Index in the list
+        # indicates the bit number. Includes inherited attributes. We need the
+        # bitmap for types such as native ints (i64 etc.) that can't have a dedicated
+        # error value that doesn't overlap a valid value. The bitmap is used if the
+        # value of an attribute is the same as the error value.
+        self.bitmap_attrs: list[str] = []
+
+        # If this is a generator environment class, what is the actual method for it
+        self.env_user_function: FuncIR | None = None
+
+        # If True, keep one freed, cleared instance available for immediate reuse to
+        # speed up allocations. This helps if many objects are freed quickly, before
+        # other instances of the same class are allocated. This is effectively a
+        # per-type free "list" of up to length 1.
+        self.reuse_freed_instance = False
+
+        # If True, the class does not participate in cyclic garbage collection.
+        # This can improve performance but is only safe if instances can never
+        # be part of reference cycles. Derived from @mypyc_attr(acyclic=True).
+        self.is_acyclic = False
+
+        # Is this a class inheriting from enum.Enum? Such classes can be special-cased.
+        self.is_enum = False
+
+        # Name of the function if this a callable class representing a coroutine.
+        self.coroutine_name: str | None = None
+
+    def __repr__(self) -> str:
+        return (
+            "ClassIR("
+            "name={self.name}, module_name={self.module_name}, "
+            "is_trait={self.is_trait}, is_generated={self.is_generated}, "
+            "is_abstract={self.is_abstract}, is_ext_class={self.is_ext_class}, "
+            "is_final_class={self.is_final_class}"
+            ")".format(self=self)
+        )
+
+    @property
+    def fullname(self) -> str:
+        return f"{self.module_name}.{self.name}"
+
+    def real_base(self) -> ClassIR | None:
+        """Return the actual concrete base class, if there is one."""
+        if len(self.mro) > 1 and not self.mro[1].is_trait:
+            return self.mro[1]
+        return None
+
+    def vtable_entry(self, name: str) -> int:
+        assert self.vtable is not None, "vtable not computed yet"
+        assert name in self.vtable, f"{self.name!r} has no attribute {name!r}"
+        return self.vtable[name]
+
+    def attr_details(self, name: str) -> tuple[RType, ClassIR]:
+        for ir in self.mro:
+            if name in ir.attributes:
+                return ir.attributes[name], ir
+            if name in ir.property_types:
+                return ir.property_types[name], ir
+        raise KeyError(f"{self.name!r} has no attribute {name!r}")
+
+    def attr_type(self, name: str) -> RType:
+        return self.attr_details(name)[0]
+
+    def method_decl(self, name: str) -> FuncDecl:
+        for ir in self.mro:
+            if name in ir.method_decls:
+                return ir.method_decls[name]
+        raise KeyError(f"{self.name!r} has no attribute {name!r}")
+
+    def method_sig(self, name: str) -> FuncSignature:
+        return self.method_decl(name).sig
+
+    def has_method(self, name: str) -> bool:
+        try:
+            self.method_decl(name)
+        except KeyError:
+            return False
+        return True
+
+    def is_method_final(self, name: str) -> bool:
+        subs = self.subclasses()
+        if subs is None:
+            return self.is_final_class
+
+        if self.has_method(name):
+            method_decl = self.method_decl(name)
+            for subc in subs:
+                if subc.method_decl(name) != method_decl:
+                    return False
+            return True
+        else:
+            return not any(subc.has_method(name) for subc in subs)
+
+    def has_attr(self, name: str) -> bool:
+        try:
+            self.attr_type(name)
+        except KeyError:
+            return False
+        return True
+
+    def is_deletable(self, name: str) -> bool:
+        return any(name in ir.deletable for ir in self.mro)
+
+    def is_always_defined(self, name: str) -> bool:
+        if self.is_deletable(name):
+            return False
+        return name in self._always_initialized_attrs
+
+    def name_prefix(self, names: NameGenerator) -> str:
+        return names.private_name(self.module_name, self.name)
+
+    def struct_name(self, names: NameGenerator) -> str:
+        return f"{exported_name(self.fullname)}Object"
+
+    def get_method_and_class(
+        self, name: str, *, prefer_method: bool = False
+    ) -> tuple[FuncIR, ClassIR] | None:
+        for ir in self.mro:
+            if name in ir.methods:
+                func_ir = ir.methods[name]
+                if not prefer_method and func_ir.decl.implicit:
+                    # This is an implicit accessor, so there is also an attribute definition
+                    # which the caller prefers. This happens if an attribute overrides a
+                    # property.
+                    return None
+                return func_ir, ir
+
+        return None
+
+    def get_method(self, name: str, *, prefer_method: bool = False) -> FuncIR | None:
+        res = self.get_method_and_class(name, prefer_method=prefer_method)
+        return res[0] if res else None
+
+    def has_method_decl(self, name: str) -> bool:
+        return any(name in ir.method_decls for ir in self.mro)
+
+    def has_no_subclasses(self) -> bool:
+        return self.children == [] and not self.allow_interpreted_subclasses
+
+    def subclasses(self) -> set[ClassIR] | None:
+        """Return all subclasses of this class, both direct and indirect.
+
+        Return None if it is impossible to identify all subclasses, for example
+        because we are performing separate compilation.
+        """
+        if self.children is None or self.allow_interpreted_subclasses:
+            return None
+        result = set(self.children)
+        for child in self.children:
+            if child.children:
+                child_subs = child.subclasses()
+                if child_subs is None:
+                    return None
+                result.update(child_subs)
+        return result
+
+    def concrete_subclasses(self) -> list[ClassIR] | None:
+        """Return all concrete (i.e. non-trait and non-abstract) subclasses.
+
+        Include both direct and indirect subclasses. Place classes with no children first.
+        """
+        subs = self.subclasses()
+        if subs is None:
+            return None
+        concrete = {c for c in subs if not (c.is_trait or c.is_abstract)}
+        # We place classes with no children first because they are more likely
+        # to appear in various isinstance() checks. We then sort leaves by name
+        # to get stable order.
+        return sorted(concrete, key=lambda c: (len(c.children or []), c.name))
+
+    def is_serializable(self) -> bool:
+        return any(ci._serializable for ci in self.mro)
+
+    def serialize(self) -> JsonDict:
+        return {
+            "name": self.name,
+            "module_name": self.module_name,
+            "is_trait": self.is_trait,
+            "is_ext_class": self.is_ext_class,
+            "is_abstract": self.is_abstract,
+            "is_generated": self.is_generated,
+            "is_augmented": self.is_augmented,
+            "is_final_class": self.is_final_class,
+            "inherits_python": self.inherits_python,
+            "has_dict": self.has_dict,
+            "allow_interpreted_subclasses": self.allow_interpreted_subclasses,
+            "needs_getseters": self.needs_getseters,
+            "_serializable": self._serializable,
+            "builtin_base": self.builtin_base,
+            "ctor": self.ctor.serialize(),
+            # We serialize dicts as lists to ensure order is preserved
+            "attributes": [(k, t.serialize()) for k, t in self.attributes.items()],
+            # We try to serialize a name reference, but if the decl isn't in methods
+            # then we can't be sure that will work so we serialize the whole decl.
+            "method_decls": [
+                (k, d.id if k in self.methods else d.serialize())
+                for k, d in self.method_decls.items()
+            ],
+            # We serialize method fullnames out and put methods in a separate dict
+            "methods": [(k, m.id) for k, m in self.methods.items()],
+            "glue_methods": [
+                ((cir.fullname, k), m.id) for (cir, k), m in self.glue_methods.items()
+            ],
+            # We serialize properties and property_types separately out of an
+            # abundance of caution about preserving dict ordering...
+            "property_types": [(k, t.serialize()) for k, t in self.property_types.items()],
+            "properties": list(self.properties),
+            "vtable": self.vtable,
+            "vtable_entries": serialize_vtable(self.vtable_entries),
+            "trait_vtables": [
+                (cir.fullname, serialize_vtable(v)) for cir, v in self.trait_vtables.items()
+            ],
+            # References to class IRs are all just names
+            "base": self.base.fullname if self.base else None,
+            "traits": [cir.fullname for cir in self.traits],
+            "mro": [cir.fullname for cir in self.mro],
+            "base_mro": [cir.fullname for cir in self.base_mro],
+            "children": (
+                [cir.fullname for cir in self.children] if self.children is not None else None
+            ),
+            "deletable": self.deletable,
+            "attrs_with_defaults": sorted(self.attrs_with_defaults),
+            "_always_initialized_attrs": sorted(self._always_initialized_attrs),
+            "_sometimes_initialized_attrs": sorted(self._sometimes_initialized_attrs),
+            "init_self_leak": self.init_self_leak,
+            "env_user_function": self.env_user_function.id if self.env_user_function else None,
+            "reuse_freed_instance": self.reuse_freed_instance,
+            "is_acyclic": self.is_acyclic,
+            "is_enum": self.is_enum,
+            "is_coroutine": self.coroutine_name,
+        }
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> ClassIR:
+        fullname = data["module_name"] + "." + data["name"]
+        assert fullname in ctx.classes, "Class %s not in deser class map" % fullname
+        ir = ctx.classes[fullname]
+
+        ir.is_trait = data["is_trait"]
+        ir.is_generated = data["is_generated"]
+        ir.is_abstract = data["is_abstract"]
+        ir.is_ext_class = data["is_ext_class"]
+        ir.is_augmented = data["is_augmented"]
+        ir.is_final_class = data["is_final_class"]
+        ir.inherits_python = data["inherits_python"]
+        ir.has_dict = data["has_dict"]
+        ir.allow_interpreted_subclasses = data["allow_interpreted_subclasses"]
+        ir.needs_getseters = data["needs_getseters"]
+        ir._serializable = data["_serializable"]
+        ir.builtin_base = data["builtin_base"]
+        ir.ctor = FuncDecl.deserialize(data["ctor"], ctx)
+        ir.attributes = {k: deserialize_type(t, ctx) for k, t in data["attributes"]}
+        ir.method_decls = {
+            k: ctx.functions[v].decl if isinstance(v, str) else FuncDecl.deserialize(v, ctx)
+            for k, v in data["method_decls"]
+        }
+        ir.methods = {k: ctx.functions[v] for k, v in data["methods"]}
+        ir.glue_methods = {
+            (ctx.classes[c], k): ctx.functions[v] for (c, k), v in data["glue_methods"]
+        }
+        ir.property_types = {k: deserialize_type(t, ctx) for k, t in data["property_types"]}
+        ir.properties = {
+            k: (ir.methods[k], ir.methods.get(PROPSET_PREFIX + k)) for k in data["properties"]
+        }
+
+        ir.vtable = data["vtable"]
+        ir.vtable_entries = deserialize_vtable(data["vtable_entries"], ctx)
+        ir.trait_vtables = {
+            ctx.classes[k]: deserialize_vtable(v, ctx) for k, v in data["trait_vtables"]
+        }
+
+        base = data["base"]
+        ir.base = ctx.classes[base] if base else None
+        ir.traits = [ctx.classes[s] for s in data["traits"]]
+        ir.mro = [ctx.classes[s] for s in data["mro"]]
+        ir.base_mro = [ctx.classes[s] for s in data["base_mro"]]
+        ir.children = data["children"] and [ctx.classes[s] for s in data["children"]]
+        ir.deletable = data["deletable"]
+        ir.attrs_with_defaults = set(data["attrs_with_defaults"])
+        ir._always_initialized_attrs = set(data["_always_initialized_attrs"])
+        ir._sometimes_initialized_attrs = set(data["_sometimes_initialized_attrs"])
+        ir.init_self_leak = data["init_self_leak"]
+        ir.env_user_function = (
+            ctx.functions[data["env_user_function"]] if data["env_user_function"] else None
+        )
+        ir.reuse_freed_instance = data["reuse_freed_instance"]
+        ir.is_acyclic = data.get("is_acyclic", False)
+        ir.is_enum = data["is_enum"]
+        ir.coroutine_name = data["is_coroutine"]
+
+        return ir
+
+
+class NonExtClassInfo:
+    """Information needed to construct a non-extension class (Python class).
+
+    Includes the class dictionary, a tuple of base classes,
+    the class annotations dictionary, and the metaclass.
+    """
+
+    def __init__(self, dict: Value, bases: Value, anns: Value, metaclass: Value) -> None:
+        self.dict = dict
+        self.bases = bases
+        self.anns = anns
+        self.metaclass = metaclass
+
+
+def serialize_vtable_entry(entry: VTableMethod) -> JsonDict:
+    return {
+        ".class": "VTableMethod",
+        "cls": entry.cls.fullname,
+        "name": entry.name,
+        "method": entry.method.decl.id,
+        "shadow_method": entry.shadow_method.decl.id if entry.shadow_method else None,
+    }
+
+
+def serialize_vtable(vtable: VTableEntries) -> list[JsonDict]:
+    return [serialize_vtable_entry(v) for v in vtable]
+
+
+def deserialize_vtable_entry(data: JsonDict, ctx: DeserMaps) -> VTableMethod:
+    if data[".class"] == "VTableMethod":
+        return VTableMethod(
+            ctx.classes[data["cls"]],
+            data["name"],
+            ctx.functions[data["method"]],
+            ctx.functions[data["shadow_method"]] if data["shadow_method"] else None,
+        )
+    assert False, "Bogus vtable .class: %s" % data[".class"]
+
+
+def deserialize_vtable(data: list[JsonDict], ctx: DeserMaps) -> VTableEntries:
+    return [deserialize_vtable_entry(x, ctx) for x in data]
+
+
+def all_concrete_classes(class_ir: ClassIR) -> list[ClassIR] | None:
+    """Return all concrete classes among the class itself and its subclasses."""
+    concrete = class_ir.concrete_subclasses()
+    if concrete is None:
+        return None
+    if not (class_ir.is_abstract or class_ir.is_trait):
+        concrete.append(class_ir)
+    return concrete

micromamba_root/Lib/site-packages/mypyc/ir/deps.py

@@ -0,0 +1,59 @@
+from typing import Final
+
+
+class Capsule:
+    """Defines a C extension capsule that a primitive may require."""
+
+    def __init__(self, name: str) -> None:
+        # Module fullname, e.g. 'librt.base64'
+        self.name: Final = name
+
+    def __repr__(self) -> str:
+        return f"Capsule(name={self.name!r})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, Capsule) and self.name == other.name
+
+    def __hash__(self) -> int:
+        return hash(("Capsule", self.name))
+
+
+class SourceDep:
+    """Defines a C source file that a primitive may require.
+
+    Each source file must also have a corresponding .h file (replace .c with .h)
+    that gets implicitly #included if the source is used.
+    """
+
+    def __init__(self, path: str) -> None:
+        # Relative path from mypyc/lib-rt, e.g. 'bytes_extra_ops.c'
+        self.path: Final = path
+
+    def __repr__(self) -> str:
+        return f"SourceDep(path={self.path!r})"
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, SourceDep) and self.path == other.path
+
+    def __hash__(self) -> int:
+        return hash(("SourceDep", self.path))
+
+    def get_header(self) -> str:
+        """Get the header file path by replacing .c with .h"""
+        return self.path.replace(".c", ".h")
+
+
+Dependency = Capsule | SourceDep
+
+
+LIBRT_STRINGS: Final = Capsule("librt.strings")
+LIBRT_BASE64: Final = Capsule("librt.base64")
+LIBRT_VECS: Final = Capsule("librt.vecs")
+LIBRT_TIME: Final = Capsule("librt.time")
+
+BYTES_EXTRA_OPS: Final = SourceDep("bytes_extra_ops.c")
+BYTES_WRITER_EXTRA_OPS: Final = SourceDep("byteswriter_extra_ops.c")
+STRING_WRITER_EXTRA_OPS: Final = SourceDep("stringwriter_extra_ops.c")
+BYTEARRAY_EXTRA_OPS: Final = SourceDep("bytearray_extra_ops.c")
+STR_EXTRA_OPS: Final = SourceDep("str_extra_ops.c")
+VECS_EXTRA_OPS: Final = SourceDep("vecs_extra_ops.c")

micromamba_root/Lib/site-packages/mypyc/ir/func_ir.py

@@ -0,0 +1,484 @@
+"""Intermediate representation of functions."""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Sequence
+from typing import Final
+
+from mypy.nodes import ARG_POS, ArgKind, Block, FuncDef
+from mypyc.common import BITMAP_BITS, JsonDict, bitmap_name, get_id_from_name, short_id_from_name
+from mypyc.ir.ops import (
+    Assign,
+    AssignMulti,
+    BasicBlock,
+    Box,
+    ControlOp,
+    DeserMaps,
+    Float,
+    Integer,
+    LoadAddress,
+    LoadLiteral,
+    Register,
+    TupleSet,
+    Value,
+)
+from mypyc.ir.rtypes import (
+    RType,
+    bitmap_rprimitive,
+    deserialize_type,
+    is_bool_rprimitive,
+    is_none_rprimitive,
+)
+from mypyc.namegen import NameGenerator
+
+
+class RuntimeArg:
+    """Description of a function argument in IR.
+
+    Argument kind is one of ARG_* constants defined in mypy.nodes.
+    """
+
+    def __init__(
+        self, name: str, typ: RType, kind: ArgKind = ARG_POS, pos_only: bool = False
+    ) -> None:
+        self.name = name
+        self.type = typ
+        self.kind = kind
+        self.pos_only = pos_only
+
+    @property
+    def optional(self) -> bool:
+        return self.kind.is_optional()
+
+    def __repr__(self) -> str:
+        return "RuntimeArg(name={}, type={}, optional={!r}, pos_only={!r})".format(
+            self.name, self.type, self.optional, self.pos_only
+        )
+
+    def serialize(self) -> JsonDict:
+        return {
+            "name": self.name,
+            "type": self.type.serialize(),
+            "kind": int(self.kind.value),
+            "pos_only": self.pos_only,
+        }
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> RuntimeArg:
+        return RuntimeArg(
+            data["name"],
+            deserialize_type(data["type"], ctx),
+            ArgKind(data["kind"]),
+            data["pos_only"],
+        )
+
+
+class FuncSignature:
+    """Signature of a function in IR."""
+
+    # TODO: Track if method?
+
+    def __init__(self, args: Sequence[RuntimeArg], ret_type: RType) -> None:
+        self.args = tuple(args)
+        self.ret_type = ret_type
+        # Bitmap arguments are use to mark default values for arguments that
+        # have types with overlapping error values.
+        self.num_bitmap_args = num_bitmap_args(self.args)
+        if self.num_bitmap_args:
+            extra = [
+                RuntimeArg(bitmap_name(i), bitmap_rprimitive, pos_only=True)
+                for i in range(self.num_bitmap_args)
+            ]
+            self.args = self.args + tuple(reversed(extra))
+
+    def real_args(self) -> tuple[RuntimeArg, ...]:
+        """Return arguments without any synthetic bitmap arguments."""
+        if self.num_bitmap_args:
+            return self.args[: -self.num_bitmap_args]
+        return self.args
+
+    def bound_sig(self) -> FuncSignature:
+        if self.num_bitmap_args:
+            return FuncSignature(self.args[1 : -self.num_bitmap_args], self.ret_type)
+        else:
+            return FuncSignature(self.args[1:], self.ret_type)
+
+    def __repr__(self) -> str:
+        return f"FuncSignature(args={self.args!r}, ret={self.ret_type!r})"
+
+    def serialize(self) -> JsonDict:
+        if self.num_bitmap_args:
+            args = self.args[: -self.num_bitmap_args]
+        else:
+            args = self.args
+        return {"args": [t.serialize() for t in args], "ret_type": self.ret_type.serialize()}
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> FuncSignature:
+        return FuncSignature(
+            [RuntimeArg.deserialize(arg, ctx) for arg in data["args"]],
+            deserialize_type(data["ret_type"], ctx),
+        )
+
+
+def num_bitmap_args(args: tuple[RuntimeArg, ...]) -> int:
+    n = 0
+    for arg in args:
+        if arg.type.error_overlap and arg.kind.is_optional():
+            n += 1
+    return (n + (BITMAP_BITS - 1)) // BITMAP_BITS
+
+
+FUNC_NORMAL: Final = 0
+FUNC_STATICMETHOD: Final = 1
+FUNC_CLASSMETHOD: Final = 2
+
+
+class FuncDecl:
+    """Declaration of a function in IR (without body or implementation).
+
+    A function can be a regular module-level function, a method, a
+    static method, a class method, or a property getter/setter.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        class_name: str | None,
+        module_name: str,
+        sig: FuncSignature,
+        kind: int = FUNC_NORMAL,
+        *,
+        is_prop_setter: bool = False,
+        is_prop_getter: bool = False,
+        is_generator: bool = False,
+        is_coroutine: bool = False,
+        implicit: bool = False,
+        internal: bool = False,
+    ) -> None:
+        self.name = name
+        self.class_name = class_name
+        self.module_name = module_name
+        self.sig = sig
+        self.kind = kind
+        self.is_prop_setter = is_prop_setter
+        self.is_prop_getter = is_prop_getter
+        self.is_generator = is_generator
+        self.is_coroutine = is_coroutine
+        if class_name is None:
+            self.bound_sig: FuncSignature | None = None
+        else:
+            if kind == FUNC_STATICMETHOD:
+                self.bound_sig = sig
+            else:
+                self.bound_sig = sig.bound_sig()
+
+        # If True, not present in the mypy AST and must be synthesized during irbuild
+        # Currently only supported for property getters/setters
+        self.implicit = implicit
+
+        # If True, only direct C level calls are supported (no wrapper function)
+        self.internal = internal
+
+        # This is optional because this will be set to the line number when the corresponding
+        # FuncIR is created
+        self._line: int | None = None
+
+    @property
+    def line(self) -> int:
+        assert self._line is not None
+        return self._line
+
+    @line.setter
+    def line(self, line: int) -> None:
+        self._line = line
+
+    @property
+    def id(self) -> str:
+        assert self.line is not None
+        return get_id_from_name(self.name, self.fullname, self.line)
+
+    @staticmethod
+    def compute_shortname(class_name: str | None, name: str) -> str:
+        return class_name + "." + name if class_name else name
+
+    @property
+    def shortname(self) -> str:
+        return FuncDecl.compute_shortname(self.class_name, self.name)
+
+    @property
+    def fullname(self) -> str:
+        return self.module_name + "." + self.shortname
+
+    def cname(self, names: NameGenerator) -> str:
+        partial_name = short_id_from_name(self.name, self.shortname, self._line)
+        return names.private_name(self.module_name, partial_name)
+
+    def serialize(self) -> JsonDict:
+        return {
+            "name": self.name,
+            "class_name": self.class_name,
+            "module_name": self.module_name,
+            "sig": self.sig.serialize(),
+            "kind": self.kind,
+            "is_prop_setter": self.is_prop_setter,
+            "is_prop_getter": self.is_prop_getter,
+            "is_generator": self.is_generator,
+            "is_coroutine": self.is_coroutine,
+            "implicit": self.implicit,
+            "internal": self.internal,
+        }
+
+    # TODO: move this to FuncIR?
+    @staticmethod
+    def get_id_from_json(func_ir: JsonDict) -> str:
+        """Get the id from the serialized FuncIR associated with this FuncDecl"""
+        decl = func_ir["decl"]
+        shortname = FuncDecl.compute_shortname(decl["class_name"], decl["name"])
+        fullname = decl["module_name"] + "." + shortname
+        return get_id_from_name(decl["name"], fullname, func_ir["line"])
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> FuncDecl:
+        return FuncDecl(
+            data["name"],
+            data["class_name"],
+            data["module_name"],
+            FuncSignature.deserialize(data["sig"], ctx),
+            data["kind"],
+            is_prop_setter=data["is_prop_setter"],
+            is_prop_getter=data["is_prop_getter"],
+            is_generator=data["is_generator"],
+            is_coroutine=data["is_coroutine"],
+            implicit=data["implicit"],
+            internal=data["internal"],
+        )
+
+
+class FuncIR:
+    """Intermediate representation of a function with contextual information.
+
+    Unlike FuncDecl, this includes the IR of the body (basic blocks).
+    """
+
+    def __init__(
+        self,
+        decl: FuncDecl,
+        arg_regs: list[Register],
+        blocks: list[BasicBlock],
+        line: int = -1,
+        traceback_name: str | None = None,
+    ) -> None:
+        # Declaration of the function, including the signature
+        self.decl = decl
+        # Registers for all the arguments to the function
+        self.arg_regs = arg_regs
+        # Body of the function
+        self.blocks = blocks
+        self.decl.line = line
+        # The name that should be displayed for tracebacks that
+        # include this function. Function will be omitted from
+        # tracebacks if None.
+        self.traceback_name = traceback_name
+
+    @property
+    def line(self) -> int:
+        return self.decl.line
+
+    @property
+    def args(self) -> Sequence[RuntimeArg]:
+        return self.decl.sig.args
+
+    @property
+    def ret_type(self) -> RType:
+        return self.decl.sig.ret_type
+
+    @property
+    def class_name(self) -> str | None:
+        return self.decl.class_name
+
+    @property
+    def sig(self) -> FuncSignature:
+        return self.decl.sig
+
+    @property
+    def name(self) -> str:
+        return self.decl.name
+
+    @property
+    def fullname(self) -> str:
+        return self.decl.fullname
+
+    @property
+    def id(self) -> str:
+        return self.decl.id
+
+    @property
+    def internal(self) -> bool:
+        return self.decl.internal
+
+    def cname(self, names: NameGenerator) -> str:
+        return self.decl.cname(names)
+
+    def __repr__(self) -> str:
+        if self.class_name:
+            return f"<FuncIR {self.class_name}.{self.name}>"
+        else:
+            return f"<FuncIR {self.name}>"
+
+    def serialize(self) -> JsonDict:
+        # We don't include blocks in the serialized version
+        return {
+            "decl": self.decl.serialize(),
+            "line": self.line,
+            "traceback_name": self.traceback_name,
+        }
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> FuncIR:
+        return FuncIR(
+            FuncDecl.deserialize(data["decl"], ctx), [], [], data["line"], data["traceback_name"]
+        )
+
+
+INVALID_FUNC_DEF: Final = FuncDef("<INVALID_FUNC_DEF>", [], Block([]))
+
+
+def all_values(args: list[Register], blocks: list[BasicBlock]) -> list[Value]:
+    """Return the set of all values that may be initialized in the blocks.
+
+    This omits registers that are only read.
+    """
+    values: list[Value] = list(args)
+    seen_registers = set(args)
+
+    for block in blocks:
+        for op in block.ops:
+            if not isinstance(op, ControlOp):
+                if isinstance(op, (Assign, AssignMulti)):
+                    if op.dest not in seen_registers:
+                        values.append(op.dest)
+                        seen_registers.add(op.dest)
+                elif op.is_void:
+                    continue
+                else:
+                    # If we take the address of a register, it might get initialized.
+                    if (
+                        isinstance(op, LoadAddress)
+                        and isinstance(op.src, Register)
+                        and op.src not in seen_registers
+                    ):
+                        values.append(op.src)
+                        seen_registers.add(op.src)
+                    values.append(op)
+
+    return values
+
+
+def all_values_full(args: list[Register], blocks: list[BasicBlock]) -> list[Value]:
+    """Return set of all values that are initialized or accessed."""
+    values: list[Value] = list(args)
+    seen_registers = set(args)
+
+    for block in blocks:
+        for op in block.ops:
+            for source in op.sources():
+                # Look for uninitialized registers that are accessed. Ignore
+                # non-registers since we don't allow ops outside basic blocks.
+                if isinstance(source, Register) and source not in seen_registers:
+                    values.append(source)
+                    seen_registers.add(source)
+            if not isinstance(op, ControlOp):
+                if isinstance(op, (Assign, AssignMulti)):
+                    if op.dest not in seen_registers:
+                        values.append(op.dest)
+                        seen_registers.add(op.dest)
+                elif op.is_void:
+                    continue
+                else:
+                    values.append(op)
+
+    return values
+
+
+_ARG_KIND_TO_INSPECT: Final = {
+    ArgKind.ARG_POS: inspect.Parameter.POSITIONAL_OR_KEYWORD,
+    ArgKind.ARG_OPT: inspect.Parameter.POSITIONAL_OR_KEYWORD,
+    ArgKind.ARG_STAR: inspect.Parameter.VAR_POSITIONAL,
+    ArgKind.ARG_NAMED: inspect.Parameter.KEYWORD_ONLY,
+    ArgKind.ARG_STAR2: inspect.Parameter.VAR_KEYWORD,
+    ArgKind.ARG_NAMED_OPT: inspect.Parameter.KEYWORD_ONLY,
+}
+
+# Sentinel indicating a value that cannot be represented in a text signature.
+_NOT_REPRESENTABLE = object()
+
+
+def get_text_signature(fn: FuncIR, *, bound: bool = False) -> str | None:
+    """Return a text signature in CPython's internal doc format, or None
+    if the function's signature cannot be represented.
+    """
+    parameters = []
+    mark_self = (fn.class_name is not None) and (fn.decl.kind != FUNC_STATICMETHOD) and not bound
+    sig = fn.decl.bound_sig if bound and fn.decl.bound_sig is not None else fn.decl.sig
+    # Pre-scan for end of positional-only parameters.
+    # This is needed to handle signatures like 'def foo(self, __x)', where mypy
+    # currently sees 'self' as being positional-or-keyword and '__x' as positional-only.
+    pos_only_idx = -1
+    for idx, arg in enumerate(sig.args):
+        if arg.pos_only and arg.kind in (ArgKind.ARG_POS, ArgKind.ARG_OPT):
+            pos_only_idx = idx
+    for idx, arg in enumerate(sig.args):
+        if arg.name.startswith(("__bitmap", "__mypyc")):
+            continue
+        kind = (
+            inspect.Parameter.POSITIONAL_ONLY
+            if idx <= pos_only_idx
+            else _ARG_KIND_TO_INSPECT[arg.kind]
+        )
+        default: object = inspect.Parameter.empty
+        if arg.optional:
+            default = _find_default_argument(arg.name, fn.blocks)
+            if default is _NOT_REPRESENTABLE:
+                # This default argument cannot be represented in a __text_signature__
+                return None
+
+        curr_param = inspect.Parameter(arg.name, kind, default=default)
+        parameters.append(curr_param)
+        if mark_self:
+            # Parameter.__init__/Parameter.replace do not accept $
+            curr_param._name = f"${arg.name}"  # type: ignore[attr-defined]
+            mark_self = False
+    return f"{fn.name}{inspect.Signature(parameters)}"
+
+
+def _find_default_argument(name: str, blocks: list[BasicBlock]) -> object:
+    # Find assignment inserted by gen_arg_defaults. Assumed to be the first assignment.
+    for block in blocks:
+        for op in block.ops:
+            if isinstance(op, Assign) and op.dest.name == name:
+                return _extract_python_literal(op.src)
+    return _NOT_REPRESENTABLE
+
+
+def _extract_python_literal(value: Value) -> object:
+    if isinstance(value, Integer):
+        if is_none_rprimitive(value.type):
+            return None
+        val = value.numeric_value()
+        if is_bool_rprimitive(value.type):
+            return bool(val)
+        return val
+    elif isinstance(value, Float):
+        return value.value
+    elif isinstance(value, LoadLiteral):
+        return value.value
+    elif isinstance(value, Box):
+        return _extract_python_literal(value.src)
+    elif isinstance(value, TupleSet):
+        items = tuple(_extract_python_literal(item) for item in value.items)
+        if any(itm is _NOT_REPRESENTABLE for itm in items):
+            return _NOT_REPRESENTABLE
+        return items
+    return _NOT_REPRESENTABLE

micromamba_root/Lib/site-packages/mypyc/ir/module_ir.py

@@ -0,0 +1,115 @@
+"""Intermediate representation of modules."""
+
+from __future__ import annotations
+
+from mypyc.common import JsonDict
+from mypyc.ir.class_ir import ClassIR
+from mypyc.ir.deps import Capsule, Dependency, SourceDep
+from mypyc.ir.func_ir import FuncDecl, FuncIR
+from mypyc.ir.ops import DeserMaps
+from mypyc.ir.rtypes import RType, deserialize_type
+
+
+class ModuleIR:
+    """Intermediate representation of a module."""
+
+    def __init__(
+        self,
+        fullname: str,
+        imports: list[str],
+        functions: list[FuncIR],
+        classes: list[ClassIR],
+        final_names: list[tuple[str, RType]],
+        type_var_names: list[str],
+    ) -> None:
+        self.fullname = fullname
+        self.imports = imports.copy()
+        self.functions = functions
+        self.classes = classes
+        self.final_names = final_names
+        # Names of C statics used for Python 3.12 type variable objects.
+        # These are only visible in the module that defined them, so no need
+        # to serialize.
+        self.type_var_names = type_var_names
+        # Dependencies needed by the module (such as capsules or source files)
+        self.dependencies: set[Dependency] = set()
+
+    def serialize(self) -> JsonDict:
+        # Serialize dependencies as a list of dicts with type information
+        serialized_deps = []
+        for dep in sorted(self.dependencies, key=lambda d: (type(d).__name__, str(d))):
+            if isinstance(dep, Capsule):
+                serialized_deps.append({"type": "Capsule", "name": dep.name})
+            elif isinstance(dep, SourceDep):
+                serialized_deps.append({"type": "SourceDep", "path": dep.path})
+
+        return {
+            "fullname": self.fullname,
+            "imports": self.imports,
+            "functions": [f.serialize() for f in self.functions],
+            "classes": [c.serialize() for c in self.classes],
+            "final_names": [(k, t.serialize()) for k, t in self.final_names],
+            "dependencies": serialized_deps,
+        }
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> ModuleIR:
+        module = ModuleIR(
+            data["fullname"],
+            data["imports"],
+            [ctx.functions[FuncDecl.get_id_from_json(f)] for f in data["functions"]],
+            [ClassIR.deserialize(c, ctx) for c in data["classes"]],
+            [(k, deserialize_type(t, ctx)) for k, t in data["final_names"]],
+            [],
+        )
+
+        # Deserialize dependencies
+        deps: set[Dependency] = set()
+        for dep_dict in data["dependencies"]:
+            if dep_dict["type"] == "Capsule":
+                deps.add(Capsule(dep_dict["name"]))
+            elif dep_dict["type"] == "SourceDep":
+                deps.add(SourceDep(dep_dict["path"]))
+        module.dependencies = deps
+
+        return module
+
+
+def deserialize_modules(data: dict[str, JsonDict], ctx: DeserMaps) -> dict[str, ModuleIR]:
+    """Deserialize a collection of modules.
+
+    The modules can contain dependencies on each other.
+
+    Arguments:
+        data: A dict containing the modules to deserialize.
+        ctx: The deserialization maps to use and to populate.
+             They are populated with information from the deserialized
+             modules and as a precondition must have been populated by
+             deserializing any dependencies of the modules being deserialized
+             (outside of dependencies between the modules themselves).
+
+    Returns a map containing the deserialized modules.
+    """
+    for mod in data.values():
+        # First create ClassIRs for every class so that we can construct types and whatnot
+        for cls in mod["classes"]:
+            ir = ClassIR(cls["name"], cls["module_name"])
+            assert ir.fullname not in ctx.classes, "Class %s already in map" % ir.fullname
+            ctx.classes[ir.fullname] = ir
+
+    for mod in data.values():
+        # Then deserialize all of the functions so that methods are available
+        # to the class deserialization.
+        for method in mod["functions"]:
+            func = FuncIR.deserialize(method, ctx)
+            assert func.decl.id not in ctx.functions, (
+                "Method %s already in map" % func.decl.fullname
+            )
+            ctx.functions[func.decl.id] = func
+
+    return {k: ModuleIR.deserialize(v, ctx) for k, v in data.items()}
+
+
+# ModulesIRs should also always be an *OrderedDict*, but if we
+# declared it that way we would need to put it in quotes everywhere...
+ModuleIRs = dict[str, ModuleIR]

micromamba_root/Lib/site-packages/mypyc/ir/ops.py

@@ -0,0 +1,2106 @@
+"""Low-level opcodes for compiler intermediate representation (IR).
+
+Opcodes operate on abstract values (Value) in a register machine. Each
+value has a type (RType). A value can hold various things, such as:
+
+- local variables or temporaries (Register)
+- intermediate values of expressions (RegisterOp subclasses)
+- condition flags (true/false)
+- literals (integer literals, True, False, etc.)
+
+NOTE: As a convention, we don't create subclasses of concrete Value/Op
+      subclasses (e.g. you shouldn't define a subclass of Integer, which
+      is a concrete class).
+
+      If you want to introduce a variant of an existing class, you'd
+      typically add an attribute (e.g. a flag) to an existing concrete
+      class to enable the new behavior. Sometimes adding a new abstract
+      base class is also an option, or just creating a new subclass
+      without any inheritance relationship (some duplication of code
+      is preferred over introducing complex implementation inheritance).
+
+      This makes it possible to use isinstance(x, <concrete Value
+      subclass>) checks without worrying about potential subclasses.
+"""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Final, Generic, NamedTuple, TypeVar, final
+
+from mypy_extensions import trait
+
+from mypyc.common import PROPSET_PREFIX
+from mypyc.ir.deps import Dependency
+from mypyc.ir.rtypes import (
+    RArray,
+    RInstance,
+    RStruct,
+    RTuple,
+    RType,
+    RUnion,
+    RVec,
+    RVoid,
+    bit_rprimitive,
+    bool_rprimitive,
+    cstring_rprimitive,
+    float_rprimitive,
+    int_rprimitive,
+    is_bool_or_bit_rprimitive,
+    is_fixed_width_rtype,
+    is_int_rprimitive,
+    is_none_rprimitive,
+    is_pointer_rprimitive,
+    is_short_int_rprimitive,
+    object_rprimitive,
+    pointer_rprimitive,
+    short_int_rprimitive,
+    void_rtype,
+)
+
+if TYPE_CHECKING:
+    from mypyc.codegen.literals import LiteralValue
+    from mypyc.ir.class_ir import ClassIR
+    from mypyc.ir.func_ir import FuncDecl, FuncIR
+
+T = TypeVar("T")
+
+
+@final
+class BasicBlock:
+    """IR basic block.
+
+    Contains a sequence of Ops and ends with a ControlOp (Goto,
+    Branch, Return or Unreachable). Only the last op can be a
+    ControlOp.
+
+    All generated Ops live in basic blocks. Basic blocks determine the
+    order of evaluation and control flow within a function. A basic
+    block is always associated with a single function/method (FuncIR).
+
+    When building the IR, ops that raise exceptions can be included in
+    the middle of a basic block, but the exceptions aren't checked.
+    Afterwards we perform a transform that inserts explicit checks for
+    all error conditions and splits basic blocks accordingly to preserve
+    the invariant that a jump, branch or return can only ever appear
+    as the final op in a block. Manually inserting error checking ops
+    would be boring and error-prone.
+
+    BasicBlocks have an error_handler attribute that determines where
+    to jump if an error occurs. If none is specified, an error will
+    propagate up out of the function. This is compiled away by the
+    `exceptions` module.
+
+    Block labels are used for pretty printing and emitting C code, and
+    get filled in by those passes.
+
+    Ops that may terminate the program aren't treated as exits.
+    """
+
+    def __init__(self, label: int = -1) -> None:
+        self.label = label
+        self.ops: list[Op] = []
+        self.error_handler: BasicBlock | None = None
+        self.referenced = False
+
+    @property
+    def terminated(self) -> bool:
+        """Does the block end with a jump, branch or return?
+
+        This should always be true after the basic block has been fully built, but
+        this is false during construction.
+        """
+        return bool(self.ops) and isinstance(self.ops[-1], ControlOp)
+
+    @property
+    def terminator(self) -> ControlOp:
+        """The terminator operation of the block."""
+        assert bool(self.ops) and isinstance(self.ops[-1], ControlOp)
+        return self.ops[-1]
+
+
+# Never generates an exception
+ERR_NEVER: Final = 0
+# Generates magic value (c_error_value) based on target RType on exception
+ERR_MAGIC: Final = 1
+# Generates false (bool) on exception
+ERR_FALSE: Final = 2
+# Always fails
+ERR_ALWAYS: Final = 3
+# Like ERR_MAGIC, but the magic return overlaps with a possible return value, and
+# an extra PyErr_Occurred() check is also required
+ERR_MAGIC_OVERLAPPING: Final = 4
+
+# Hack: using this line number for an op will suppress it in tracebacks
+NO_TRACEBACK_LINE_NO = -10000
+
+
+class Value:
+    """Abstract base class for all IR values.
+
+    These include references to registers, literals, and all
+    operations (Ops), such as assignments, calls and branches.
+
+    Values are often used as inputs of Ops. Register can be used as an
+    assignment target.
+
+    A Value is part of the IR being compiled if it's included in a BasicBlock
+    that is reachable from a FuncIR (i.e., is part of a function).
+
+    See also: Op is a subclass of Value that is the base class of all
+    operations.
+    """
+
+    # Source line number (-1 for no/unknown line)
+    line = -1
+    # Type of the value or the result of the operation
+    type: RType = void_rtype
+    is_borrowed = False
+
+    @property
+    def is_void(self) -> bool:
+        return isinstance(self.type, RVoid)
+
+
+@final
+class Register(Value):
+    """A Register holds a value of a specific type, and it can be read and mutated.
+
+    A Register is always local to a function. Each local variable maps
+    to a Register, and they are also used for some (but not all)
+    temporary values.
+
+    Note that the term 'register' is overloaded and is sometimes used
+    to refer to arbitrary Values (for example, in RegisterOp).
+    """
+
+    def __init__(self, type: RType, name: str = "", is_arg: bool = False, line: int = -1) -> None:
+        self.type = type
+        self.name = name
+        self.is_arg = is_arg
+        self.is_borrowed = is_arg
+        self.line = line
+
+    @property
+    def is_void(self) -> bool:
+        return False
+
+    def __repr__(self) -> str:
+        return f"<Register {self.name!r} at {hex(id(self))}>"
+
+
+@final
+class Integer(Value):
+    """Short integer literal.
+
+    Integer literals are treated as constant values and are generally
+    not included in data flow analyses and such, unlike Register and
+    Op subclasses.
+
+    Integer can represent multiple types:
+
+     * Short tagged integers (short_int_primitive type; the tag bit is clear)
+     * Ordinary fixed-width integers (e.g., int32_rprimitive)
+     * Values of other unboxed primitive types that are represented as integers
+       (none_rprimitive, bool_rprimitive)
+     * Null pointers (value 0) of various types, including object_rprimitive
+    """
+
+    def __init__(self, value: int, rtype: RType = short_int_rprimitive, line: int = -1) -> None:
+        if is_short_int_rprimitive(rtype) or is_int_rprimitive(rtype):
+            self.value = value * 2
+        else:
+            self.value = value
+        self.type = rtype
+        self.line = line
+
+    def numeric_value(self) -> int:
+        if is_short_int_rprimitive(self.type) or is_int_rprimitive(self.type):
+            return self.value // 2
+        return self.value
+
+
+@final
+class Float(Value):
+    """Float literal.
+
+    Floating point literals are treated as constant values and are generally
+    not included in data flow analyses and such, unlike Register and
+    Op subclasses.
+    """
+
+    def __init__(self, value: float, line: int = -1) -> None:
+        self.value = value
+        self.type = float_rprimitive
+        self.line = line
+
+
+@final
+class CString(Value):
+    """C string literal (zero-terminated).
+
+    You can also include zero values in the value, but then you'll need to track
+    the length of the string separately.
+    """
+
+    def __init__(self, value: bytes, line: int = -1) -> None:
+        self.value = value
+        self.type = cstring_rprimitive
+        self.line = line
+
+
+@final
+class Undef(Value):
+    """An undefined value.
+
+    Use Undef() as the initial value followed by one or more SetElement
+    ops to initialize a struct. Pseudocode example:
+
+      r0 = set_element undef MyStruct, "field1", f1
+      r1 = set_element r0, "field2", f2
+      # r1 now has new struct value with two fields set
+
+    Warning: Always initialize undefined values before using them,
+    as otherwise the values are garbage. You shouldn't expect that
+    undefined values are zeroed, in particular.
+    """
+
+    def __init__(self, rtype: RType) -> None:
+        self.type = rtype
+
+
+class Op(Value):
+    """Abstract base class for all IR operations.
+
+    Each operation must be stored in a BasicBlock (in 'ops') to be
+    active in the IR. This is different from non-Op values, including
+    Register and Integer, where a reference from an active Op is
+    sufficient to be considered active.
+
+    In well-formed IR an active Op has no references to inactive ops
+    or ops used in another function.
+    """
+
+    def __init__(self, line: int) -> None:
+        self.line = line
+
+    def can_raise(self) -> bool:
+        # Override this is if Op may raise an exception. Note that currently the fact that
+        # only RegisterOps may raise an exception in hard coded in some places.
+        return False
+
+    @abstractmethod
+    def sources(self) -> list[Value]:
+        """All the values the op may read."""
+
+    @abstractmethod
+    def set_sources(self, new: list[Value]) -> None:
+        """Rewrite the sources of an op"""
+
+    def stolen(self) -> list[Value]:
+        """Return arguments that have a reference count stolen by this op"""
+        return []
+
+    def unique_sources(self) -> list[Value]:
+        result: list[Value] = []
+        for reg in self.sources():
+            if reg not in result:
+                result.append(reg)
+        return result
+
+    @abstractmethod
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        pass
+
+
+class BaseAssign(Op):
+    """Abstract base class for ops that assign to a register."""
+
+    def __init__(self, dest: Register, line: int = -1) -> None:
+        super().__init__(line)
+        self.dest = dest
+
+
+@final
+class Assign(BaseAssign):
+    """Assign a value to a Register (dest = src)."""
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, dest: Register, src: Value, line: int = -1) -> None:
+        super().__init__(dest, line)
+        self.src = src
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def stolen(self) -> list[Value]:
+        if not self.dest.type.is_refcounted:
+            return []
+        return [self.src]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_assign(self)
+
+
+@final
+class AssignMulti(BaseAssign):
+    """Assign multiple values to a Register (dest = src1, src2, ...).
+
+    This is used to initialize RArray values. It's provided to avoid
+    very verbose IR for common vectorcall operations.
+
+    Note that this interacts atypically with reference counting. We
+    assume that each RArray register is initialized exactly once
+    with this op.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, dest: Register, src: list[Value], line: int = -1) -> None:
+        super().__init__(dest, line)
+        assert src
+        assert isinstance(dest.type, RArray)
+        assert dest.type.length == len(src)
+        self.src = src
+
+    def sources(self) -> list[Value]:
+        return self.src.copy()
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.src = new[:]
+
+    def stolen(self) -> list[Value]:
+        return []
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_assign_multi(self)
+
+
+class ControlOp(Op):
+    """Abstract base class for control flow operations."""
+
+    def targets(self) -> Sequence[BasicBlock]:
+        """Get all basic block targets of the control operation."""
+        return ()
+
+    def set_target(self, i: int, new: BasicBlock) -> None:
+        """Update a basic block target."""
+        raise AssertionError(f"Invalid set_target({self}, {i})")
+
+
+@final
+class Goto(ControlOp):
+    """Unconditional jump."""
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, label: BasicBlock, line: int = -1) -> None:
+        super().__init__(line)
+        self.label = label
+
+    def targets(self) -> Sequence[BasicBlock]:
+        return (self.label,)
+
+    def set_target(self, i: int, new: BasicBlock) -> None:
+        assert i == 0
+        self.label = new
+
+    def __repr__(self) -> str:
+        return "<Goto %s>" % self.label.label
+
+    def sources(self) -> list[Value]:
+        return []
+
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_goto(self)
+
+
+@final
+class Branch(ControlOp):
+    """Branch based on a value.
+
+    If op is BOOL, branch based on a bit/bool value:
+       if [not] r1 goto L1 else goto L2
+
+    If op is IS_ERROR, branch based on whether there is an error value:
+       if [not] is_error(r1) goto L1 else goto L2
+    """
+
+    # Branch ops never raise an exception.
+    error_kind = ERR_NEVER
+
+    BOOL: Final = 100
+    IS_ERROR: Final = 101
+
+    def __init__(
+        self,
+        value: Value,
+        true_label: BasicBlock,
+        false_label: BasicBlock,
+        op: int,
+        line: int = -1,
+        *,
+        rare: bool = False,
+    ) -> None:
+        super().__init__(line)
+        # Target value being checked
+        self.value = value
+        # Branch here if the condition is true
+        self.true = true_label
+        # Branch here if the condition is false
+        self.false = false_label
+        # Branch.BOOL (boolean check) or Branch.IS_ERROR (error value check)
+        self.op = op
+        # If True, the condition is negated
+        self.negated = False
+        # If not None, the true label should generate a traceback entry (func name, line number)
+        self.traceback_entry: tuple[str, int] | None = None
+        # If True, we expect to usually take the false branch (for optimization purposes);
+        # this is implicitly treated as true if there is a traceback entry
+        self.rare = rare
+
+    def targets(self) -> Sequence[BasicBlock]:
+        return (self.true, self.false)
+
+    def set_target(self, i: int, new: BasicBlock) -> None:
+        assert i == 0 or i == 1
+        if i == 0:
+            self.true = new
+        else:
+            self.false = new
+
+    def sources(self) -> list[Value]:
+        return [self.value]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.value,) = new
+
+    def invert(self) -> None:
+        self.negated = not self.negated
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_branch(self)
+
+
+@final
+class Return(ControlOp):
+    """Return a value from a function."""
+
+    error_kind = ERR_NEVER
+
+    def __init__(
+        self, value: Value, line: int = -1, *, yield_target: BasicBlock | None = None
+    ) -> None:
+        super().__init__(line)
+        self.value = value
+        # If this return is created by a yield, keep track of the next
+        # basic block. This doesn't affect the code we generate but
+        # can feed into analysis that need to understand the
+        # *original* CFG.
+        self.yield_target = yield_target
+
+    def sources(self) -> list[Value]:
+        return [self.value]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.value,) = new
+
+    def stolen(self) -> list[Value]:
+        return [self.value]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_return(self)
+
+
+@final
+class Unreachable(ControlOp):
+    """Mark the end of basic block as unreachable.
+
+    This is sometimes necessary when the end of a basic block is never
+    reached. This can also be explicitly added to the end of non-None
+    returning functions (in None-returning function we can just return
+    None).
+
+    Mypy statically guarantees that the end of the function is not
+    unreachable if there is not a return statement.
+
+    This prevents the block formatter from being confused due to lack
+    of a leave and also leaves a nifty note in the IR. It is not
+    generally processed by visitors.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, line: int = -1) -> None:
+        super().__init__(line)
+
+    def sources(self) -> list[Value]:
+        return []
+
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_unreachable(self)
+
+
+class RegisterOp(Op):
+    """Abstract base class for operations that can be written as r1 = f(r2, ..., rn).
+
+    Takes some values, performs an operation, and generates an output
+    (unless the 'type' attribute is void_rtype, which is the default).
+    Other ops can refer to the result of the Op by referring to the Op
+    instance. This doesn't do any explicit control flow, but can raise an
+    error.
+
+    Note that the operands can be arbitrary Values, not just Register
+    instances, even though the naming may suggest otherwise.
+    """
+
+    error_kind = -1  # Can this raise exception and how is it signalled; one of ERR_*
+
+    _type: RType | None = None
+
+    def __init__(self, line: int) -> None:
+        super().__init__(line)
+        assert self.error_kind != -1, "error_kind not defined"
+
+    def can_raise(self) -> bool:
+        return self.error_kind != ERR_NEVER
+
+
+@final
+class IncRef(RegisterOp):
+    """Increase reference count (inc_ref src)."""
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, line: int = -1) -> None:
+        assert src.type.is_refcounted
+        super().__init__(line)
+        self.src = src
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_inc_ref(self)
+
+
+@final
+class DecRef(RegisterOp):
+    """Decrease reference count and free object if zero (dec_ref src).
+
+    The is_xdec flag says to use an XDECREF, which checks if the
+    pointer is NULL first.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, is_xdec: bool = False, line: int = -1) -> None:
+        assert src.type.is_refcounted
+        super().__init__(line)
+        self.src = src
+        self.is_xdec = is_xdec
+
+    def __repr__(self) -> str:
+        return "<{}DecRef {!r}>".format("X" if self.is_xdec else "", self.src)
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_dec_ref(self)
+
+
+@final
+class Call(RegisterOp):
+    """Native call f(arg, ...).
+
+    The call target can be a module-level function or a class.
+    """
+
+    def __init__(self, fn: FuncDecl, args: Sequence[Value], line: int) -> None:
+        self.fn = fn
+        self.args = list(args)
+        assert len(self.args) == len(fn.sig.args)
+        self.type = fn.sig.ret_type
+        ret_type = fn.sig.ret_type
+        if not ret_type.error_overlap:
+            self.error_kind = ERR_MAGIC
+        else:
+            self.error_kind = ERR_MAGIC_OVERLAPPING
+        super().__init__(line)
+
+    def sources(self) -> list[Value]:
+        return list(self.args.copy())
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.args = new[:]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_call(self)
+
+
+@final
+class MethodCall(RegisterOp):
+    """Native method call obj.method(arg, ...)"""
+
+    def __init__(self, obj: Value, method: str, args: list[Value], line: int = -1) -> None:
+        self.obj = obj
+        self.method = method
+        self.args = args
+        assert isinstance(obj.type, RInstance), "Methods can only be called on instances"
+        self.receiver_type = obj.type
+        method_ir = self.receiver_type.class_ir.method_sig(method)
+        assert method_ir is not None, "{} doesn't have method {}".format(
+            self.receiver_type.name, method
+        )
+        ret_type = method_ir.ret_type
+        self.type = ret_type
+        if not ret_type.error_overlap:
+            self.error_kind = ERR_MAGIC
+        else:
+            self.error_kind = ERR_MAGIC_OVERLAPPING
+        super().__init__(line)
+
+    def sources(self) -> list[Value]:
+        return self.args.copy() + [self.obj]
+
+    def set_sources(self, new: list[Value]) -> None:
+        *self.args, self.obj = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_method_call(self)
+
+
+@final
+class PrimitiveDescription:
+    """Description of a primitive op.
+
+    Primitives get lowered into lower-level ops before code generation.
+
+    If c_function_name is provided, a primitive will be lowered into a CallC op.
+    Otherwise, custom logic will need to be implemented to transform the
+    primitive into lower-level ops.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        arg_types: list[RType],
+        return_type: RType,  # TODO: What about generic?
+        var_arg_type: RType | None,
+        truncated_type: RType | None,
+        c_function_name: str | None,
+        error_kind: int,
+        steals: StealsDescription,
+        is_borrowed: bool,
+        ordering: list[int] | None,
+        extra_int_constants: list[tuple[int, RType]],
+        priority: int,
+        is_pure: bool,
+        experimental: bool,
+        dependencies: list[Dependency] | None,
+    ) -> None:
+        # Each primitive much have a distinct name, but otherwise they are arbitrary.
+        self.name: Final = name
+        self.arg_types: Final = arg_types
+        self.return_type: Final = return_type
+        self.var_arg_type: Final = var_arg_type
+        self.truncated_type: Final = truncated_type
+        # If non-None, this will map to a call of a C helper function; if None,
+        # there must be a custom handler function that gets invoked during the lowering
+        # pass to generate low-level IR for the primitive (in the mypyc.lower package)
+        self.c_function_name: Final = c_function_name
+        self.error_kind: Final = error_kind
+        self.steals: Final = steals
+        self.is_borrowed: Final = is_borrowed
+        self.ordering: Final = ordering
+        self.extra_int_constants: Final = extra_int_constants
+        self.priority: Final = priority
+        # Pure primitives have no side effects, take immutable arguments, and
+        # never fail. They support additional optimizations.
+        self.is_pure: Final = is_pure
+        if is_pure:
+            assert error_kind == ERR_NEVER
+        # Experimental primitives are not used unless mypyc experimental features are
+        # explicitly enabled
+        self.experimental = experimental
+        # Dependencies for the primitive, such as a capsule that needs to imported
+        # and configured to call the primitive.
+        self.dependencies = dependencies
+        # Native integer types such as u8 can cause ambiguity in primitive
+        # matching, since these are assignable to plain int *and* vice versa.
+        # If this flag is set, the primitive has native integer types and must
+        # be matched using more complex rules.
+        self.is_ambiguous = any(has_fixed_width_int(t) for t in arg_types)
+
+    def __repr__(self) -> str:
+        return f"<PrimitiveDescription {self.name!r}: {self.arg_types}>"
+
+
+def has_fixed_width_int(t: RType) -> bool:
+    if isinstance(t, RTuple):
+        return any(has_fixed_width_int(t) for t in t.types)
+    elif isinstance(t, RUnion):
+        return any(has_fixed_width_int(t) for t in t.items)
+    return is_fixed_width_rtype(t)
+
+
+@final
+class PrimitiveOp(RegisterOp):
+    """A higher-level primitive operation.
+
+    Some of these have special compiler support. These will be lowered
+    (transformed) into lower-level IR ops before code generation, and after
+    reference counting op insertion. Others will be transformed into CallC
+    ops.
+
+    Tagged integer equality is a typical primitive op with non-trivial
+    lowering. It gets transformed into a tag check, followed by different
+    code paths for short and long representations.
+    """
+
+    def __init__(self, args: list[Value], desc: PrimitiveDescription, line: int = -1) -> None:
+        self.error_kind = desc.error_kind
+        super().__init__(line)
+        self.args = args
+        self.type = desc.return_type
+        self.desc = desc
+
+    def sources(self) -> list[Value]:
+        return self.args
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.args = new[:]
+
+    def stolen(self) -> list[Value]:
+        steals = self.desc.steals
+        if isinstance(steals, list):
+            assert len(steals) == len(self.args)
+            return [arg for arg, steal in zip(self.args, steals) if steal]
+        else:
+            return [] if not steals else self.sources()
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_primitive_op(self)
+
+
+@final
+class LoadErrorValue(RegisterOp):
+    """Load an error value.
+
+    Each type has one reserved value that signals an error (exception). This
+    loads the error value for a specific type.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(
+        self, rtype: RType, line: int = -1, is_borrowed: bool = False, undefines: bool = False
+    ) -> None:
+        super().__init__(line)
+        self.type = rtype
+        self.is_borrowed = is_borrowed
+        # Undefines is true if this should viewed by the definedness
+        # analysis pass as making the register it is assigned to
+        # undefined (and thus checks should be added on uses).
+        self.undefines = undefines
+
+    def sources(self) -> list[Value]:
+        return []
+
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_load_error_value(self)
+
+
+@final
+class LoadLiteral(RegisterOp):
+    """Load a Python literal object (dest = 'foo' / b'foo' / ...).
+
+    This is used to load a static PyObject * value corresponding to
+    a literal of one of the supported types.
+
+    Tuple / frozenset literals must contain only valid literal values as items.
+
+    NOTE: You can use this to load boxed (Python) int objects. Use
+          Integer to load unboxed, tagged integers or fixed-width,
+          low-level integers.
+
+          For int literals, both int_rprimitive (CPyTagged) and
+          object_primitive (PyObject *) are supported as rtype. However,
+          when using int_rprimitive, the value must *not* be small enough
+          to fit in an unboxed integer.
+    """
+
+    error_kind = ERR_NEVER
+    is_borrowed = True
+
+    def __init__(self, value: LiteralValue, rtype: RType, line: int = -1) -> None:
+        super().__init__(line)
+        self.value = value
+        self.type = rtype
+
+    def sources(self) -> list[Value]:
+        return []
+
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_load_literal(self)
+
+
+@final
+class GetAttr(RegisterOp):
+    """obj.attr (for a native object)"""
+
+    error_kind = ERR_MAGIC
+
+    def __init__(
+        self,
+        obj: Value,
+        attr: str,
+        line: int,
+        *,
+        borrow: bool = False,
+        allow_error_value: bool = False,
+    ) -> None:
+        super().__init__(line)
+        self.obj = obj
+        self.attr = attr
+        self.allow_error_value = allow_error_value
+        assert isinstance(obj.type, RInstance), "Attribute access not supported: %s" % obj.type
+        self.class_type = obj.type
+        attr_type = obj.type.attr_type(attr)
+        self.type = attr_type
+        if allow_error_value:
+            self.error_kind = ERR_NEVER
+        elif attr_type.error_overlap:
+            self.error_kind = ERR_MAGIC_OVERLAPPING
+        self.is_borrowed = borrow and attr_type.is_refcounted
+
+    def sources(self) -> list[Value]:
+        return [self.obj]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.obj,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_get_attr(self)
+
+
+@final
+class SetAttr(RegisterOp):
+    """obj.attr = src (for a native object)"""
+
+    error_kind = ERR_FALSE
+
+    def __init__(self, obj: Value, attr: str, src: Value, line: int) -> None:
+        super().__init__(line)
+        self.obj = obj
+        self.attr = attr
+        self.src = src
+        assert isinstance(obj.type, RInstance), "Attribute access not supported: %s" % obj.type
+        self.class_type = obj.type
+        self.type = bool_rprimitive
+        # If True, we can safely assume that the attribute is previously undefined
+        # and we don't use a setter
+        self.is_init = False
+
+        cl = self.class_type.class_ir
+        is_propset = False
+        for ir in cl.mro:
+            propset = ir.method_decls.get(PROPSET_PREFIX + attr)
+            if propset is not None:
+                is_propset = not propset.implicit
+                break
+        # If True, this op represents calling a property setter.
+        self.is_propset = is_propset
+
+    def mark_as_initializer(self) -> None:
+        self.is_init = True
+        self.error_kind = ERR_NEVER
+        self.type = void_rtype
+
+    def sources(self) -> list[Value]:
+        return [self.obj, self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.obj, self.src = new
+
+    def stolen(self) -> list[Value]:
+        # The property setter method increfs the passed value so don't treat it as a steal
+        # to avoid leaking.
+        if self.is_propset:
+            return []
+        return [self.src]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_set_attr(self)
+
+
+# Default name space for statics, variables
+NAMESPACE_STATIC: Final = "static"
+
+# Static namespace for pointers to native type objects
+NAMESPACE_TYPE: Final = "type"
+
+# Namespace for modules
+NAMESPACE_MODULE: Final = "module"
+
+# Namespace for Python 3.12 type variable objects (implicitly created TypeVar instances, etc.)
+NAMESPACE_TYPE_VAR: Final = "typevar"
+
+
+@final
+class LoadStatic(RegisterOp):
+    """Load a static name (name :: static).
+
+    Load a C static variable/pointer. The namespace for statics is shared
+    for the entire compilation group. You can optionally provide a module
+    name and a sub-namespace identifier for additional namespacing to avoid
+    name conflicts. The static namespace does not overlap with other C names,
+    since the final C name will get a prefix, so conflicts only must be
+    avoided with other statics.
+    """
+
+    error_kind = ERR_NEVER
+    is_borrowed = True
+
+    def __init__(
+        self,
+        type: RType,
+        identifier: str,
+        module_name: str | None = None,
+        namespace: str = NAMESPACE_STATIC,
+        line: int = -1,
+        ann: object = None,
+    ) -> None:
+        super().__init__(line)
+        self.identifier = identifier
+        self.module_name = module_name
+        self.namespace = namespace
+        self.type = type
+        self.ann = ann  # An object to pretty print with the load
+
+    def sources(self) -> list[Value]:
+        return []
+
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_load_static(self)
+
+
+@final
+class InitStatic(RegisterOp):
+    """static = value :: static
+
+    Initialize a C static variable/pointer. See everything in LoadStatic.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(
+        self,
+        value: Value,
+        identifier: str,
+        module_name: str | None = None,
+        namespace: str = NAMESPACE_STATIC,
+        line: int = -1,
+    ) -> None:
+        super().__init__(line)
+        self.identifier = identifier
+        self.module_name = module_name
+        self.namespace = namespace
+        self.value = value
+
+    def sources(self) -> list[Value]:
+        return [self.value]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.value,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_init_static(self)
+
+
+@final
+class TupleSet(RegisterOp):
+    """dest = (reg, ...) (for fixed-length tuple)"""
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, items: list[Value], line: int) -> None:
+        super().__init__(line)
+        self.items = items
+        # Don't keep track of the fact that an int is short after it
+        # is put into a tuple, since we don't properly implement
+        # runtime subtyping for tuples.
+        self.tuple_type = RTuple(
+            [
+                arg.type if not is_short_int_rprimitive(arg.type) else int_rprimitive
+                for arg in items
+            ]
+        )
+        self.type = self.tuple_type
+
+    def sources(self) -> list[Value]:
+        return self.items.copy()
+
+    def stolen(self) -> list[Value]:
+        return self.items.copy()
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.items = new[:]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_tuple_set(self)
+
+
+@final
+class TupleGet(RegisterOp):
+    """Get item of a fixed-length tuple (src[index])."""
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, index: int, line: int = -1, *, borrow: bool = False) -> None:
+        super().__init__(line)
+        assert isinstance(
+            src.type, RTuple
+        ), f"TupleGet only operates on tuples, not {type(src.type).__name__}"
+        src_len = len(src.type.types)
+        self.src = src
+        self.index = index
+        if index < 0:
+            self.index += src_len
+        assert (
+            self.index <= src_len - 1
+        ), f"Index out of range.\nsource type: {src.type}\nindex: {index}"
+        self.type = src.type.types[index]
+        self.is_borrowed = borrow
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_tuple_get(self)
+
+
+@final
+class Cast(RegisterOp):
+    """cast(type, src)
+
+    Perform a runtime type check (no representation or value conversion).
+
+    DO NOT increment reference counts.
+    """
+
+    error_kind = ERR_MAGIC
+
+    def __init__(
+        self, src: Value, typ: RType, line: int, *, borrow: bool = False, unchecked: bool = False
+    ) -> None:
+        super().__init__(line)
+        self.src = src
+        self.type = typ
+        # If true, don't incref the result.
+        self.is_borrowed = borrow
+        # If true, don't perform a runtime type check (only changes the static type of
+        # the operand). Used when we know that the cast will always succeed.
+        self.is_unchecked = unchecked
+        if unchecked:
+            self.error_kind = ERR_NEVER
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def stolen(self) -> list[Value]:
+        if self.is_borrowed:
+            return []
+        return [self.src]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_cast(self)
+
+
+@final
+class Box(RegisterOp):
+    """box(type, src)
+
+    This converts from a potentially unboxed representation to a straight Python object.
+    Only supported for types with an unboxed representation.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, line: int = -1) -> None:
+        super().__init__(line)
+        self.src = src
+        self.type = object_rprimitive
+        # When we box None and bool values, we produce a borrowed result
+        if is_none_rprimitive(self.src.type) or is_bool_or_bit_rprimitive(self.src.type):
+            self.is_borrowed = True
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def stolen(self) -> list[Value]:
+        return [self.src]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_box(self)
+
+
+@final
+class Unbox(RegisterOp):
+    """unbox(type, src)
+
+    This is similar to a cast, but it also changes to a (potentially) unboxed runtime
+    representation. Only supported for types with an unboxed representation.
+    """
+
+    def __init__(self, src: Value, typ: RType, line: int) -> None:
+        self.src = src
+        self.type = typ
+        if not typ.error_overlap:
+            self.error_kind = ERR_MAGIC
+        else:
+            self.error_kind = ERR_MAGIC_OVERLAPPING
+        super().__init__(line)
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_unbox(self)
+
+
+@final
+class RaiseStandardError(RegisterOp):
+    """Raise built-in exception with an optional error string.
+
+    We have a separate opcode for this for convenience and to
+    generate smaller, more idiomatic C code.
+    """
+
+    # TODO: Make it more explicit at IR level that this always raises
+
+    error_kind = ERR_FALSE
+
+    VALUE_ERROR: Final = "ValueError"
+    ASSERTION_ERROR: Final = "AssertionError"
+    STOP_ITERATION: Final = "StopIteration"
+    UNBOUND_LOCAL_ERROR: Final = "UnboundLocalError"
+    RUNTIME_ERROR: Final = "RuntimeError"
+    NAME_ERROR: Final = "NameError"
+    ZERO_DIVISION_ERROR: Final = "ZeroDivisionError"
+    INDEX_ERROR: Final = "IndexError"
+
+    def __init__(self, class_name: str, value: str | Value | None, line: int) -> None:
+        super().__init__(line)
+        self.class_name = class_name
+        self.value = value
+        self.type = bool_rprimitive
+
+    def sources(self) -> list[Value]:
+        return []
+
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_raise_standard_error(self)
+
+
+# True steals all arguments, False steals none, a list steals those in matching positions
+StealsDescription = bool | list[bool]
+
+
+@final
+class CallC(RegisterOp):
+    """result = function(arg0, arg1, ...)
+
+    Call a C function that is not a compiled/native function (for
+    example, a Python C API function). Use Call to call native
+    functions.
+    """
+
+    def __init__(
+        self,
+        function_name: str,
+        args: list[Value],
+        ret_type: RType,
+        steals: StealsDescription,
+        is_borrowed: bool,
+        error_kind: int,
+        line: int,
+        var_arg_idx: int = -1,
+        *,
+        is_pure: bool = False,
+        returns_null: bool = False,
+        dependencies: list[Dependency] | None = None,
+    ) -> None:
+        self.error_kind = error_kind
+        super().__init__(line)
+        self.function_name = function_name
+        self.args = args
+        self.type = ret_type
+        self.steals = steals
+        self.is_borrowed = is_borrowed
+        # The position of the first variable argument in args (if >= 0)
+        self.var_arg_idx = var_arg_idx
+        # Is the function pure? Pure functions have no side effects
+        # and all the arguments are immutable. Pure functions support
+        # additional optimizations. Pure functions never fail.
+        self.is_pure = is_pure
+        # The function might return a null value that does not indicate
+        # an error.
+        self.returns_null = returns_null
+        # Dependencies (such as capsules) that must be imported and initialized before
+        # calling this function (used for C functions exported from librt).
+        self.dependencies = dependencies
+        if is_pure or returns_null:
+            assert error_kind == ERR_NEVER
+
+    def sources(self) -> list[Value]:
+        return self.args[:]
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.args = new[:]
+
+    def stolen(self) -> list[Value]:
+        if isinstance(self.steals, list):
+            assert len(self.steals) == len(self.args)
+            return [arg for arg, steal in zip(self.args, self.steals) if steal]
+        else:
+            return [] if not self.steals else self.sources()
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_call_c(self)
+
+
+@final
+class Truncate(RegisterOp):
+    """result = truncate src from src_type to dst_type
+
+    Truncate a value from type with more bits to type with less bits.
+
+    dst_type and src_type can be native integer types, bools or tagged
+    integers. Tagged integers should have the tag bit unset.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, dst_type: RType, line: int = -1) -> None:
+        super().__init__(line)
+        self.src = src
+        self.type = dst_type
+        self.src_type = src.type
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def stolen(self) -> list[Value]:
+        return []
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_truncate(self)
+
+
+@final
+class Extend(RegisterOp):
+    """result = extend src from src_type to dst_type
+
+    Extend a value from a type with fewer bits to a type with more bits.
+
+    dst_type and src_type can be native integer types, bools or tagged
+    integers. Tagged integers should have the tag bit unset.
+
+    If 'signed' is true, perform sign extension. Otherwise, the result will be
+    zero extended.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, dst_type: RType, signed: bool, line: int = -1) -> None:
+        super().__init__(line)
+        self.src = src
+        self.type = dst_type
+        self.src_type = src.type
+        self.signed = signed
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def stolen(self) -> list[Value]:
+        return []
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_extend(self)
+
+
+@final
+class LoadGlobal(RegisterOp):
+    """Load a low-level global variable/pointer.
+
+    Note that can't be used to directly load Python module-level
+    global variable, since they are stored in a globals dictionary
+    and accessed using dictionary operations.
+    """
+
+    error_kind = ERR_NEVER
+    is_borrowed = True
+
+    def __init__(self, type: RType, identifier: str, line: int = -1, ann: object = None) -> None:
+        super().__init__(line)
+        self.identifier = identifier
+        self.type = type
+        self.ann = ann  # An object to pretty print with the load
+
+    def sources(self) -> list[Value]:
+        return []
+
+    def set_sources(self, new: list[Value]) -> None:
+        assert not new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_load_global(self)
+
+
+@final
+class IntOp(RegisterOp):
+    """Binary arithmetic or bitwise op on integer operands (e.g., r1 = r2 + r3).
+
+    These ops are low-level and are similar to the corresponding C
+    operations.
+
+    The left and right values must have low-level integer types with
+    compatible representations. Fixed-width integers, short_int_rprimitive,
+    bool_rprimitive and bit_rprimitive are supported.
+
+    For tagged (arbitrary-precision) integer ops look at mypyc.primitives.int_ops.
+    """
+
+    error_kind = ERR_NEVER
+
+    # Arithmetic ops
+    ADD: Final = 0
+    SUB: Final = 1
+    MUL: Final = 2
+    DIV: Final = 3
+    MOD: Final = 4
+
+    # Bitwise ops
+    AND: Final = 200
+    OR: Final = 201
+    XOR: Final = 202
+    LEFT_SHIFT: Final = 203
+    RIGHT_SHIFT: Final = 204
+
+    op_str: Final = {
+        ADD: "+",
+        SUB: "-",
+        MUL: "*",
+        DIV: "/",
+        MOD: "%",
+        AND: "&",
+        OR: "|",
+        XOR: "^",
+        LEFT_SHIFT: "<<",
+        RIGHT_SHIFT: ">>",
+    }
+
+    def __init__(self, type: RType, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
+        super().__init__(line)
+        self.type = type
+        self.lhs = lhs
+        self.rhs = rhs
+        self.op = op
+
+    def sources(self) -> list[Value]:
+        return [self.lhs, self.rhs]
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.lhs, self.rhs = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_int_op(self)
+
+
+# We can't have this in the IntOp class body, because of
+# https://github.com/mypyc/mypyc/issues/932.
+int_op_to_id: Final = {op: op_id for op_id, op in IntOp.op_str.items()}
+
+
+@final
+class ComparisonOp(RegisterOp):
+    """Low-level comparison op for integers and pointers.
+
+    Both unsigned and signed comparisons are supported. Supports
+    comparisons between fixed-width integer types and pointer types.
+    The operands should have matching sizes.
+
+    The result is always a bit (representing a boolean).
+
+    Python semantics, such as calling __eq__, are not supported.
+    """
+
+    # Must be ERR_NEVER or ERR_FALSE. ERR_FALSE means that a false result
+    # indicates that an exception has been raised and should be propagated.
+    error_kind = ERR_NEVER
+
+    # S for signed and U for unsigned
+    EQ: Final = 100
+    NEQ: Final = 101
+    SLT: Final = 102
+    SGT: Final = 103
+    SLE: Final = 104
+    SGE: Final = 105
+    ULT: Final = 106
+    UGT: Final = 107
+    ULE: Final = 108
+    UGE: Final = 109
+
+    op_str: Final = {
+        EQ: "==",
+        NEQ: "!=",
+        SLT: "<",
+        SGT: ">",
+        SLE: "<=",
+        SGE: ">=",
+        ULT: "<",
+        UGT: ">",
+        ULE: "<=",
+        UGE: ">=",
+    }
+
+    signed_ops: Final = {"==": EQ, "!=": NEQ, "<": SLT, ">": SGT, "<=": SLE, ">=": SGE}
+    unsigned_ops: Final = {"==": EQ, "!=": NEQ, "<": ULT, ">": UGT, "<=": ULE, ">=": UGE}
+
+    def __init__(self, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
+        super().__init__(line)
+        self.type = bit_rprimitive
+        self.lhs = lhs
+        self.rhs = rhs
+        self.op = op
+
+    def sources(self) -> list[Value]:
+        return [self.lhs, self.rhs]
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.lhs, self.rhs = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_comparison_op(self)
+
+
+@final
+class FloatOp(RegisterOp):
+    """Binary float arithmetic op (e.g., r1 = r2 + r3).
+
+    These ops are low-level and are similar to the corresponding C
+    operations (and somewhat different from Python operations).
+
+    The left and right values must be floats.
+    """
+
+    error_kind = ERR_NEVER
+
+    ADD: Final = 0
+    SUB: Final = 1
+    MUL: Final = 2
+    DIV: Final = 3
+    MOD: Final = 4
+
+    op_str: Final = {ADD: "+", SUB: "-", MUL: "*", DIV: "/", MOD: "%"}
+
+    def __init__(self, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
+        super().__init__(line)
+        self.type = float_rprimitive
+        self.lhs = lhs
+        self.rhs = rhs
+        self.op = op
+
+    def sources(self) -> list[Value]:
+        return [self.lhs, self.rhs]
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.lhs, self.rhs = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_float_op(self)
+
+
+# We can't have this in the FloatOp class body, because of
+# https://github.com/mypyc/mypyc/issues/932.
+float_op_to_id: Final = {op: op_id for op_id, op in FloatOp.op_str.items()}
+
+
+@final
+class FloatNeg(RegisterOp):
+    """Float negation op (r1 = -r2)."""
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, line: int = -1) -> None:
+        super().__init__(line)
+        self.type = float_rprimitive
+        self.src = src
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_float_neg(self)
+
+
+@final
+class FloatComparisonOp(RegisterOp):
+    """Low-level comparison op for floats."""
+
+    error_kind = ERR_NEVER
+
+    EQ: Final = 200
+    NEQ: Final = 201
+    LT: Final = 202
+    GT: Final = 203
+    LE: Final = 204
+    GE: Final = 205
+
+    op_str: Final = {EQ: "==", NEQ: "!=", LT: "<", GT: ">", LE: "<=", GE: ">="}
+
+    def __init__(self, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
+        super().__init__(line)
+        self.type = bit_rprimitive
+        self.lhs = lhs
+        self.rhs = rhs
+        self.op = op
+
+    def sources(self) -> list[Value]:
+        return [self.lhs, self.rhs]
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.lhs, self.rhs = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_float_comparison_op(self)
+
+
+# We can't have this in the FloatOp class body, because of
+# https://github.com/mypyc/mypyc/issues/932.
+float_comparison_op_to_id: Final = {op: op_id for op_id, op in FloatComparisonOp.op_str.items()}
+
+
+@final
+class LoadMem(RegisterOp):
+    """Read a memory location: result = *(type *)src.
+
+    Attributes:
+      type: Type of the read value
+      src: Pointer to memory to read
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, type: RType, src: Value, line: int = -1, *, borrow: bool = False) -> None:
+        super().__init__(line)
+        self.type = type
+        # TODO: Support other native integer types
+        assert is_pointer_rprimitive(src.type)
+        self.src = src
+        self.is_borrowed = borrow and type.is_refcounted
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_load_mem(self)
+
+
+@final
+class SetMem(Op):
+    """Write to a memory location: *(type *)dest = src
+
+    Attributes:
+      type: Type of the written value
+      dest: Pointer to memory to write
+      src: Source value
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, type: RType, dest: Value, src: Value, line: int = -1) -> None:
+        super().__init__(line)
+        self.type = void_rtype
+        self.dest_type = type
+        self.src = src
+        self.dest = dest
+
+    def sources(self) -> list[Value]:
+        return [self.src, self.dest]
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.src, self.dest = new
+
+    def stolen(self) -> list[Value]:
+        return [self.src]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_set_mem(self)
+
+
+@final
+class GetElement(RegisterOp):
+    """Get the value of a struct element from a struct value."""
+
+    error_kind = ERR_NEVER
+    is_borrowed = True
+
+    def __init__(self, src: Value, field: str, line: int = -1) -> None:
+        super().__init__(line)
+        assert isinstance(src.type, (RStruct, RVec))
+        self.type = src.type.field_type(field)
+        self.src = src
+        self.src_type = src.type
+        self.field = field
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_get_element(self)
+
+
+@final
+class GetElementPtr(RegisterOp):
+    """Get the address of a struct element from a pointer to a struct.
+
+    If you have a struct value, use GetElement instead.
+
+    Note that you may need to use KeepAlive to avoid the struct
+    being freed, if it's reference counted, such as PyObject *.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, src_type: RType, field: str, line: int = -1) -> None:
+        super().__init__(line)
+        assert not isinstance(src.type, (RStruct, RVec))
+        self.type = pointer_rprimitive
+        self.src = src
+        self.src_type = src_type
+        self.field = field
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_get_element_ptr(self)
+
+
+@final
+class SetElement(RegisterOp):
+    """Set the value of a struct element.
+
+    This evaluates to a new struct with the changed value.
+
+    Use together with Undef to initialize a fresh struct value
+    (see Undef for more details).
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, field: str, item: Value, line: int = -1) -> None:
+        super().__init__(line)
+        assert isinstance(src.type, (RStruct, RVec)), src.type
+        self.type = src.type
+        self.src = src
+        self.item = item
+        self.field = field
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def stolen(self) -> list[Value]:
+        return [self.src]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_set_element(self)
+
+
+@final
+class LoadAddress(RegisterOp):
+    """Get the address of a value: result = (type)&src
+
+    Attributes:
+      type: Type of the loaded address(e.g. ptr/object_ptr)
+      src: Source value (str for globals like 'PyList_Type',
+           Register for temporary values or locals, LoadStatic
+           for statics.)
+    """
+
+    error_kind = ERR_NEVER
+    is_borrowed = True
+
+    def __init__(self, type: RType, src: str | Register | LoadStatic, line: int = -1) -> None:
+        super().__init__(line)
+        self.type = type
+        self.src = src
+
+    def sources(self) -> list[Value]:
+        if isinstance(self.src, Register):
+            return [self.src]
+        else:
+            return []
+
+    def set_sources(self, new: list[Value]) -> None:
+        if new:
+            assert isinstance(new[0], Register)
+            assert len(new) == 1
+            self.src = new[0]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_load_address(self)
+
+
+@final
+class KeepAlive(RegisterOp):
+    """A no-op operation that ensures source values aren't freed.
+
+    This is sometimes useful to avoid decref when a reference is still
+    being held but not seen by the compiler.
+
+    A typical use case is like this (C-like pseudocode):
+
+      ptr = &x.item
+      r = *ptr
+      keep_alive x  # x must not be freed here
+      # x may be freed here
+
+    If we didn't have "keep_alive x", x could be freed immediately
+    after taking the address of 'item', resulting in a read after free
+    on the second line.
+
+    If 'steal' is true, the value is considered to be stolen at
+    this op, i.e. it won't be decref'd. You need to ensure that
+    the value is freed otherwise, perhaps by using borrowing
+    followed by Unborrow.
+
+    Be careful with steal=True -- this can cause memory leaks.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: list[Value], line: int = -1, *, steal: bool = False) -> None:
+        super().__init__(line)
+        assert src
+        self.src = src
+        self.steal = steal
+
+    def sources(self) -> list[Value]:
+        return self.src.copy()
+
+    def stolen(self) -> list[Value]:
+        if self.steal:
+            return self.src.copy()
+        return []
+
+    def set_sources(self, new: list[Value]) -> None:
+        self.src = new[:]
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_keep_alive(self)
+
+
+@final
+class Unborrow(RegisterOp):
+    """A no-op op to create a regular reference from a borrowed one.
+
+    Borrowed references can only be used temporarily and the reference
+    counts won't be managed. This value will be refcounted normally.
+
+    This is mainly useful if you split an aggregate value, such as
+    a tuple, into components using borrowed values (to avoid increfs),
+    and want to treat the components as sharing the original managed
+    reference. You'll also need to use KeepAlive with steal=True to
+    "consume" the original tuple reference:
+
+      # t is a 2-tuple
+      r0 = borrow t[0]
+      r1 = borrow t[1]
+      keep_alive steal t
+      r2 = unborrow r0
+      r3 = unborrow r1
+      # now (r2, r3) represent the tuple as separate items, that are
+      # managed again. (Note we need to steal before unborrow, to avoid
+      # refcount briefly touching zero if r2 or r3 are unused.)
+
+    Be careful with this -- this can easily cause double freeing.
+    """
+
+    error_kind = ERR_NEVER
+
+    def __init__(self, src: Value, line: int = -1) -> None:
+        super().__init__(line)
+        assert src.is_borrowed
+        self.src = src
+        self.type = src.type
+
+    def sources(self) -> list[Value]:
+        return [self.src]
+
+    def set_sources(self, new: list[Value]) -> None:
+        (self.src,) = new
+
+    def stolen(self) -> list[Value]:
+        return []
+
+    def accept(self, visitor: OpVisitor[T]) -> T:
+        return visitor.visit_unborrow(self)
+
+
+@trait
+class OpVisitor(Generic[T]):
+    """Generic visitor over ops (uses the visitor design pattern)."""
+
+    @abstractmethod
+    def visit_goto(self, op: Goto) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_branch(self, op: Branch) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_return(self, op: Return) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_unreachable(self, op: Unreachable) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_assign(self, op: Assign) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_assign_multi(self, op: AssignMulti) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_load_error_value(self, op: LoadErrorValue) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_load_literal(self, op: LoadLiteral) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_get_attr(self, op: GetAttr) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_set_attr(self, op: SetAttr) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_load_static(self, op: LoadStatic) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_init_static(self, op: InitStatic) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_tuple_get(self, op: TupleGet) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_tuple_set(self, op: TupleSet) -> T:
+        raise NotImplementedError
+
+    def visit_inc_ref(self, op: IncRef) -> T:
+        raise NotImplementedError
+
+    def visit_dec_ref(self, op: DecRef) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_call(self, op: Call) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_method_call(self, op: MethodCall) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_cast(self, op: Cast) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_box(self, op: Box) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_unbox(self, op: Unbox) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_raise_standard_error(self, op: RaiseStandardError) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_call_c(self, op: CallC) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_primitive_op(self, op: PrimitiveOp) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_truncate(self, op: Truncate) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_extend(self, op: Extend) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_load_global(self, op: LoadGlobal) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_int_op(self, op: IntOp) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_comparison_op(self, op: ComparisonOp) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_float_op(self, op: FloatOp) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_float_neg(self, op: FloatNeg) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_float_comparison_op(self, op: FloatComparisonOp) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_load_mem(self, op: LoadMem) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_set_mem(self, op: SetMem) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_get_element(self, op: GetElement) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_get_element_ptr(self, op: GetElementPtr) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_set_element(self, op: SetElement) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_load_address(self, op: LoadAddress) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_keep_alive(self, op: KeepAlive) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_unborrow(self, op: Unborrow) -> T:
+        raise NotImplementedError
+
+
+# TODO: Should the following definition live somewhere else?
+
+
+# We do a three-pass deserialization scheme in order to resolve name
+# references.
+#  1. Create an empty ClassIR for each class in an SCC.
+#  2. Deserialize all of the functions, which can contain references
+#     to ClassIRs in their types
+#  3. Deserialize all of the classes, which contain lots of references
+#     to the functions they contain. (And to other classes.)
+#
+# Note that this approach differs from how we deserialize ASTs in mypy itself,
+# where everything is deserialized in one pass then a second pass cleans up
+# 'cross_refs'. We don't follow that approach here because it seems to be more
+# code for not a lot of gain since it is easy in mypyc to identify all the objects
+# we might need to reference.
+#
+# Because of these references, we need to maintain maps from class
+# names to ClassIRs and func IDs to FuncIRs.
+#
+# These are tracked in a DeserMaps which is passed to every
+# deserialization function.
+#
+# (Serialization and deserialization *will* be used for incremental
+# compilation but so far it is not hooked up to anything.)
+class DeserMaps(NamedTuple):
+    classes: dict[str, ClassIR]
+    functions: dict[str, FuncIR]

micromamba_root/Lib/site-packages/mypyc/ir/pprint.py

@@ -0,0 +1,530 @@
+"""Utilities for pretty-printing IR in a human-readable form."""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from collections.abc import Sequence
+from typing import Any, Final
+
+from mypyc.common import short_name
+from mypyc.ir.func_ir import FuncIR, all_values_full
+from mypyc.ir.module_ir import ModuleIRs
+from mypyc.ir.ops import (
+    ERR_NEVER,
+    Assign,
+    AssignMulti,
+    BasicBlock,
+    Box,
+    Branch,
+    Call,
+    CallC,
+    Cast,
+    ComparisonOp,
+    ControlOp,
+    CString,
+    DecRef,
+    Extend,
+    Float,
+    FloatComparisonOp,
+    FloatNeg,
+    FloatOp,
+    GetAttr,
+    GetElement,
+    GetElementPtr,
+    Goto,
+    IncRef,
+    InitStatic,
+    Integer,
+    IntOp,
+    KeepAlive,
+    LoadAddress,
+    LoadErrorValue,
+    LoadGlobal,
+    LoadLiteral,
+    LoadMem,
+    LoadStatic,
+    MethodCall,
+    Op,
+    OpVisitor,
+    PrimitiveOp,
+    RaiseStandardError,
+    Register,
+    Return,
+    SetAttr,
+    SetElement,
+    SetMem,
+    Truncate,
+    TupleGet,
+    TupleSet,
+    Unborrow,
+    Unbox,
+    Undef,
+    Unreachable,
+    Value,
+)
+from mypyc.ir.rtypes import RType, is_bool_rprimitive, is_int_rprimitive
+
+ErrorSource = BasicBlock | Op
+
+
+class IRPrettyPrintVisitor(OpVisitor[str]):
+    """Internal visitor that pretty-prints ops."""
+
+    def __init__(self, names: dict[Value, str]) -> None:
+        # This should contain a name for all values that are shown as
+        # registers in the output. This is not just for Register
+        # instances -- all Ops that produce values need (generated) names.
+        self.names = names
+
+    def visit_goto(self, op: Goto) -> str:
+        return self.format("goto %l", op.label)
+
+    branch_op_names: Final = {Branch.BOOL: ("%r", "bool"), Branch.IS_ERROR: ("is_error(%r)", "")}
+
+    def visit_branch(self, op: Branch) -> str:
+        fmt, typ = self.branch_op_names[op.op]
+        if op.negated:
+            fmt = f"not {fmt}"
+
+        cond = self.format(fmt, op.value)
+        tb = ""
+        if op.traceback_entry:
+            tb = " (error at %s:%d)" % op.traceback_entry
+        fmt = f"if {cond} goto %l{tb} else goto %l"
+        if typ:
+            fmt += f" :: {typ}"
+        return self.format(fmt, op.true, op.false)
+
+    def visit_return(self, op: Return) -> str:
+        return self.format("return %r", op.value)
+
+    def visit_unreachable(self, op: Unreachable) -> str:
+        return "unreachable"
+
+    def visit_assign(self, op: Assign) -> str:
+        return self.format("%r = %r", op.dest, op.src)
+
+    def visit_assign_multi(self, op: AssignMulti) -> str:
+        return self.format("%r = [%s]", op.dest, ", ".join(self.format("%r", v) for v in op.src))
+
+    def visit_load_error_value(self, op: LoadErrorValue) -> str:
+        return self.format("%r = <error> :: %s", op, op.type)
+
+    def visit_load_literal(self, op: LoadLiteral) -> str:
+        prefix = ""
+        # For values that have a potential unboxed representation, make
+        # it explicit that this is a Python object.
+        if isinstance(op.value, int):
+            prefix = "object "
+
+        rvalue = repr(op.value)
+        if isinstance(op.value, frozenset):
+            # We need to generate a string representation that won't vary
+            # run-to-run because sets are unordered, otherwise we may get
+            # spurious irbuild test failures.
+            #
+            # Sorting by the item's string representation is a bit of a
+            # hack, but it's stable and won't cause TypeErrors.
+            formatted_items = [repr(i) for i in sorted(op.value, key=str)]
+            rvalue = "frozenset({" + ", ".join(formatted_items) + "})"
+        return self.format("%r = %s%s", op, prefix, rvalue)
+
+    def visit_get_attr(self, op: GetAttr) -> str:
+        return self.format("%r = %s%r.%s", op, self.borrow_prefix(op), op.obj, op.attr)
+
+    def borrow_prefix(self, op: Op) -> str:
+        if op.is_borrowed:
+            return "borrow "
+        return ""
+
+    def visit_set_attr(self, op: SetAttr) -> str:
+        if op.is_init:
+            assert op.error_kind == ERR_NEVER
+        if op.error_kind == ERR_NEVER:
+            # Initialization and direct struct access can never fail
+            return self.format("%r.%s = %r", op.obj, op.attr, op.src)
+        else:
+            return self.format("%r.%s = %r; %r = is_error", op.obj, op.attr, op.src, op)
+
+    def visit_load_static(self, op: LoadStatic) -> str:
+        ann = f"  ({repr(op.ann)})" if op.ann else ""
+        name = op.identifier
+        if op.module_name is not None:
+            name = f"{op.module_name}.{name}"
+        return self.format("%r = %s :: %s%s", op, name, op.namespace, ann)
+
+    def visit_init_static(self, op: InitStatic) -> str:
+        name = op.identifier
+        if op.module_name is not None:
+            name = f"{op.module_name}.{name}"
+        return self.format("%s = %r :: %s", name, op.value, op.namespace)
+
+    def visit_tuple_get(self, op: TupleGet) -> str:
+        return self.format("%r = %s%r[%d]", op, self.borrow_prefix(op), op.src, op.index)
+
+    def visit_tuple_set(self, op: TupleSet) -> str:
+        item_str = ", ".join(self.format("%r", item) for item in op.items)
+        return self.format("%r = (%s)", op, item_str)
+
+    def visit_inc_ref(self, op: IncRef) -> str:
+        s = self.format("inc_ref %r", op.src)
+        # TODO: Remove bool check (it's unboxed)
+        if is_bool_rprimitive(op.src.type) or is_int_rprimitive(op.src.type):
+            s += f" :: {short_name(op.src.type.name)}"
+        return s
+
+    def visit_dec_ref(self, op: DecRef) -> str:
+        s = self.format("%sdec_ref %r", "x" if op.is_xdec else "", op.src)
+        # TODO: Remove bool check (it's unboxed)
+        if is_bool_rprimitive(op.src.type) or is_int_rprimitive(op.src.type):
+            s += f" :: {short_name(op.src.type.name)}"
+        return s
+
+    def visit_call(self, op: Call) -> str:
+        args = ", ".join(self.format("%r", arg) for arg in op.args)
+        # TODO: Display long name?
+        short_name = op.fn.shortname
+        s = f"{short_name}({args})"
+        if not op.is_void:
+            s = self.format("%r = ", op) + s
+        return s
+
+    def visit_method_call(self, op: MethodCall) -> str:
+        args = ", ".join(self.format("%r", arg) for arg in op.args)
+        s = self.format("%r.%s(%s)", op.obj, op.method, args)
+        if not op.is_void:
+            s = self.format("%r = ", op) + s
+        return s
+
+    def visit_cast(self, op: Cast) -> str:
+        if op.is_unchecked:
+            prefix = "unchecked "
+        else:
+            prefix = ""
+        return self.format(
+            "%r = %s%scast(%s, %r)", op, prefix, self.borrow_prefix(op), op.type, op.src
+        )
+
+    def visit_box(self, op: Box) -> str:
+        return self.format("%r = box(%s, %r)", op, op.src.type, op.src)
+
+    def visit_unbox(self, op: Unbox) -> str:
+        return self.format("%r = unbox(%s, %r)", op, op.type, op.src)
+
+    def visit_raise_standard_error(self, op: RaiseStandardError) -> str:
+        if op.value is not None:
+            if isinstance(op.value, str):
+                return self.format("%r = raise %s(%s)", op, op.class_name, repr(op.value))
+            elif isinstance(op.value, Value):
+                return self.format("%r = raise %s(%r)", op, op.class_name, op.value)
+            else:
+                assert False, "value type must be either str or Value"
+        else:
+            return self.format("%r = raise %s", op, op.class_name)
+
+    def visit_call_c(self, op: CallC) -> str:
+        args_str = ", ".join(self.format("%r", arg) for arg in op.args)
+        if op.is_void:
+            return self.format("%s(%s)", op.function_name, args_str)
+        else:
+            return self.format("%r = %s(%s)", op, op.function_name, args_str)
+
+    def visit_primitive_op(self, op: PrimitiveOp) -> str:
+        args_str = ", ".join(self.format("%r", arg) for arg in op.args)
+        if op.is_void:
+            return self.format("%s %s", op.desc.name, args_str)
+        else:
+            return self.format("%r = %s %s", op, op.desc.name, args_str)
+
+    def visit_truncate(self, op: Truncate) -> str:
+        return self.format("%r = truncate %r: %t to %t", op, op.src, op.src_type, op.type)
+
+    def visit_extend(self, op: Extend) -> str:
+        if op.signed:
+            extra = " signed"
+        else:
+            extra = ""
+        return self.format("%r = extend%s %r: %t to %t", op, extra, op.src, op.src_type, op.type)
+
+    def visit_load_global(self, op: LoadGlobal) -> str:
+        ann = f"  ({repr(op.ann)})" if op.ann else ""
+        return self.format("%r = load_global %s :: static%s", op, op.identifier, ann)
+
+    def visit_int_op(self, op: IntOp) -> str:
+        return self.format("%r = %r %s %r", op, op.lhs, IntOp.op_str[op.op], op.rhs)
+
+    def visit_comparison_op(self, op: ComparisonOp) -> str:
+        if op.op in (ComparisonOp.SLT, ComparisonOp.SGT, ComparisonOp.SLE, ComparisonOp.SGE):
+            sign_format = " :: signed"
+        elif op.op in (ComparisonOp.ULT, ComparisonOp.UGT, ComparisonOp.ULE, ComparisonOp.UGE):
+            sign_format = " :: unsigned"
+        else:
+            sign_format = ""
+        return self.format(
+            "%r = %r %s %r%s", op, op.lhs, ComparisonOp.op_str[op.op], op.rhs, sign_format
+        )
+
+    def visit_float_op(self, op: FloatOp) -> str:
+        return self.format("%r = %r %s %r", op, op.lhs, FloatOp.op_str[op.op], op.rhs)
+
+    def visit_float_neg(self, op: FloatNeg) -> str:
+        return self.format("%r = -%r", op, op.src)
+
+    def visit_float_comparison_op(self, op: FloatComparisonOp) -> str:
+        return self.format("%r = %r %s %r", op, op.lhs, op.op_str[op.op], op.rhs)
+
+    def visit_load_mem(self, op: LoadMem) -> str:
+        return self.format(
+            "%r = %sload_mem %r :: %t*", op, self.borrow_prefix(op), op.src, op.type
+        )
+
+    def visit_set_mem(self, op: SetMem) -> str:
+        return self.format("set_mem %r, %r :: %t*", op.dest, op.src, op.dest_type)
+
+    def visit_get_element(self, op: GetElement) -> str:
+        return self.format("%r = %r.%s", op, op.src, op.field)
+
+    def visit_get_element_ptr(self, op: GetElementPtr) -> str:
+        return self.format("%r = get_element_ptr %r %s :: %t", op, op.src, op.field, op.src_type)
+
+    def visit_set_element(self, op: SetElement) -> str:
+        return self.format("%r = set_element %r, %s, %r", op, op.src, op.field, op.item)
+
+    def visit_load_address(self, op: LoadAddress) -> str:
+        if isinstance(op.src, Register):
+            return self.format("%r = load_address %r", op, op.src)
+        elif isinstance(op.src, LoadStatic):
+            name = op.src.identifier
+            if op.src.module_name is not None:
+                name = f"{op.src.module_name}.{name}"
+            return self.format("%r = load_address %s :: %s", op, name, op.src.namespace)
+        else:
+            return self.format("%r = load_address %s", op, op.src)
+
+    def visit_keep_alive(self, op: KeepAlive) -> str:
+        if op.steal:
+            steal = "steal "
+        else:
+            steal = ""
+        return self.format(
+            "keep_alive {}{}".format(steal, ", ".join(self.format("%r", v) for v in op.src))
+        )
+
+    def visit_unborrow(self, op: Unborrow) -> str:
+        return self.format("%r = unborrow %r", op, op.src)
+
+    # Helpers
+
+    def format(self, fmt: str, *args: Any) -> str:
+        """Helper for formatting strings.
+
+        These format sequences are supported in fmt:
+
+          %s: arbitrary object converted to string using str()
+          %r: name of IR value/register
+          %d: int
+          %f: float
+          %l: BasicBlock (formatted as label 'Ln')
+          %t: RType
+        """
+        result = []
+        i = 0
+        arglist = list(args)
+        while i < len(fmt):
+            n = fmt.find("%", i)
+            if n < 0:
+                n = len(fmt)
+            result.append(fmt[i:n])
+            if n < len(fmt):
+                typespec = fmt[n + 1]
+                arg = arglist.pop(0)
+                if typespec == "r":
+                    # Register/value
+                    assert isinstance(arg, Value)
+                    if isinstance(arg, Integer):
+                        result.append(str(arg.value))
+                    elif isinstance(arg, Float):
+                        result.append(repr(arg.value))
+                    elif isinstance(arg, CString):
+                        result.append(f"CString({arg.value!r})")
+                    elif isinstance(arg, Undef):
+                        result.append(f"undef {arg.type.name}")
+                    else:
+                        result.append(self.names[arg])
+                elif typespec == "d":
+                    # Integer
+                    result.append("%d" % arg)
+                elif typespec == "f":
+                    # Float
+                    result.append("%f" % arg)
+                elif typespec == "l":
+                    # Basic block (label)
+                    assert isinstance(arg, BasicBlock)
+                    result.append("L%s" % arg.label)
+                elif typespec == "t":
+                    # RType
+                    assert isinstance(arg, RType)
+                    result.append(arg.name)
+                elif typespec == "s":
+                    # String
+                    result.append(str(arg))
+                else:
+                    raise ValueError(f"Invalid format sequence %{typespec}")
+                i = n + 2
+            else:
+                i = n
+        return "".join(result)
+
+
+def format_registers(func_ir: FuncIR, names: dict[Value, str]) -> list[str]:
+    result = []
+    i = 0
+    regs = all_values_full(func_ir.arg_regs, func_ir.blocks)
+    while i < len(regs):
+        i0 = i
+        group = [names[regs[i0]]]
+        while i + 1 < len(regs) and regs[i + 1].type == regs[i0].type:
+            i += 1
+            group.append(names[regs[i]])
+        i += 1
+        result.append("{} :: {}".format(", ".join(group), regs[i0].type))
+    return result
+
+
+def format_blocks(
+    blocks: list[BasicBlock],
+    names: dict[Value, str],
+    source_to_error: dict[ErrorSource, list[str]],
+) -> list[str]:
+    """Format a list of IR basic blocks into a human-readable form."""
+    # First label all of the blocks
+    for i, block in enumerate(blocks):
+        block.label = i
+
+    handler_map: dict[BasicBlock, list[BasicBlock]] = {}
+    for b in blocks:
+        if b.error_handler:
+            handler_map.setdefault(b.error_handler, []).append(b)
+
+    visitor = IRPrettyPrintVisitor(names)
+
+    lines = []
+    for i, block in enumerate(blocks):
+        handler_msg = ""
+        if block in handler_map:
+            labels = sorted("L%d" % b.label for b in handler_map[block])
+            handler_msg = " (handler for {})".format(", ".join(labels))
+
+        lines.append("L%d:%s" % (block.label, handler_msg))
+        if block in source_to_error:
+            for error in source_to_error[block]:
+                lines.append(f"  ERROR: {error}")
+        ops = block.ops
+        if (
+            isinstance(ops[-1], Goto)
+            and i + 1 < len(blocks)
+            and ops[-1].label == blocks[i + 1]
+            and not source_to_error.get(ops[-1], [])
+        ):
+            # Hide the last goto if it just goes to the next basic block,
+            # and there are no assocatiated errors with the op.
+            ops = ops[:-1]
+        for op in ops:
+            line = "    " + op.accept(visitor)
+            lines.append(line)
+            if op in source_to_error:
+                first = len(lines) - 1
+                # Use emojis to highlight the error
+                for error in source_to_error[op]:
+                    lines.append(f"    \U0001f446 ERROR: {error}")
+                lines[first] = " \U0000274c " + lines[first][4:]
+
+        if not isinstance(block.ops[-1], (Goto, Branch, Return, Unreachable)):
+            # Each basic block needs to exit somewhere.
+            lines.append("    [MISSING BLOCK EXIT OPCODE]")
+    return lines
+
+
+def format_func(fn: FuncIR, errors: Sequence[tuple[ErrorSource, str]] = ()) -> list[str]:
+    lines = []
+    cls_prefix = fn.class_name + "." if fn.class_name else ""
+    lines.append(
+        "def {}{}({}):".format(cls_prefix, fn.name, ", ".join(arg.name for arg in fn.args))
+    )
+    names = generate_names_for_ir(fn.arg_regs, fn.blocks)
+    for line in format_registers(fn, names):
+        lines.append("    " + line)
+
+    source_to_error = defaultdict(list)
+    for source, error in errors:
+        source_to_error[source].append(error)
+
+    code = format_blocks(fn.blocks, names, source_to_error)
+    lines.extend(code)
+    return lines
+
+
+def format_modules(modules: ModuleIRs) -> list[str]:
+    ops = []
+    for module in modules.values():
+        for fn in module.functions:
+            ops.extend(format_func(fn))
+            ops.append("")
+    return ops
+
+
+def generate_names_for_ir(args: list[Register], blocks: list[BasicBlock]) -> dict[Value, str]:
+    """Generate unique names for IR values.
+
+    Give names such as 'r5' to temp values in IR which are useful when
+    pretty-printing or generating C. Ensure generated names are unique.
+    """
+    names: dict[Value, str] = {}
+    used_names = set()
+
+    temp_index = 0
+
+    for arg in args:
+        names[arg] = arg.name
+        used_names.add(arg.name)
+
+    for block in blocks:
+        for op in block.ops:
+            values = []
+
+            for source in op.sources():
+                if source not in names:
+                    values.append(source)
+
+            if isinstance(op, (Assign, AssignMulti)):
+                values.append(op.dest)
+            elif isinstance(op, ControlOp) or op.is_void:
+                continue
+            elif op not in names:
+                values.append(op)
+
+            for value in values:
+                if value in names:
+                    continue
+                if isinstance(value, Register) and value.name:
+                    name = value.name
+                elif isinstance(value, (Integer, Float, Undef)):
+                    continue
+                else:
+                    name = "r%d" % temp_index
+                    temp_index += 1
+
+                # Append _2, _3, ... if needed to make the name unique.
+                if name in used_names:
+                    n = 2
+                    while True:
+                        candidate = "%s_%d" % (name, n)
+                        if candidate not in used_names:
+                            name = candidate
+                            break
+                        n += 1
+
+                names[value] = name
+                used_names.add(name)
+
+    return names

micromamba_root/Lib/site-packages/mypyc/ir/rtypes.py

@@ -0,0 +1,1444 @@
+"""Types used in the intermediate representation.
+
+These are runtime types (RTypes), as opposed to mypy Type objects.
+The latter are only used during type checking and not directly used at
+runtime.  Runtime types are derived from mypy types, but there's no
+simple one-to-one correspondence. (Here 'runtime' means 'runtime
+checked'.)
+
+The generated IR ensures some runtime type safety properties based on
+RTypes. Compiled code can assume that the runtime value matches the
+static RType of a value. If the RType of a register is 'builtins.str'
+(str_rprimitive), for example, the generated IR will ensure that the
+register will have a 'str' object.
+
+RTypes are simpler and less expressive than mypy (or PEP 484)
+types. For example, all mypy types of form 'list[T]' (for arbitrary T)
+are erased to the single RType 'builtins.list' (list_rprimitive).
+
+mypyc.irbuild.mapper.Mapper.type_to_rtype converts mypy Types to mypyc
+RTypes.
+
+NOTE: As a convention, we don't create subclasses of concrete RType
+      subclasses (e.g. you shouldn't define a subclass of RTuple, which
+      is a concrete class). We prefer a flat class hierarchy.
+
+      If you want to introduce a variant of an existing class, you'd
+      typically add an attribute (e.g. a flag) to an existing concrete
+      class to enable the new behavior. In rare cases, adding a new
+      abstract base class could also be an option. Adding a completely
+      separate class and sharing some functionality using module-level
+      helper functions may also be reasonable.
+
+      This makes it possible to use isinstance(x, <concrete RType
+      subclass>) checks without worrying about potential subclasses
+      and avoids most trouble caused by implementation inheritance.
+"""
+
+from __future__ import annotations
+
+from abc import abstractmethod
+from typing import TYPE_CHECKING, ClassVar, Final, Generic, TypeGuard, TypeVar, Union, final
+
+from mypyc.common import HAVE_IMMORTAL, IS_32_BIT_PLATFORM, PLATFORM_SIZE, JsonDict, short_name
+from mypyc.ir.deps import LIBRT_STRINGS, LIBRT_VECS, Dependency
+from mypyc.namegen import NameGenerator
+
+if TYPE_CHECKING:
+    from mypyc.ir.class_ir import ClassIR
+    from mypyc.ir.ops import DeserMaps
+
+T = TypeVar("T")
+
+
+class RType:
+    """Abstract base class for runtime types (erased, only concrete; no generics)."""
+
+    name: str
+    # If True, the type has a special unboxed representation. If False, the
+    # type is represented as PyObject *. Even if True, the representation
+    # may contain pointers.
+    is_unboxed = False
+    # This is the C undefined value for this type. It's used for initialization
+    # if there's no value yet, and for function return value on error/exception.
+    #
+    # TODO: This shouldn't be specific to C or a string
+    c_undefined: str
+    # If unboxed: does the unboxed version use reference counting?
+    is_refcounted = True
+    # C type; use Emitter.ctype() to access
+    _ctype: str
+    # If True, error/undefined value overlaps with a valid value. To
+    # detect an exception, PyErr_Occurred() must be used in addition
+    # to checking for error value as the return value of a function.
+    #
+    # For example, no i64 value can be reserved for error value, so we
+    # pick an arbitrary value (-113) to signal error, but this is
+    # also a valid non-error value. The chosen value is rare as a
+    # normal, non-error value, so most of the time we can avoid calling
+    # PyErr_Occurred() when checking for errors raised by called
+    # functions.
+    #
+    # This also means that if an attribute with this type might be
+    # undefined, we can't just rely on the error value to signal this.
+    # Instead, we add a bitfield to keep track whether attributes with
+    # "error overlap" have a value. If there is no value, AttributeError
+    # is raised on attribute read. Parameters with default values also
+    # use the bitfield trick to indicate whether the caller passed a
+    # value. (If we can determine that an attribute is "always defined",
+    # we never raise an AttributeError and don't need the bitfield
+    # entry.)
+    error_overlap = False
+    dependencies: tuple[Dependency, ...] | None = None
+
+    @abstractmethod
+    def accept(self, visitor: RTypeVisitor[T]) -> T:
+        raise NotImplementedError()
+
+    def short_name(self) -> str:
+        return short_name(self.name)
+
+    @property
+    @abstractmethod
+    def may_be_immortal(self) -> bool:
+        raise NotImplementedError
+
+    def __str__(self) -> str:
+        return short_name(self.name)
+
+    def __repr__(self) -> str:
+        return "<%s>" % self.__class__.__name__
+
+    def serialize(self) -> JsonDict | str:
+        raise NotImplementedError(f"Cannot serialize {self.__class__.__name__} instance")
+
+
+def deserialize_type(data: JsonDict | str, ctx: DeserMaps) -> RType:
+    """Deserialize a JSON-serialized RType.
+
+    Arguments:
+        data: The decoded JSON of the serialized type
+        ctx: The deserialization maps to use
+    """
+    # Since there are so few types, we just case on them directly.  If
+    # more get added we should switch to a system like mypy.types
+    # uses.
+    if isinstance(data, str):
+        if data in ctx.classes:
+            return RInstance(ctx.classes[data])
+        elif data in RPrimitive.primitive_map:
+            return RPrimitive.primitive_map[data]
+        elif data == "void":
+            return RVoid()
+        else:
+            assert False, f"Can't find class {data}"
+    elif data[".class"] == "RTuple":
+        return RTuple.deserialize(data, ctx)
+    elif data[".class"] == "RUnion":
+        return RUnion.deserialize(data, ctx)
+    elif data[".class"] == "RVec":
+        return RVec.deserialize(data, ctx)
+    raise NotImplementedError("unexpected .class {}".format(data[".class"]))
+
+
+class RTypeVisitor(Generic[T]):
+    """Generic visitor over RTypes (uses the visitor design pattern)."""
+
+    @abstractmethod
+    def visit_rprimitive(self, typ: RPrimitive, /) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_rinstance(self, typ: RInstance, /) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_rvec(self, typ: RVec, /) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_runion(self, typ: RUnion, /) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_rtuple(self, typ: RTuple, /) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_rstruct(self, typ: RStruct, /) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_rarray(self, typ: RArray, /) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def visit_rvoid(self, typ: RVoid, /) -> T:
+        raise NotImplementedError
+
+
+# These types are implemented as C structs.
+RStructLike = Union["RStruct", "RVec"]
+
+
+@final
+class RVoid(RType):
+    """The void type (no value).
+
+    This is a singleton -- use void_rtype (below) to refer to this instead of
+    constructing a new instance.
+    """
+
+    is_unboxed = False
+    name = "void"
+    ctype = "void"
+
+    def accept(self, visitor: RTypeVisitor[T]) -> T:
+        return visitor.visit_rvoid(self)
+
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
+    def serialize(self) -> str:
+        return "void"
+
+    def __eq__(self, other: object) -> TypeGuard[RVoid]:
+        return isinstance(other, RVoid)
+
+    def __hash__(self) -> int:
+        return hash(RVoid)
+
+
+# Singleton instance of RVoid
+void_rtype: Final = RVoid()
+
+
+@final
+class RPrimitive(RType):
+    """Primitive type such as 'object' or 'int'.
+
+    These often have custom ops associated with them. The 'object'
+    primitive type can be used to hold arbitrary Python objects.
+
+    Different primitive types have different representations, and
+    primitives may be unboxed or boxed. Primitive types don't need to
+    directly correspond to Python types, but most do.
+
+    NOTE: All supported primitive types are defined below
+    (e.g. object_rprimitive).
+    """
+
+    # Map from primitive names to primitive types and is used by deserialization
+    primitive_map: ClassVar[dict[str, RPrimitive]] = {}
+
+    def __init__(
+        self,
+        name: str,
+        *,
+        is_unboxed: bool,
+        is_refcounted: bool,
+        is_native_int: bool = False,
+        is_signed: bool = False,
+        ctype: str = "PyObject *",
+        size: int = PLATFORM_SIZE,
+        error_overlap: bool = False,
+        may_be_immortal: bool = True,
+        dependencies: tuple[Dependency, ...] | None = None,
+    ) -> None:
+        RPrimitive.primitive_map[name] = self
+
+        self.name = name
+        self.is_unboxed = is_unboxed
+        self.is_refcounted = is_refcounted
+        self.is_native_int = is_native_int
+        self.is_signed = is_signed
+        self._ctype = ctype
+        self.size = size
+        self.error_overlap = error_overlap
+        self._may_be_immortal = may_be_immortal and HAVE_IMMORTAL
+        self.dependencies = dependencies
+        if ctype == "CPyTagged":
+            self.c_undefined = "CPY_INT_TAG"
+        elif ctype in ("int16_t", "int32_t", "int64_t"):
+            # This is basically an arbitrary value that is pretty
+            # unlikely to overlap with a real value.
+            self.c_undefined = "-113"
+        elif ctype == "CPyPtr":
+            # TODO: Invent an overlapping error value?
+            self.c_undefined = "0"
+        elif ctype.endswith("*"):
+            # Boxed and pointer types use the null pointer as the error value.
+            self.c_undefined = "NULL"
+        elif ctype == "char":
+            self.c_undefined = "2"
+        elif ctype == "double":
+            self.c_undefined = "-113.0"
+        elif ctype in ("uint8_t", "uint16_t", "uint32_t", "uint64_t"):
+            self.c_undefined = "239"  # An arbitrary number
+        else:
+            assert False, "Unrecognized ctype: %r" % ctype
+
+    def accept(self, visitor: RTypeVisitor[T]) -> T:
+        return visitor.visit_rprimitive(self)
+
+    @property
+    def may_be_immortal(self) -> bool:
+        return self._may_be_immortal
+
+    def serialize(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return "<RPrimitive %s>" % self.name
+
+    def __eq__(self, other: object) -> TypeGuard[RPrimitive]:
+        return isinstance(other, RPrimitive) and other.name == self.name
+
+    def __hash__(self) -> int:
+        return hash(self.name)
+
+
+# NOTE: All the supported instances of RPrimitive are defined
+# below. Use these instead of creating new instances.
+
+# Used to represent arbitrary objects and dynamically typed (Any)
+# values. There are various ops that let you perform generic, runtime
+# checked operations on these (that match Python semantics). See the
+# ops in mypyc.primitives.misc_ops, including py_getattr_op,
+# py_call_op, and many others.
+#
+# If there is no more specific RType available for some value, we fall
+# back to using this type.
+#
+# NOTE: Even though this is very flexible, this type should be used as
+# little as possible, as generic ops are typically slow. Other types,
+# including other primitive types and RInstance, are usually much
+# faster.
+object_rprimitive: Final = RPrimitive("builtins.object", is_unboxed=False, is_refcounted=True)
+
+# represents a low level pointer of an object
+object_pointer_rprimitive: Final = RPrimitive(
+    "object_ptr", is_unboxed=False, is_refcounted=False, ctype="PyObject **"
+)
+
+# Similar to object_primitive, but does not use automatic reference
+# counting. Useful for temporaries.
+object_non_refcounted_rprimitive: Final = RPrimitive(
+    "builtins.object_nrc", is_unboxed=False, is_refcounted=False
+)
+
+# Arbitrary-precision integer (corresponds to Python 'int'). Small
+# enough values are stored unboxed, while large integers are
+# represented as a tagged pointer to a Python 'int' PyObject. The
+# lowest bit is used as the tag to decide whether it is a signed
+# unboxed value (shifted left by one) or a PyObject * pointing to an
+# 'int' object. Pointers have the least significant bit set.
+#
+# The undefined/error value is the null pointer (1 -- only the least
+# significant bit is set)).
+#
+# This cannot represent a subclass of int. An instance of a subclass
+# of int is coerced to the corresponding 'int' value.
+int_rprimitive: Final = RPrimitive(
+    "builtins.int", is_unboxed=True, is_refcounted=True, ctype="CPyTagged"
+)
+
+# An unboxed integer. The representation is the same as for unboxed
+# int_rprimitive (shifted left by one). These can be used when an
+# integer is known to be small enough to fit size_t (CPyTagged).
+short_int_rprimitive: Final = RPrimitive(
+    "short_int", is_unboxed=True, is_refcounted=False, ctype="CPyTagged"
+)
+
+# Low level integer types (correspond to C integer types)
+
+int16_rprimitive: Final = RPrimitive(
+    "i16",
+    is_unboxed=True,
+    is_refcounted=False,
+    is_native_int=True,
+    is_signed=True,
+    ctype="int16_t",
+    size=2,
+    error_overlap=True,
+)
+int32_rprimitive: Final = RPrimitive(
+    "i32",
+    is_unboxed=True,
+    is_refcounted=False,
+    is_native_int=True,
+    is_signed=True,
+    ctype="int32_t",
+    size=4,
+    error_overlap=True,
+)
+int64_rprimitive: Final = RPrimitive(
+    "i64",
+    is_unboxed=True,
+    is_refcounted=False,
+    is_native_int=True,
+    is_signed=True,
+    ctype="int64_t",
+    size=8,
+    error_overlap=True,
+)
+uint8_rprimitive: Final = RPrimitive(
+    "u8",
+    is_unboxed=True,
+    is_refcounted=False,
+    is_native_int=True,
+    is_signed=False,
+    ctype="uint8_t",
+    size=1,
+    error_overlap=True,
+)
+
+# The following unsigned native int types (u16, u32, u64) are not
+# exposed to the user. They are for internal use within mypyc only.
+
+u16_rprimitive: Final = RPrimitive(
+    "u16",
+    is_unboxed=True,
+    is_refcounted=False,
+    is_native_int=True,
+    is_signed=False,
+    ctype="uint16_t",
+    size=2,
+    error_overlap=True,
+)
+uint32_rprimitive: Final = RPrimitive(
+    "u32",
+    is_unboxed=True,
+    is_refcounted=False,
+    is_native_int=True,
+    is_signed=False,
+    ctype="uint32_t",
+    size=4,
+    error_overlap=True,
+)
+uint64_rprimitive: Final = RPrimitive(
+    "u64",
+    is_unboxed=True,
+    is_refcounted=False,
+    is_native_int=True,
+    is_signed=False,
+    ctype="uint64_t",
+    size=8,
+    error_overlap=True,
+)
+
+# The C 'int' type
+c_int_rprimitive = int32_rprimitive
+
+if IS_32_BIT_PLATFORM:
+    c_size_t_rprimitive = uint32_rprimitive
+    c_pyssize_t_rprimitive = RPrimitive(
+        "native_int",
+        is_unboxed=True,
+        is_refcounted=False,
+        is_native_int=True,
+        is_signed=True,
+        ctype="int32_t",
+        size=4,
+    )
+else:
+    c_size_t_rprimitive = uint64_rprimitive
+    c_pyssize_t_rprimitive = RPrimitive(
+        "native_int",
+        is_unboxed=True,
+        is_refcounted=False,
+        is_native_int=True,
+        is_signed=True,
+        ctype="int64_t",
+        size=8,
+    )
+
+# Untyped pointer, represented as integer in the C backend
+pointer_rprimitive: Final = RPrimitive("ptr", is_unboxed=True, is_refcounted=False, ctype="CPyPtr")
+
+# Untyped pointer, represented as void * in the C backend
+c_pointer_rprimitive: Final = RPrimitive(
+    "c_ptr", is_unboxed=False, is_refcounted=False, ctype="void *"
+)
+
+cstring_rprimitive: Final = RPrimitive(
+    "cstring", is_unboxed=True, is_refcounted=False, ctype="const char *"
+)
+
+# The type corresponding to mypyc.common.BITMAP_TYPE
+bitmap_rprimitive: Final = uint32_rprimitive
+
+# Floats are represent as 'float' PyObject * values. (In the future
+# we'll likely switch to a more efficient, unboxed representation.)
+float_rprimitive: Final = RPrimitive(
+    "builtins.float",
+    is_unboxed=True,
+    is_refcounted=False,
+    ctype="double",
+    size=8,
+    error_overlap=True,
+)
+
+# An unboxed Python bool value. This actually has three possible values
+# (0 -> False, 1 -> True, 2 -> error). If you only need True/False, use
+# bit_rprimitive instead.
+bool_rprimitive: Final = RPrimitive(
+    "builtins.bool", is_unboxed=True, is_refcounted=False, ctype="char", size=1
+)
+
+# A low-level boolean value with two possible values: 0 and 1. Any
+# other value results in undefined behavior. Undefined or error values
+# are not supported.
+bit_rprimitive: Final = RPrimitive(
+    "bit", is_unboxed=True, is_refcounted=False, ctype="char", size=1
+)
+
+# The 'None' value. The possible values are 0 -> None and 2 -> error.
+none_rprimitive: Final = RPrimitive(
+    "builtins.None", is_unboxed=True, is_refcounted=False, ctype="char", size=1
+)
+
+# Python list object (or an instance of a subclass of list). These could be
+# immortal, but since this is expected to be very rare, and the immortality checks
+# can be pretty expensive for lists, we treat lists as non-immortal.
+list_rprimitive: Final = RPrimitive(
+    "builtins.list", is_unboxed=False, is_refcounted=True, may_be_immortal=False
+)
+
+# Python dict object (or an instance of a subclass of dict).
+dict_rprimitive: Final = RPrimitive("builtins.dict", is_unboxed=False, is_refcounted=True)
+
+# Python set object (or an instance of a subclass of set).
+set_rprimitive: Final = RPrimitive("builtins.set", is_unboxed=False, is_refcounted=True)
+
+# Python frozenset object (or an instance of a subclass of frozenset).
+frozenset_rprimitive: Final = RPrimitive(
+    "builtins.frozenset", is_unboxed=False, is_refcounted=True
+)
+
+# Python str object. At the C layer, str is referred to as unicode
+# (PyUnicode).
+str_rprimitive: Final = RPrimitive("builtins.str", is_unboxed=False, is_refcounted=True)
+
+# Python bytes object.
+bytes_rprimitive: Final = RPrimitive("builtins.bytes", is_unboxed=False, is_refcounted=True)
+
+# Python bytearray object.
+bytearray_rprimitive: Final = RPrimitive(
+    "builtins.bytearray", is_unboxed=False, is_refcounted=True
+)
+
+# Tuple of an arbitrary length (corresponds to Tuple[t, ...], with
+# explicit '...').
+tuple_rprimitive: Final = RPrimitive("builtins.tuple", is_unboxed=False, is_refcounted=True)
+
+# Python range object.
+range_rprimitive: Final = RPrimitive("builtins.range", is_unboxed=False, is_refcounted=True)
+
+KNOWN_NATIVE_TYPES: Final = {
+    name: RPrimitive(name, is_unboxed=False, is_refcounted=True, dependencies=(LIBRT_STRINGS,))
+    for name in [
+        "librt.internal.WriteBuffer",
+        "librt.internal.ReadBuffer",
+        "librt.strings.BytesWriter",
+        "librt.strings.StringWriter",
+    ]
+}
+
+bytes_writer_rprimitive: Final = KNOWN_NATIVE_TYPES["librt.strings.BytesWriter"]
+string_writer_rprimitive: Final = KNOWN_NATIVE_TYPES["librt.strings.StringWriter"]
+
+
+def is_native_rprimitive(rtype: RType) -> bool:
+    return isinstance(rtype, RPrimitive) and rtype.name in KNOWN_NATIVE_TYPES
+
+
+def is_tagged(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is int_rprimitive or rtype is short_int_rprimitive
+
+
+def is_any_int(rtype: RType) -> bool:
+    return is_tagged(rtype) or is_int32_rprimitive(rtype) or is_int64_rprimitive(rtype)
+
+
+def is_int_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is int_rprimitive
+
+
+def is_short_int_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is short_int_rprimitive
+
+
+def is_int16_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is int16_rprimitive
+
+
+def is_int32_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is int32_rprimitive or (
+        rtype is c_pyssize_t_rprimitive and rtype._ctype == "int32_t"
+    )
+
+
+def is_int64_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is int64_rprimitive or (
+        rtype is c_pyssize_t_rprimitive and rtype._ctype == "int64_t"
+    )
+
+
+def is_fixed_width_rtype(rtype: RType) -> TypeGuard[RPrimitive]:
+    return (
+        is_int64_rprimitive(rtype)
+        or is_int32_rprimitive(rtype)
+        or is_int16_rprimitive(rtype)
+        or is_uint8_rprimitive(rtype)
+    )
+
+
+def is_uint8_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is uint8_rprimitive
+
+
+def is_uint32_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is uint32_rprimitive
+
+
+def is_uint64_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is uint64_rprimitive
+
+
+def is_c_py_ssize_t_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is c_pyssize_t_rprimitive
+
+
+def is_pointer_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return rtype is pointer_rprimitive
+
+
+def is_float_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.float"
+
+
+def is_bool_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.bool"
+
+
+def is_bit_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "bit"
+
+
+def is_bool_or_bit_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return is_bool_rprimitive(rtype) or is_bit_rprimitive(rtype)
+
+
+def is_object_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.object"
+
+
+def is_none_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.None"
+
+
+def is_list_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.list"
+
+
+def is_dict_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.dict"
+
+
+def is_set_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.set"
+
+
+def is_frozenset_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.frozenset"
+
+
+def is_str_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.str"
+
+
+def is_bytes_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.bytes"
+
+
+def is_bytearray_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.bytearray"
+
+
+def is_tuple_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.tuple"
+
+
+def is_range_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and rtype.name == "builtins.range"
+
+
+def is_sequence_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return isinstance(rtype, RPrimitive) and (
+        is_list_rprimitive(rtype)
+        or is_tuple_rprimitive(rtype)
+        or is_str_rprimitive(rtype)
+        or is_bytes_rprimitive(rtype)
+        or is_bytearray_rprimitive(rtype)
+    )
+
+
+def is_immutable_rprimitive(rtype: RType) -> TypeGuard[RPrimitive]:
+    return (
+        is_str_rprimitive(rtype)
+        or is_bytes_rprimitive(rtype)
+        or is_tuple_rprimitive(rtype)
+        or is_frozenset_rprimitive(rtype)
+    )
+
+
+class TupleNameVisitor(RTypeVisitor[str]):
+    """Produce a tuple name based on the concrete representations of types."""
+
+    def visit_rinstance(self, t: RInstance) -> str:
+        return "O"
+
+    def visit_rvec(self, t: RVec) -> str:
+        if isinstance(t.item_type, RVec):
+            # All nested vecs share a representation
+            return "Vv"
+        return "V" + t.item_type.accept(self)
+
+    def visit_runion(self, t: RUnion) -> str:
+        return "O"
+
+    def visit_rprimitive(self, t: RPrimitive) -> str:
+        if t._ctype == "CPyTagged":
+            return "I"
+        elif t._ctype == "char":
+            return "C"
+        elif t._ctype == "int64_t":
+            return "8"  # "8 byte integer"
+        elif t._ctype == "int32_t":
+            return "4"  # "4 byte integer"
+        elif t._ctype == "int16_t":
+            return "2"  # "2 byte integer"
+        elif t._ctype == "uint8_t":
+            return "U1"  # "1 byte unsigned integer"
+        elif t._ctype == "double":
+            return "F"
+        assert not t.is_unboxed, f"{t} unexpected unboxed type"
+        return "O"
+
+    def visit_rtuple(self, t: RTuple) -> str:
+        parts = [elem.accept(self) for elem in t.types]
+        return "T{}{}".format(len(parts), "".join(parts))
+
+    def visit_rstruct(self, t: RStruct) -> str:
+        if t.name == "VecNestedBufItem":
+            return "Vi"
+        assert False, "RStruct not supported in tuple"
+
+    def visit_rarray(self, t: RArray) -> str:
+        assert False, "RArray not supported in tuple"
+
+    def visit_rvoid(self, t: RVoid) -> str:
+        assert False, "rvoid in tuple?"
+
+
+@final
+class RTuple(RType):
+    """Fixed-length unboxed tuple (represented as a C struct).
+
+    These are used to represent mypy TupleType values (fixed-length
+    Python tuples). Since this is unboxed, the identity of a tuple
+    object is not preserved within compiled code. If the identity of a
+    tuple is important, or there is a need to have multiple references
+    to a single tuple object, a variable-length tuple should be used
+    (tuple_rprimitive or Tuple[T, ...]  with explicit '...'), as they
+    are boxed.
+
+    These aren't immutable. However, user code won't be able to mutate
+    individual tuple items.
+    """
+
+    is_unboxed = True
+
+    def __init__(self, types: list[RType]) -> None:
+        self.name = "tuple"
+        self.types = tuple(types)
+        self.is_refcounted = any(t.is_refcounted for t in self.types)
+        # Generate a unique id which is used in naming corresponding C identifiers.
+        # This is necessary since C does not have anonymous structural type equivalence
+        # in the same way python can just assign a Tuple[int, bool] to a Tuple[int, bool].
+        self.unique_id = self.accept(TupleNameVisitor())
+        # Nominally the max c length is 31 chars, but I'm not honestly worried about this.
+        self.struct_name = f"tuple_{self.unique_id}"
+        self._ctype = f"{self.struct_name}"
+        self.error_overlap = all(t.error_overlap for t in self.types) and bool(self.types)
+
+    def accept(self, visitor: RTypeVisitor[T]) -> T:
+        return visitor.visit_rtuple(self)
+
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
+    def __str__(self) -> str:
+        return "tuple[%s]" % ", ".join(str(typ) for typ in self.types)
+
+    def __repr__(self) -> str:
+        return "<RTuple %s>" % ", ".join(repr(typ) for typ in self.types)
+
+    def __eq__(self, other: object) -> TypeGuard[RTuple]:
+        return isinstance(other, RTuple) and self.types == other.types
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.types))
+
+    def serialize(self) -> JsonDict:
+        types = [x.serialize() for x in self.types]
+        return {".class": "RTuple", "types": types}
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> RTuple:
+        types = [deserialize_type(t, ctx) for t in data["types"]]
+        return RTuple(types)
+
+
+# Exception tuple: (exception class, exception instance, traceback object)
+exc_rtuple = RTuple([object_rprimitive, object_rprimitive, object_rprimitive])
+
+# Dictionary iterator tuple: (should continue, internal offset, key, value)
+# See mypyc.irbuild.for_helpers.ForDictionaryCommon for more details.
+dict_next_rtuple_pair = RTuple(
+    [bool_rprimitive, short_int_rprimitive, object_rprimitive, object_rprimitive]
+)
+# Same as above but just for key or value.
+dict_next_rtuple_single = RTuple([bool_rprimitive, short_int_rprimitive, object_rprimitive])
+
+
+def compute_rtype_alignment(typ: RType) -> int:
+    """Compute alignment of a given type based on platform alignment rule"""
+    platform_alignment = PLATFORM_SIZE
+    if isinstance(typ, RPrimitive):
+        return typ.size
+    elif isinstance(typ, RInstance):
+        return platform_alignment
+    elif isinstance(typ, RUnion):
+        return platform_alignment
+    elif isinstance(typ, RArray):
+        return compute_rtype_alignment(typ.item_type)
+    else:
+        if isinstance(typ, RTuple):
+            items = list(typ.types)
+        elif isinstance(typ, RStruct):
+            items = typ.types
+        else:
+            assert False, "invalid rtype for computing alignment"
+        max_alignment = max(compute_rtype_alignment(item) for item in items)
+        return max_alignment
+
+
+def compute_rtype_size(typ: RType) -> int:
+    """Compute unaligned size of rtype"""
+    if isinstance(typ, RPrimitive):
+        return typ.size
+    elif isinstance(typ, RTuple):
+        return compute_aligned_offsets_and_size(list(typ.types))[1]
+    elif isinstance(typ, RUnion):
+        return PLATFORM_SIZE
+    elif isinstance(typ, RStruct):
+        return compute_aligned_offsets_and_size(typ.types)[1]
+    elif isinstance(typ, RInstance):
+        return PLATFORM_SIZE
+    elif isinstance(typ, RArray):
+        alignment = compute_rtype_alignment(typ)
+        aligned_size = (compute_rtype_size(typ.item_type) + (alignment - 1)) & ~(alignment - 1)
+        return aligned_size * typ.length
+    else:
+        assert False, "invalid rtype for computing size"
+
+
+def compute_aligned_offsets_and_size(types: list[RType]) -> tuple[list[int], int]:
+    """Compute offsets and total size of a list of types after alignment
+
+    Note that the types argument are types of values that are stored
+    sequentially with platform default alignment.
+    """
+    unaligned_sizes = [compute_rtype_size(typ) for typ in types]
+    alignments = [compute_rtype_alignment(typ) for typ in types]
+
+    current_offset = 0
+    offsets = []
+    final_size = 0
+    for i in range(len(unaligned_sizes)):
+        offsets.append(current_offset)
+        if i + 1 < len(unaligned_sizes):
+            cur_size = unaligned_sizes[i]
+            current_offset += cur_size
+            next_alignment = alignments[i + 1]
+            # compute aligned offset,
+            # check https://en.wikipedia.org/wiki/Data_structure_alignment for more information
+            current_offset = (current_offset + (next_alignment - 1)) & -next_alignment
+        else:
+            struct_alignment = max(alignments)
+            final_size = current_offset + unaligned_sizes[i]
+            final_size = (final_size + (struct_alignment - 1)) & -struct_alignment
+    return offsets, final_size
+
+
+@final
+class RStruct(RType):
+    """C struct type"""
+
+    def __init__(self, name: str, names: list[str], types: list[RType]) -> None:
+        self.name = name
+        self.names = names
+        self.types = types
+        self.is_refcounted = any(t.is_refcounted for t in self.types)
+
+        # generate dummy names
+        if len(self.names) < len(self.types):
+            for i in range(len(self.types) - len(self.names)):
+                self.names.append("_item" + str(i))
+        self.offsets, self.size = compute_aligned_offsets_and_size(types)
+        self._ctype = name
+
+    def field_type(self, name: str) -> RType:
+        for n, t in zip(self.names, self.types):
+            if n == name:
+                return t
+        assert False, f"{self.name} has no field '{name}'"
+
+    def accept(self, visitor: RTypeVisitor[T]) -> T:
+        return visitor.visit_rstruct(self)
+
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
+    def __str__(self) -> str:
+        # if not tuple(unnamed structs)
+        return "{}{{{}}}".format(
+            self.name,
+            ", ".join(name + ":" + str(typ) for name, typ in zip(self.names, self.types)),
+        )
+
+    def __repr__(self) -> str:
+        return "<RStruct {}{{{}}}>".format(
+            self.name,
+            ", ".join(name + ":" + repr(typ) for name, typ in zip(self.names, self.types)),
+        )
+
+    def __eq__(self, other: object) -> TypeGuard[RStruct]:
+        return (
+            isinstance(other, RStruct)
+            and self.name == other.name
+            and self.names == other.names
+            and self.types == other.types
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.name, tuple(self.names), tuple(self.types)))
+
+    def serialize(self) -> JsonDict:
+        assert False
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> RStruct:
+        assert False
+
+
+@final
+class RInstance(RType):
+    """Instance of user-defined class (compiled to C extension class).
+
+    The runtime representation is 'PyObject *', and these are always
+    boxed and thus reference-counted.
+
+    These support fast method calls and fast attribute access using
+    vtables, and they usually use a dict-free, struct-based
+    representation of attributes. Method calls and attribute access
+    can skip the vtable if we know that there is no overriding.
+
+    These are also sometimes called 'native' types, since these have
+    the most efficient representation and ops (along with certain
+    RPrimitive types and RTuple).
+    """
+
+    is_unboxed = False
+
+    def __init__(self, class_ir: ClassIR) -> None:
+        # name is used for formatting the name in messages and debug output
+        # so we want the fullname for precision.
+        self.name = class_ir.fullname
+        self.class_ir = class_ir
+        self._ctype = "PyObject *"
+
+    def accept(self, visitor: RTypeVisitor[T]) -> T:
+        return visitor.visit_rinstance(self)
+
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
+    def struct_name(self, names: NameGenerator) -> str:
+        return self.class_ir.struct_name(names)
+
+    def getter_index(self, name: str) -> int:
+        return self.class_ir.vtable_entry(name)
+
+    def setter_index(self, name: str) -> int:
+        return self.getter_index(name) + 1
+
+    def method_index(self, name: str) -> int:
+        return self.class_ir.vtable_entry(name)
+
+    def attr_type(self, name: str) -> RType:
+        return self.class_ir.attr_type(name)
+
+    def __repr__(self) -> str:
+        return "<RInstance %s>" % self.name
+
+    def __eq__(self, other: object) -> TypeGuard[RInstance]:
+        return isinstance(other, RInstance) and other.name == self.name
+
+    def __hash__(self) -> int:
+        return hash(self.name)
+
+    def serialize(self) -> str:
+        return self.name
+
+
+@final
+class RVec(RType):
+    """librt.vecs.vec[T]"""
+
+    is_unboxed = True
+
+    def __init__(self, item_type: RType) -> None:
+        self.name = "vec[%s]" % item_type
+        self.item_type = item_type
+        self.names = ["len", "buf"]
+        self.dependencies = (LIBRT_VECS,)
+        if isinstance(item_type, RUnion):
+            non_opt = optional_value_type(item_type)
+        else:
+            non_opt = item_type
+        if item_type in vec_buf_types:
+            self._ctype = vec_c_types[item_type]
+            self.buf_type = vec_buf_types[item_type]
+            self.types = [c_pyssize_t_rprimitive, self.buf_type]
+        elif isinstance(non_opt, RVec):
+            self._ctype = "VecNested"
+            self.types = [c_pyssize_t_rprimitive, VecTBufObject]
+            self.buf_type = VecNestedBufObject
+        else:
+            self._ctype = "VecT"
+            self.types = [c_pyssize_t_rprimitive, VecTBufObject]
+            self.buf_type = VecTBufObject
+
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
+    def unwrap_item_type(self) -> RPrimitive | RInstance:
+        """Return the non-optional value (non-vec) item type in a potentially nested vec."""
+        item_type = self.item_type
+        while True:
+            if isinstance(item_type, RUnion):
+                value_type = optional_value_type(item_type)
+                assert value_type is not None
+                item_type = value_type
+            elif isinstance(item_type, RVec):
+                item_type = item_type.item_type
+            elif isinstance(item_type, (RPrimitive, RInstance)):
+                return item_type
+            else:
+                assert False, f"unexpected item type: {self.item_type}"
+
+    def is_optional(self) -> bool:
+        item_type = self.item_type
+        if isinstance(item_type, RUnion):
+            return True
+        elif isinstance(item_type, RVec):
+            return item_type.is_optional()
+        return False
+
+    def depth(self) -> int:
+        item_type = self.item_type
+        if isinstance(item_type, RUnion):
+            value_type = optional_value_type(item_type)
+            assert value_type is not None
+            item_type = value_type
+        if isinstance(item_type, RVec):
+            return 1 + item_type.depth()
+        return 0
+
+    def field_type(self, name: str) -> RType:
+        if name == "len":
+            return c_pyssize_t_rprimitive
+        elif name == "buf":
+            return object_rprimitive
+        assert False, f"RVec has no field '{name}'"
+
+    def accept(self, visitor: RTypeVisitor[T]) -> T:
+        return visitor.visit_rvec(self)
+
+    def __str__(self) -> str:
+        if self.is_optional() and self.depth() == 0:
+            type_str = f"{self.unwrap_item_type()} | None"
+        else:
+            type_str = str(self.item_type)
+        return f"vec[{type_str}]"
+
+    def __repr__(self) -> str:
+        return "<RVec[%s]>" % self.item_type
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, RVec) and other.item_type == self.item_type
+
+    def __hash__(self) -> int:
+        return hash(self.item_type) ^ 1
+
+    def serialize(self) -> JsonDict:
+        return {".class": "RVec", "item_type": self.item_type.serialize()}
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> RVec:
+        return RVec(deserialize_type(data["item_type"], ctx))
+
+
+@final
+class RUnion(RType):
+    """union[x, ..., y]"""
+
+    is_unboxed = False
+
+    def __init__(self, items: list[RType]) -> None:
+        self.name = "union"
+        self.items = items
+        self.items_set = frozenset(items)
+        self._ctype = "PyObject *"
+
+    @staticmethod
+    def make_simplified_union(items: list[RType]) -> RType:
+        """Return a normalized union that covers the given items.
+
+        Flatten nested unions and remove duplicate items.
+
+        Overlapping items are *not* simplified. For example,
+        [object, str] will not be simplified.
+        """
+        items = flatten_nested_unions(items)
+        assert items
+
+        unique_items = dict.fromkeys(items)
+        if len(unique_items) > 1:
+            return RUnion(list(unique_items))
+        else:
+            return next(iter(unique_items))
+
+    def accept(self, visitor: RTypeVisitor[T]) -> T:
+        return visitor.visit_runion(self)
+
+    @property
+    def may_be_immortal(self) -> bool:
+        return any(item.may_be_immortal for item in self.items)
+
+    def __repr__(self) -> str:
+        return "<RUnion %s>" % ", ".join(str(item) for item in self.items)
+
+    def __str__(self) -> str:
+        return "union[%s]" % ", ".join(str(item) for item in self.items)
+
+    # We compare based on the set because order in a union doesn't matter
+    def __eq__(self, other: object) -> TypeGuard[RUnion]:
+        return isinstance(other, RUnion) and self.items_set == other.items_set
+
+    def __hash__(self) -> int:
+        return hash(("union", self.items_set))
+
+    def serialize(self) -> JsonDict:
+        types = [x.serialize() for x in self.items]
+        return {".class": "RUnion", "types": types}
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> RUnion:
+        types = [deserialize_type(t, ctx) for t in data["types"]]
+        return RUnion(types)
+
+
+def flatten_nested_unions(types: list[RType]) -> list[RType]:
+    if not any(isinstance(t, RUnion) for t in types):
+        return types  # Fast path
+
+    flat_items: list[RType] = []
+    for t in types:
+        if isinstance(t, RUnion):
+            flat_items.extend(flatten_nested_unions(t.items))
+        else:
+            flat_items.append(t)
+    return flat_items
+
+
+def optional_value_type(rtype: RType) -> RType | None:
+    """If rtype is the union of none_rprimitive and another type X, return X.
+
+    Otherwise, return None.
+    """
+    if isinstance(rtype, RUnion) and len(rtype.items) == 2:
+        if rtype.items[0] == none_rprimitive:
+            return rtype.items[1]
+        elif rtype.items[1] == none_rprimitive:
+            return rtype.items[0]
+    return None
+
+
+def is_optional_type(rtype: RType) -> TypeGuard[RUnion]:
+    """Is rtype an optional type with exactly two union items?"""
+    return optional_value_type(rtype) is not None
+
+
+@final
+class RArray(RType):
+    """Fixed-length C array type (for example, int[5]).
+
+    Note that the implementation is a bit limited, and these can basically
+    be only used for local variables that are initialized in one location.
+    """
+
+    def __init__(self, item_type: RType, length: int) -> None:
+        self.item_type = item_type
+        # Number of items
+        self.length = length
+        self.is_refcounted = False
+
+    def accept(self, visitor: RTypeVisitor[T]) -> T:
+        return visitor.visit_rarray(self)
+
+    @property
+    def may_be_immortal(self) -> bool:
+        return False
+
+    def __str__(self) -> str:
+        return f"{self.item_type}[{self.length}]"
+
+    def __repr__(self) -> str:
+        return f"<RArray {self.item_type!r}[{self.length}]>"
+
+    def __eq__(self, other: object) -> TypeGuard[RArray]:
+        return (
+            isinstance(other, RArray)
+            and self.item_type == other.item_type
+            and self.length == other.length
+        )
+
+    def __hash__(self) -> int:
+        return hash((self.item_type, self.length))
+
+    def serialize(self) -> JsonDict:
+        assert False
+
+    @classmethod
+    def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> RArray:
+        assert False
+
+
+PyObject = RStruct(
+    name="PyObject",
+    names=["ob_refcnt", "ob_type"],
+    types=[c_pyssize_t_rprimitive, pointer_rprimitive],
+)
+
+PyVarObject = RStruct(
+    name="PyVarObject", names=["ob_base", "ob_size"], types=[PyObject, c_pyssize_t_rprimitive]
+)
+
+setentry = RStruct(
+    name="setentry", names=["key", "hash"], types=[pointer_rprimitive, c_pyssize_t_rprimitive]
+)
+
+smalltable = RStruct(name="smalltable", names=[], types=[setentry] * 8)
+
+PySetObject = RStruct(
+    name="PySetObject",
+    names=[
+        "ob_base",
+        "fill",
+        "used",
+        "mask",
+        "table",
+        "hash",
+        "finger",
+        "smalltable",
+        "weakreflist",
+    ],
+    types=[
+        PyObject,
+        c_pyssize_t_rprimitive,
+        c_pyssize_t_rprimitive,
+        c_pyssize_t_rprimitive,
+        pointer_rprimitive,
+        c_pyssize_t_rprimitive,
+        c_pyssize_t_rprimitive,
+        smalltable,
+        pointer_rprimitive,
+    ],
+)
+
+PyListObject = RStruct(
+    name="PyListObject",
+    names=["ob_base", "ob_item", "allocated"],
+    types=[PyVarObject, pointer_rprimitive, c_pyssize_t_rprimitive],
+)
+
+
+def check_native_int_range(rtype: RPrimitive, n: int) -> bool:
+    """Is n within the range of a native, fixed-width int type?
+
+    Assume the type is a fixed-width int type.
+    """
+    if not rtype.is_signed:
+        return 0 <= n < (1 << (8 * rtype.size))
+    else:
+        limit = 1 << (rtype.size * 8 - 1)
+        return -limit <= n < limit
+
+
+# Buffers for vec item types that have a packed representation
+#
+# Note that the 'items' fields are variable-length arrays, and mypyc IR isn't
+# able to represent these, so the field type is omitted for now.
+
+VecI64BufObject = RStruct(
+    name="VecI64BufObject",
+    names=["ob_base", "len", "items"],
+    types=[PyVarObject, int64_rprimitive],
+)
+
+VecI32BufObject = RStruct(
+    name="VecI32BufObject",
+    names=["ob_base", "len", "items"],
+    types=[PyVarObject, int64_rprimitive],
+)
+
+VecI16BufObject = RStruct(
+    name="VecI16BufObject",
+    names=["ob_base", "len", "items"],
+    types=[PyVarObject, int64_rprimitive],
+)
+
+VecU8BufObject = RStruct(
+    name="VecU8BufObject", names=["ob_base", "len", "items"], types=[PyVarObject, int64_rprimitive]
+)
+
+VecFloatBufObject = RStruct(
+    name="VecFloatBufObject",
+    names=["ob_base", "len", "items"],
+    types=[PyVarObject, int64_rprimitive],
+)
+
+VecBoolBufObject = RStruct(
+    name="VecBoolBufObject",
+    names=["ob_base", "len", "items"],
+    types=[PyVarObject, int64_rprimitive],
+)
+
+
+# Struct type for vec[i64] (in most cases use RVec instead).
+VecI64 = RStruct(
+    name="VecI64", names=["len", "buf"], types=[c_pyssize_t_rprimitive, object_rprimitive]
+)
+
+
+# Buffer for vec[t]
+VecTBufObject = RStruct(
+    name="VecTBufObject",
+    names=["ob_base", "item_type", "items"],
+    types=[PyVarObject, c_pyssize_t_rprimitive, object_rprimitive],
+)
+
+# Struct type for vec[t] (in most cases use RVec instead).
+VecT = RStruct(
+    name="VecT", names=["len", "buf"], types=[c_pyssize_t_rprimitive, object_rprimitive]
+)
+
+VecNestedBufItem = RStruct(
+    name="VecNestedBufItem",
+    names=["len", "buf"],
+    types=[c_pyssize_t_rprimitive, object_non_refcounted_rprimitive],
+)
+
+# Buffer for vec[vec[t]]
+VecNestedBufObject = RStruct(
+    name="VecNestedBufObject",
+    names=["ob_base", "item_type", "depth", "optionals", "items"],
+    types=[
+        PyVarObject,
+        c_pyssize_t_rprimitive,
+        int32_rprimitive,
+        int32_rprimitive,
+        VecNestedBufItem,
+    ],
+)
+
+# Struct type for vec[vec[...]] (in most cases use RVec instead).
+VecNested = RStruct(
+    name="VecNested", names=["len", "buf"], types=[c_pyssize_t_rprimitive, object_rprimitive]
+)
+
+VecNestedBufObject_rprimitive = RPrimitive(
+    "VecNestedBufObject_ptr", is_unboxed=False, is_refcounted=True, ctype="VecNestedBufObject *"
+)
+
+VecNestedPopResult = RStruct(
+    name="VecNestedPopResult", names=["vec", "item"], types=[VecNested, VecNestedBufItem]
+)
+
+
+vec_buf_types: Final[dict[RType, RStruct]] = {
+    int64_rprimitive: VecI64BufObject,
+    int32_rprimitive: VecI32BufObject,
+    int16_rprimitive: VecI16BufObject,
+    uint8_rprimitive: VecU8BufObject,
+    float_rprimitive: VecFloatBufObject,
+    bool_rprimitive: VecBoolBufObject,
+}
+
+vec_c_types: Final[dict[RType, str]] = {
+    int64_rprimitive: "VecI64",
+    int32_rprimitive: "VecI32",
+    int16_rprimitive: "VecI16",
+    uint8_rprimitive: "VecU8",
+    float_rprimitive: "VecFloat",
+    bool_rprimitive: "VecBool",
+}
+
+vec_api_fields: Final[dict[RType, str]] = {
+    int64_rprimitive: "i64",
+    int32_rprimitive: "i32",
+    int16_rprimitive: "i16",
+    uint8_rprimitive: "u8",
+    float_rprimitive: "float_",
+    bool_rprimitive: "bool_",
+}
+
+vec_api_by_item_type: Final[dict[RType, str]] = {
+    int64_rprimitive: "VecI64Api",
+    int32_rprimitive: "VecI32Api",
+    int16_rprimitive: "VecI16Api",
+    uint8_rprimitive: "VecU8Api",
+    float_rprimitive: "VecFloatApi",
+    bool_rprimitive: "VecBoolApi",
+}
+
+# These are special item type constants used in nested vecs to represent
+# item types with specialized representations. These must match definitions
+# in the vecs module (see VEC_ITEM_TYPE_I64 etc.).
+vec_item_type_tags: Final[dict[RType, int]] = {
+    int64_rprimitive: 2,
+    int32_rprimitive: 6,
+    int16_rprimitive: 10,
+    uint8_rprimitive: 14,
+    float_rprimitive: 18,
+    bool_rprimitive: 22,
+}