jaclang 0.7.33__py3-none-any.whl → 0.8.0__py3-none-any.whl

jaclang/vendor/mypyc/irbuild/builder.py

@@ -1,1394 +0,0 @@
-"""Builder class used to transform a mypy AST to the IR form.
-
-The IRBuilder class maintains transformation state and provides access
-to various helpers used to implement the transform.
-
-The top-level transform control logic is in mypyc.irbuild.main.
-
-mypyc.irbuild.visitor.IRBuilderVisitor is used to dispatch based on mypy
-AST node type to code that actually does the bulk of the work. For
-example, expressions are transformed in mypyc.irbuild.expression and
-functions are transformed in mypyc.irbuild.function.
-"""
-
-from __future__ import annotations
-
-from contextlib import contextmanager
-from typing import Any, Callable, Final, Iterator, Sequence, Union
-from typing_extensions import overload
-
-from mypy.build import Graph
-from mypy.maptype import map_instance_to_supertype
-from mypy.nodes import (
-    ARG_NAMED,
-    ARG_POS,
-    GDEF,
-    LDEF,
-    ArgKind,
-    CallExpr,
-    Decorator,
-    Expression,
-    FuncDef,
-    IndexExpr,
-    IntExpr,
-    Lvalue,
-    MemberExpr,
-    MypyFile,
-    NameExpr,
-    OpExpr,
-    OverloadedFuncDef,
-    RefExpr,
-    StarExpr,
-    Statement,
-    SymbolNode,
-    TupleExpr,
-    TypeAlias,
-    TypeInfo,
-    UnaryExpr,
-    Var,
-)
-from mypy.types import (
-    AnyType,
-    DeletedType,
-    Instance,
-    ProperType,
-    TupleType,
-    Type,
-    TypedDictType,
-    TypeOfAny,
-    UninhabitedType,
-    UnionType,
-    get_proper_type,
-)
-from mypy.util import module_prefix, split_target
-from mypy.visitor import ExpressionVisitor, StatementVisitor
-from mypyc.common import BITMAP_BITS, SELF_NAME, TEMP_ATTR_NAME
-from mypyc.crash import catch_errors
-from mypyc.errors import Errors
-from mypyc.ir.class_ir import ClassIR, NonExtClassInfo
-from mypyc.ir.func_ir import INVALID_FUNC_DEF, FuncDecl, FuncIR, FuncSignature, RuntimeArg
-from mypyc.ir.ops import (
-    NAMESPACE_MODULE,
-    Assign,
-    BasicBlock,
-    Branch,
-    ComparisonOp,
-    GetAttr,
-    InitStatic,
-    Integer,
-    IntOp,
-    LoadStatic,
-    Op,
-    RaiseStandardError,
-    Register,
-    SetAttr,
-    TupleGet,
-    Unreachable,
-    Value,
-)
-from mypyc.ir.rtypes import (
-    RInstance,
-    RTuple,
-    RType,
-    RUnion,
-    bitmap_rprimitive,
-    c_pyssize_t_rprimitive,
-    dict_rprimitive,
-    int_rprimitive,
-    is_float_rprimitive,
-    is_list_rprimitive,
-    is_none_rprimitive,
-    is_object_rprimitive,
-    is_tagged,
-    is_tuple_rprimitive,
-    none_rprimitive,
-    object_rprimitive,
-    str_rprimitive,
-)
-from mypyc.irbuild.context import FuncInfo, ImplicitClass
-from mypyc.irbuild.ll_builder import LowLevelIRBuilder
-from mypyc.irbuild.mapper import Mapper
-from mypyc.irbuild.nonlocalcontrol import (
-    BaseNonlocalControl,
-    GeneratorNonlocalControl,
-    LoopNonlocalControl,
-    NonlocalControl,
-)
-from mypyc.irbuild.prebuildvisitor import PreBuildVisitor
-from mypyc.irbuild.prepare import RegisterImplInfo
-from mypyc.irbuild.targets import (
-    AssignmentTarget,
-    AssignmentTargetAttr,
-    AssignmentTargetIndex,
-    AssignmentTargetRegister,
-    AssignmentTargetTuple,
-)
-from mypyc.irbuild.util import bytes_from_str, is_constant
-from mypyc.options import CompilerOptions
-from mypyc.primitives.dict_ops import dict_get_item_op, dict_set_item_op
-from mypyc.primitives.generic_ops import iter_op, next_op, py_setattr_op
-from mypyc.primitives.list_ops import list_get_item_unsafe_op, list_pop_last, to_list
-from mypyc.primitives.misc_ops import check_unpack_count_op, get_module_dict_op, import_op
-from mypyc.primitives.registry import CFunctionDescription, function_ops
-
-# These int binary operations can borrow their operands safely, since the
-# primitives take this into consideration.
-int_borrow_friendly_op: Final = {"+", "-", "==", "!=", "<", "<=", ">", ">="}
-
-
-class IRVisitor(ExpressionVisitor[Value], StatementVisitor[None]):
-    pass
-
-
-class UnsupportedException(Exception):
-    pass
-
-
-SymbolTarget = Union[AssignmentTargetRegister, AssignmentTargetAttr]
-
-
-class IRBuilder:
-    def __init__(
-        self,
-        current_module: str,
-        types: dict[Expression, Type],
-        graph: Graph,
-        errors: Errors,
-        mapper: Mapper,
-        pbv: PreBuildVisitor,
-        visitor: IRVisitor,
-        options: CompilerOptions,
-        singledispatch_impls: dict[FuncDef, list[RegisterImplInfo]],
-    ) -> None:
-        self.builder = LowLevelIRBuilder(errors, options)
-        self.builders = [self.builder]
-        self.symtables: list[dict[SymbolNode, SymbolTarget]] = [{}]
-        self.runtime_args: list[list[RuntimeArg]] = [[]]
-        self.function_name_stack: list[str] = []
-        self.class_ir_stack: list[ClassIR] = []
-        # Keep track of whether the next statement in a block is reachable
-        # or not, separately for each block nesting level
-        self.block_reachable_stack: list[bool] = [True]
-
-        self.current_module = current_module
-        self.mapper = mapper
-        self.types = types
-        self.graph = graph
-        self.ret_types: list[RType] = []
-        self.functions: list[FuncIR] = []
-        self.function_names: set[tuple[str | None, str]] = set()
-        self.classes: list[ClassIR] = []
-        self.final_names: list[tuple[str, RType]] = []
-        self.callable_class_names: set[str] = set()
-        self.options = options
-
-        # These variables keep track of the number of lambdas, implicit indices, and implicit
-        # iterators instantiated so we avoid name conflicts. The indices and iterators are
-        # instantiated from for-loops.
-        self.lambda_counter = 0
-        self.temp_counter = 0
-
-        # These variables are populated from the first-pass PreBuildVisitor.
-        self.free_variables = pbv.free_variables
-        self.prop_setters = pbv.prop_setters
-        self.encapsulating_funcs = pbv.encapsulating_funcs
-        self.nested_fitems = pbv.nested_funcs.keys()
-        self.fdefs_to_decorators = pbv.funcs_to_decorators
-        self.module_import_groups = pbv.module_import_groups
-
-        self.singledispatch_impls = singledispatch_impls
-
-        self.visitor = visitor
-
-        # This list operates similarly to a function call stack for nested functions. Whenever a
-        # function definition begins to be generated, a FuncInfo instance is added to the stack,
-        # and information about that function (e.g. whether it is nested, its environment class to
-        # be generated) is stored in that FuncInfo instance. When the function is done being
-        # generated, its corresponding FuncInfo is popped off the stack.
-        self.fn_info = FuncInfo(INVALID_FUNC_DEF, "", "")
-        self.fn_infos: list[FuncInfo] = [self.fn_info]
-
-        # This list operates as a stack of constructs that modify the
-        # behavior of nonlocal control flow constructs.
-        self.nonlocal_control: list[NonlocalControl] = []
-
-        self.errors = errors
-        # Notionally a list of all of the modules imported by the
-        # module being compiled, but stored as an OrderedDict so we
-        # can also do quick lookups.
-        self.imports: dict[str, None] = {}
-
-        self.can_borrow = False
-
-    # High-level control
-
-    def set_module(self, module_name: str, module_path: str) -> None:
-        """Set the name and path of the current module.
-
-        This must be called before transforming any AST nodes.
-        """
-        self.module_name = module_name
-        self.module_path = module_path
-        self.builder.set_module(module_name, module_path)
-
-    @overload
-    def accept(self, node: Expression, *, can_borrow: bool = False) -> Value: ...
-
-    @overload
-    def accept(self, node: Statement) -> None: ...
-
-    def accept(self, node: Statement | Expression, *, can_borrow: bool = False) -> Value | None:
-        """Transform an expression or a statement.
-
-        If can_borrow is true, prefer to generate a borrowed reference.
-        Borrowed references are faster since they don't require reference count
-        manipulation, but they are only safe to use in specific contexts.
-        """
-        with self.catch_errors(node.line):
-            if isinstance(node, Expression):
-                old_can_borrow = self.can_borrow
-                self.can_borrow = can_borrow
-                try:
-                    res = node.accept(self.visitor)
-                    res = self.coerce(res, self.node_type(node), node.line)
-                # If we hit an error during compilation, we want to
-                # keep trying, so we can produce more error
-                # messages. Generate a temp of the right type to keep
-                # from causing more downstream trouble.
-                except UnsupportedException:
-                    res = Register(self.node_type(node))
-                self.can_borrow = old_can_borrow
-                if not can_borrow:
-                    self.flush_keep_alives()
-                return res
-            else:
-                try:
-                    node.accept(self.visitor)
-                except UnsupportedException:
-                    pass
-                return None
-
-    def flush_keep_alives(self) -> None:
-        self.builder.flush_keep_alives()
-
-    # Pass through methods for the most common low-level builder ops, for convenience.
-
-    def add(self, op: Op) -> Value:
-        return self.builder.add(op)
-
-    def goto(self, target: BasicBlock) -> None:
-        self.builder.goto(target)
-
-    def activate_block(self, block: BasicBlock) -> None:
-        self.builder.activate_block(block)
-
-    def goto_and_activate(self, block: BasicBlock) -> None:
-        self.builder.goto_and_activate(block)
-
-    def self(self) -> Register:
-        return self.builder.self()
-
-    def py_get_attr(self, obj: Value, attr: str, line: int) -> Value:
-        return self.builder.py_get_attr(obj, attr, line)
-
-    def load_str(self, value: str) -> Value:
-        return self.builder.load_str(value)
-
-    def load_bytes_from_str_literal(self, value: str) -> Value:
-        """Load bytes object from a string literal.
-
-        The literal characters of BytesExpr (the characters inside b'')
-        are stored in BytesExpr.value, whose type is 'str' not 'bytes'.
-        Thus we perform a special conversion here.
-        """
-        return self.builder.load_bytes(bytes_from_str(value))
-
-    def load_int(self, value: int) -> Value:
-        return self.builder.load_int(value)
-
-    def load_float(self, value: float) -> Value:
-        return self.builder.load_float(value)
-
-    def unary_op(self, lreg: Value, expr_op: str, line: int) -> Value:
-        return self.builder.unary_op(lreg, expr_op, line)
-
-    def binary_op(self, lreg: Value, rreg: Value, expr_op: str, line: int) -> Value:
-        return self.builder.binary_op(lreg, rreg, expr_op, line)
-
-    def coerce(self, src: Value, target_type: RType, line: int, force: bool = False) -> Value:
-        return self.builder.coerce(src, target_type, line, force, can_borrow=self.can_borrow)
-
-    def none_object(self) -> Value:
-        return self.builder.none_object()
-
-    def none(self) -> Value:
-        return self.builder.none()
-
-    def true(self) -> Value:
-        return self.builder.true()
-
-    def false(self) -> Value:
-        return self.builder.false()
-
-    def new_list_op(self, values: list[Value], line: int) -> Value:
-        return self.builder.new_list_op(values, line)
-
-    def new_set_op(self, values: list[Value], line: int) -> Value:
-        return self.builder.new_set_op(values, line)
-
-    def translate_is_op(self, lreg: Value, rreg: Value, expr_op: str, line: int) -> Value:
-        return self.builder.translate_is_op(lreg, rreg, expr_op, line)
-
-    def py_call(
-        self,
-        function: Value,
-        arg_values: list[Value],
-        line: int,
-        arg_kinds: list[ArgKind] | None = None,
-        arg_names: Sequence[str | None] | None = None,
-    ) -> Value:
-        return self.builder.py_call(function, arg_values, line, arg_kinds, arg_names)
-
-    def add_bool_branch(self, value: Value, true: BasicBlock, false: BasicBlock) -> None:
-        self.builder.add_bool_branch(value, true, false)
-
-    def load_native_type_object(self, fullname: str) -> Value:
-        return self.builder.load_native_type_object(fullname)
-
-    def gen_method_call(
-        self,
-        base: Value,
-        name: str,
-        arg_values: list[Value],
-        result_type: RType | None,
-        line: int,
-        arg_kinds: list[ArgKind] | None = None,
-        arg_names: list[str | None] | None = None,
-    ) -> Value:
-        return self.builder.gen_method_call(
-            base, name, arg_values, result_type, line, arg_kinds, arg_names, self.can_borrow
-        )
-
-    def load_module(self, name: str) -> Value:
-        return self.builder.load_module(name)
-
-    def call_c(self, desc: CFunctionDescription, args: list[Value], line: int) -> Value:
-        return self.builder.call_c(desc, args, line)
-
-    def int_op(self, type: RType, lhs: Value, rhs: Value, op: int, line: int) -> Value:
-        return self.builder.int_op(type, lhs, rhs, op, line)
-
-    def compare_tuples(self, lhs: Value, rhs: Value, op: str, line: int) -> Value:
-        return self.builder.compare_tuples(lhs, rhs, op, line)
-
-    def builtin_len(self, val: Value, line: int) -> Value:
-        return self.builder.builtin_len(val, line)
-
-    def new_tuple(self, items: list[Value], line: int) -> Value:
-        return self.builder.new_tuple(items, line)
-
-    # Helpers for IR building
-
-    def add_to_non_ext_dict(
-        self, non_ext: NonExtClassInfo, key: str, val: Value, line: int
-    ) -> None:
-        # Add an attribute entry into the class dict of a non-extension class.
-        key_unicode = self.load_str(key)
-        self.call_c(dict_set_item_op, [non_ext.dict, key_unicode, val], line)
-
-    def gen_import(self, id: str, line: int) -> None:
-        self.imports[id] = None
-
-        needs_import, out = BasicBlock(), BasicBlock()
-        self.check_if_module_loaded(id, line, needs_import, out)
-
-        self.activate_block(needs_import)
-        value = self.call_c(import_op, [self.load_str(id)], line)
-        self.add(InitStatic(value, id, namespace=NAMESPACE_MODULE))
-        self.goto_and_activate(out)
-
-    def check_if_module_loaded(
-        self, id: str, line: int, needs_import: BasicBlock, out: BasicBlock
-    ) -> None:
-        """Generate code that checks if the module `id` has been loaded yet.
-
-        Arguments:
-            id: name of module to check if imported
-            line: line number that the import occurs on
-            needs_import: the BasicBlock that is run if the module has not been loaded yet
-            out: the BasicBlock that is run if the module has already been loaded"""
-        first_load = self.load_module(id)
-        comparison = self.translate_is_op(first_load, self.none_object(), "is not", line)
-        self.add_bool_branch(comparison, out, needs_import)
-
-    def get_module(self, module: str, line: int) -> Value:
-        # Python 3.7 has a nice 'PyImport_GetModule' function that we can't use :(
-        mod_dict = self.call_c(get_module_dict_op, [], line)
-        # Get module object from modules dict.
-        return self.call_c(dict_get_item_op, [mod_dict, self.load_str(module)], line)
-
-    def get_module_attr(self, module: str, attr: str, line: int) -> Value:
-        """Look up an attribute of a module without storing it in the local namespace.
-
-        For example, get_module_attr('typing', 'TypedDict', line) results in
-        the value of 'typing.TypedDict'.
-
-        Import the module if needed.
-        """
-        self.gen_import(module, line)
-        module_obj = self.get_module(module, line)
-        return self.py_get_attr(module_obj, attr, line)
-
-    def assign_if_null(self, target: Register, get_val: Callable[[], Value], line: int) -> None:
-        """If target is NULL, assign value produced by get_val to it."""
-        error_block, body_block = BasicBlock(), BasicBlock()
-        self.add(Branch(target, error_block, body_block, Branch.IS_ERROR))
-        self.activate_block(error_block)
-        self.add(Assign(target, self.coerce(get_val(), target.type, line)))
-        self.goto(body_block)
-        self.activate_block(body_block)
-
-    def assign_if_bitmap_unset(
-        self, target: Register, get_val: Callable[[], Value], index: int, line: int
-    ) -> None:
-        error_block, body_block = BasicBlock(), BasicBlock()
-        o = self.int_op(
-            bitmap_rprimitive,
-            self.builder.args[-1 - index // BITMAP_BITS],
-            Integer(1 << (index & (BITMAP_BITS - 1)), bitmap_rprimitive),
-            IntOp.AND,
-            line,
-        )
-        b = self.add(ComparisonOp(o, Integer(0, bitmap_rprimitive), ComparisonOp.EQ))
-        self.add(Branch(b, error_block, body_block, Branch.BOOL))
-        self.activate_block(error_block)
-        self.add(Assign(target, self.coerce(get_val(), target.type, line)))
-        self.goto(body_block)
-        self.activate_block(body_block)
-
-    def maybe_add_implicit_return(self) -> None:
-        if is_none_rprimitive(self.ret_types[-1]) or is_object_rprimitive(self.ret_types[-1]):
-            self.add_implicit_return()
-        else:
-            self.add_implicit_unreachable()
-
-    def add_implicit_return(self) -> None:
-        block = self.builder.blocks[-1]
-        if not block.terminated:
-            retval = self.coerce(self.builder.none(), self.ret_types[-1], -1)
-            self.nonlocal_control[-1].gen_return(self, retval, self.fn_info.fitem.line)
-
-    def add_implicit_unreachable(self) -> None:
-        block = self.builder.blocks[-1]
-        if not block.terminated:
-            self.add(Unreachable())
-
-    def disallow_class_assignments(self, lvalues: list[Lvalue], line: int) -> None:
-        # Some best-effort attempts to disallow assigning to class
-        # variables that aren't marked ClassVar, since we blatantly
-        # miscompile the interaction between instance and class
-        # variables.
-        for lvalue in lvalues:
-            if (
-                isinstance(lvalue, MemberExpr)
-                and isinstance(lvalue.expr, RefExpr)
-                and isinstance(lvalue.expr.node, TypeInfo)
-            ):
-                var = lvalue.expr.node[lvalue.name].node
-                if isinstance(var, Var) and not var.is_classvar:
-                    self.error("Only class variables defined as ClassVar can be assigned to", line)
-
-    def non_function_scope(self) -> bool:
-        # Currently the stack always has at least two items: dummy and top-level.
-        return len(self.fn_infos) <= 2
-
-    def top_level_fn_info(self) -> FuncInfo | None:
-        if self.non_function_scope():
-            return None
-        return self.fn_infos[2]
-
-    def init_final_static(
-        self,
-        lvalue: Lvalue,
-        rvalue_reg: Value,
-        class_name: str | None = None,
-        *,
-        type_override: RType | None = None,
-    ) -> None:
-        assert isinstance(lvalue, NameExpr)
-        assert isinstance(lvalue.node, Var)
-        if lvalue.node.final_value is None:
-            if class_name is None:
-                name = lvalue.name
-            else:
-                name = f"{class_name}.{lvalue.name}"
-            assert name is not None, "Full name not set for variable"
-            coerced = self.coerce(rvalue_reg, type_override or self.node_type(lvalue), lvalue.line)
-            self.final_names.append((name, coerced.type))
-            self.add(InitStatic(coerced, name, self.module_name))
-
-    def load_final_static(
-        self, fullname: str, typ: RType, line: int, error_name: str | None = None
-    ) -> Value:
-        split_name = split_target(self.graph, fullname)
-        assert split_name is not None
-        module, name = split_name
-        return self.builder.load_static_checked(
-            typ,
-            name,
-            module,
-            line=line,
-            error_msg=f'value for final name "{error_name}" was not set',
-        )
-
-    def load_literal_value(self, val: int | str | bytes | float | complex | bool) -> Value:
-        """Load value of a final name, class-level attribute, or constant folded expression."""
-        if isinstance(val, bool):
-            if val:
-                return self.true()
-            else:
-                return self.false()
-        elif isinstance(val, int):
-            return self.builder.load_int(val)
-        elif isinstance(val, float):
-            return self.builder.load_float(val)
-        elif isinstance(val, str):
-            return self.builder.load_str(val)
-        elif isinstance(val, bytes):
-            return self.builder.load_bytes(val)
-        elif isinstance(val, complex):
-            return self.builder.load_complex(val)
-        else:
-            assert False, "Unsupported literal value"
-
-    def get_assignment_target(
-        self, lvalue: Lvalue, line: int = -1, *, for_read: bool = False
-    ) -> AssignmentTarget:
-        if line == -1:
-            line = lvalue.line
-        if isinstance(lvalue, NameExpr):
-            # If we are visiting a decorator, then the SymbolNode we really want to be looking at
-            # is the function that is decorated, not the entire Decorator node itself.
-            symbol = lvalue.node
-            if isinstance(symbol, Decorator):
-                symbol = symbol.func
-            if symbol is None:
-                # New semantic analyzer doesn't create ad-hoc Vars for special forms.
-                assert lvalue.is_special_form
-                symbol = Var(lvalue.name)
-            if not for_read and isinstance(symbol, Var) and symbol.is_cls:
-                self.error("Cannot assign to the first argument of classmethod", line)
-            if lvalue.kind == LDEF:
-                if symbol not in self.symtables[-1]:
-                    if isinstance(symbol, Var) and not isinstance(symbol.type, DeletedType):
-                        reg_type = self.type_to_rtype(symbol.type)
-                    else:
-                        reg_type = self.node_type(lvalue)
-                    # If the function is a generator function, then first define a new variable
-                    # in the current function's environment class. Next, define a target that
-                    # refers to the newly defined variable in that environment class. Add the
-                    # target to the table containing class environment variables, as well as the
-                    # current environment.
-                    if self.fn_info.is_generator:
-                        return self.add_var_to_env_class(
-                            symbol, reg_type, self.fn_info.generator_class, reassign=False
-                        )
-
-                    # Otherwise define a new local variable.
-                    return self.add_local_reg(symbol, reg_type)
-                else:
-                    # Assign to a previously defined variable.
-                    return self.lookup(symbol)
-            elif lvalue.kind == GDEF:
-                globals_dict = self.load_globals_dict()
-                name = self.load_str(lvalue.name)
-                return AssignmentTargetIndex(globals_dict, name)
-            else:
-                assert False, lvalue.kind
-        elif isinstance(lvalue, IndexExpr):
-            # Indexed assignment x[y] = e
-            base = self.accept(lvalue.base)
-            index = self.accept(lvalue.index)
-            return AssignmentTargetIndex(base, index)
-        elif isinstance(lvalue, MemberExpr):
-            # Attribute assignment x.y = e
-            can_borrow = self.is_native_attr_ref(lvalue)
-            obj = self.accept(lvalue.expr, can_borrow=can_borrow)
-            return AssignmentTargetAttr(obj, lvalue.name, can_borrow=can_borrow)
-        elif isinstance(lvalue, TupleExpr):
-            # Multiple assignment a, ..., b = e
-            star_idx: int | None = None
-            lvalues = []
-            for idx, item in enumerate(lvalue.items):
-                targ = self.get_assignment_target(item)
-                lvalues.append(targ)
-                if isinstance(item, StarExpr):
-                    if star_idx is not None:
-                        self.error("Two starred expressions in assignment", line)
-                    star_idx = idx
-
-            return AssignmentTargetTuple(lvalues, star_idx)
-
-        elif isinstance(lvalue, StarExpr):
-            return self.get_assignment_target(lvalue.expr)
-
-        assert False, "Unsupported lvalue: %r" % lvalue
-
-    def read(
-        self, target: Value | AssignmentTarget, line: int = -1, can_borrow: bool = False
-    ) -> Value:
-        if isinstance(target, Value):
-            return target
-        if isinstance(target, AssignmentTargetRegister):
-            return target.register
-        if isinstance(target, AssignmentTargetIndex):
-            reg = self.gen_method_call(
-                target.base, "__getitem__", [target.index], target.type, line
-            )
-            if reg is not None:
-                return reg
-            assert False, target.base.type
-        if isinstance(target, AssignmentTargetAttr):
-            if isinstance(target.obj.type, RInstance) and target.obj.type.class_ir.is_ext_class:
-                borrow = can_borrow and target.can_borrow
-                return self.add(GetAttr(target.obj, target.attr, line, borrow=borrow))
-            else:
-                return self.py_get_attr(target.obj, target.attr, line)
-
-        assert False, "Unsupported lvalue: %r" % target
-
-    def assign(self, target: Register | AssignmentTarget, rvalue_reg: Value, line: int) -> None:
-        if isinstance(target, Register):
-            self.add(Assign(target, self.coerce_rvalue(rvalue_reg, target.type, line)))
-        elif isinstance(target, AssignmentTargetRegister):
-            rvalue_reg = self.coerce_rvalue(rvalue_reg, target.type, line)
-            self.add(Assign(target.register, rvalue_reg))
-        elif isinstance(target, AssignmentTargetAttr):
-            if isinstance(target.obj_type, RInstance):
-                rvalue_reg = self.coerce_rvalue(rvalue_reg, target.type, line)
-                self.add(SetAttr(target.obj, target.attr, rvalue_reg, line))
-            else:
-                key = self.load_str(target.attr)
-                boxed_reg = self.builder.box(rvalue_reg)
-                self.call_c(py_setattr_op, [target.obj, key, boxed_reg], line)
-        elif isinstance(target, AssignmentTargetIndex):
-            target_reg2 = self.gen_method_call(
-                target.base, "__setitem__", [target.index, rvalue_reg], None, line
-            )
-            assert target_reg2 is not None, target.base.type
-        elif isinstance(target, AssignmentTargetTuple):
-            if isinstance(rvalue_reg.type, RTuple) and target.star_idx is None:
-                rtypes = rvalue_reg.type.types
-                assert len(rtypes) == len(target.items)
-                for i in range(len(rtypes)):
-                    item_value = self.add(TupleGet(rvalue_reg, i, line))
-                    self.assign(target.items[i], item_value, line)
-            elif (
-                is_list_rprimitive(rvalue_reg.type) or is_tuple_rprimitive(rvalue_reg.type)
-            ) and target.star_idx is None:
-                self.process_sequence_assignment(target, rvalue_reg, line)
-            else:
-                self.process_iterator_tuple_assignment(target, rvalue_reg, line)
-        else:
-            assert False, "Unsupported assignment target"
-
-    def coerce_rvalue(self, rvalue: Value, rtype: RType, line: int) -> Value:
-        if is_float_rprimitive(rtype) and is_tagged(rvalue.type):
-            typename = rvalue.type.short_name()
-            if typename == "short_int":
-                typename = "int"
-            self.error(
-                "Incompatible value representations in assignment "
-                + f'(expression has type "{typename}", variable has type "float")',
-                line,
-            )
-        return self.coerce(rvalue, rtype, line)
-
-    def process_sequence_assignment(
-        self, target: AssignmentTargetTuple, rvalue: Value, line: int
-    ) -> None:
-        """Process assignment like 'x, y = s', where s is a variable-length list or tuple."""
-        # Check the length of sequence.
-        expected_len = Integer(len(target.items), c_pyssize_t_rprimitive)
-        self.builder.call_c(check_unpack_count_op, [rvalue, expected_len], line)
-
-        # Read sequence items.
-        values = []
-        for i in range(len(target.items)):
-            item = target.items[i]
-            index = self.builder.load_int(i)
-            if is_list_rprimitive(rvalue.type):
-                item_value = self.call_c(list_get_item_unsafe_op, [rvalue, index], line)
-            else:
-                item_value = self.builder.gen_method_call(
-                    rvalue, "__getitem__", [index], item.type, line
-                )
-            values.append(item_value)
-
-        # Assign sequence items to the target lvalues.
-        for lvalue, value in zip(target.items, values):
-            self.assign(lvalue, value, line)
-
-    def process_iterator_tuple_assignment_helper(
-        self, litem: AssignmentTarget, ritem: Value, line: int
-    ) -> None:
-        error_block, ok_block = BasicBlock(), BasicBlock()
-        self.add(Branch(ritem, error_block, ok_block, Branch.IS_ERROR))
-
-        self.activate_block(error_block)
-        self.add(
-            RaiseStandardError(RaiseStandardError.VALUE_ERROR, "not enough values to unpack", line)
-        )
-        self.add(Unreachable())
-
-        self.activate_block(ok_block)
-        self.assign(litem, ritem, line)
-
-    def process_iterator_tuple_assignment(
-        self, target: AssignmentTargetTuple, rvalue_reg: Value, line: int
-    ) -> None:
-        iterator = self.call_c(iter_op, [rvalue_reg], line)
-
-        # This may be the whole lvalue list if there is no starred value
-        split_idx = target.star_idx if target.star_idx is not None else len(target.items)
-
-        # Assign values before the first starred value
-        for litem in target.items[:split_idx]:
-            ritem = self.call_c(next_op, [iterator], line)
-            error_block, ok_block = BasicBlock(), BasicBlock()
-            self.add(Branch(ritem, error_block, ok_block, Branch.IS_ERROR))
-
-            self.activate_block(error_block)
-            self.add(
-                RaiseStandardError(
-                    RaiseStandardError.VALUE_ERROR, "not enough values to unpack", line
-                )
-            )
-            self.add(Unreachable())
-
-            self.activate_block(ok_block)
-
-            self.assign(litem, ritem, line)
-
-        # Assign the starred value and all values after it
-        if target.star_idx is not None:
-            post_star_vals = target.items[split_idx + 1 :]
-            iter_list = self.call_c(to_list, [iterator], line)
-            iter_list_len = self.builtin_len(iter_list, line)
-            post_star_len = Integer(len(post_star_vals))
-            condition = self.binary_op(post_star_len, iter_list_len, "<=", line)
-
-            error_block, ok_block = BasicBlock(), BasicBlock()
-            self.add(Branch(condition, ok_block, error_block, Branch.BOOL))
-
-            self.activate_block(error_block)
-            self.add(
-                RaiseStandardError(
-                    RaiseStandardError.VALUE_ERROR, "not enough values to unpack", line
-                )
-            )
-            self.add(Unreachable())
-
-            self.activate_block(ok_block)
-
-            for litem in reversed(post_star_vals):
-                ritem = self.call_c(list_pop_last, [iter_list], line)
-                self.assign(litem, ritem, line)
-
-            # Assign the starred value
-            self.assign(target.items[target.star_idx], iter_list, line)
-
-        # There is no starred value, so check if there are extra values in rhs that
-        # have not been assigned.
-        else:
-            extra = self.call_c(next_op, [iterator], line)
-            error_block, ok_block = BasicBlock(), BasicBlock()
-            self.add(Branch(extra, ok_block, error_block, Branch.IS_ERROR))
-
-            self.activate_block(error_block)
-            self.add(
-                RaiseStandardError(
-                    RaiseStandardError.VALUE_ERROR, "too many values to unpack", line
-                )
-            )
-            self.add(Unreachable())
-
-            self.activate_block(ok_block)
-
-    def push_loop_stack(self, continue_block: BasicBlock, break_block: BasicBlock) -> None:
-        self.nonlocal_control.append(
-            LoopNonlocalControl(self.nonlocal_control[-1], continue_block, break_block)
-        )
-
-    def pop_loop_stack(self) -> None:
-        self.nonlocal_control.pop()
-
-    def make_spill_target(self, type: RType) -> AssignmentTarget:
-        """Moves a given Value instance into the generator class' environment class."""
-        name = f"{TEMP_ATTR_NAME}{self.temp_counter}"
-        self.temp_counter += 1
-        target = self.add_var_to_env_class(Var(name), type, self.fn_info.generator_class)
-        return target
-
-    def spill(self, value: Value) -> AssignmentTarget:
-        """Moves a given Value instance into the generator class' environment class."""
-        target = self.make_spill_target(value.type)
-        # Shouldn't be able to fail, so -1 for line
-        self.assign(target, value, -1)
-        return target
-
-    def maybe_spill(self, value: Value) -> Value | AssignmentTarget:
-        """
-        Moves a given Value instance into the environment class for generator functions. For
-        non-generator functions, leaves the Value instance as it is.
-
-        Returns an AssignmentTarget associated with the Value for generator functions and the
-        original Value itself for non-generator functions.
-        """
-        if self.fn_info.is_generator:
-            return self.spill(value)
-        return value
-
-    def maybe_spill_assignable(self, value: Value) -> Register | AssignmentTarget:
-        """
-        Moves a given Value instance into the environment class for generator functions. For
-        non-generator functions, allocate a temporary Register.
-
-        Returns an AssignmentTarget associated with the Value for generator functions and an
-        assignable Register for non-generator functions.
-        """
-        if self.fn_info.is_generator:
-            return self.spill(value)
-
-        if isinstance(value, Register):
-            return value
-
-        # Allocate a temporary register for the assignable value.
-        reg = Register(value.type)
-        self.assign(reg, value, -1)
-        return reg
-
-    def extract_int(self, e: Expression) -> int | None:
-        if isinstance(e, IntExpr):
-            return e.value
-        elif isinstance(e, UnaryExpr) and e.op == "-" and isinstance(e.expr, IntExpr):
-            return -e.expr.value
-        else:
-            return None
-
-    def get_sequence_type(self, expr: Expression) -> RType:
-        return self.get_sequence_type_from_type(self.types[expr])
-
-    def get_sequence_type_from_type(self, target_type: Type) -> RType:
-        target_type = get_proper_type(target_type)
-        if isinstance(target_type, UnionType):
-            return RUnion.make_simplified_union(
-                [self.get_sequence_type_from_type(item) for item in target_type.items]
-            )
-        assert isinstance(target_type, Instance), target_type
-        if target_type.type.fullname == "builtins.str":
-            return str_rprimitive
-        else:
-            return self.type_to_rtype(target_type.args[0])
-
-    def get_dict_base_type(self, expr: Expression) -> list[Instance]:
-        """Find dict type of a dict-like expression.
-
-        This is useful for dict subclasses like SymbolTable.
-        """
-        target_type = get_proper_type(self.types[expr])
-        if isinstance(target_type, UnionType):
-            types = [get_proper_type(item) for item in target_type.items]
-        else:
-            types = [target_type]
-
-        dict_types = []
-        for t in types:
-            if isinstance(t, TypedDictType):
-                t = t.fallback
-                dict_base = next(base for base in t.type.mro if base.fullname == "typing.Mapping")
-            else:
-                assert isinstance(t, Instance), t
-                dict_base = next(base for base in t.type.mro if base.fullname == "builtins.dict")
-            dict_types.append(map_instance_to_supertype(t, dict_base))
-        return dict_types
-
-    def get_dict_key_type(self, expr: Expression) -> RType:
-        dict_base_types = self.get_dict_base_type(expr)
-        if len(dict_base_types) == 1:
-            return self.type_to_rtype(dict_base_types[0].args[0])
-        else:
-            rtypes = [self.type_to_rtype(t.args[0]) for t in dict_base_types]
-            return RUnion.make_simplified_union(rtypes)
-
-    def get_dict_value_type(self, expr: Expression) -> RType:
-        dict_base_types = self.get_dict_base_type(expr)
-        if len(dict_base_types) == 1:
-            return self.type_to_rtype(dict_base_types[0].args[1])
-        else:
-            rtypes = [self.type_to_rtype(t.args[1]) for t in dict_base_types]
-            return RUnion.make_simplified_union(rtypes)
-
-    def get_dict_item_type(self, expr: Expression) -> RType:
-        key_type = self.get_dict_key_type(expr)
-        value_type = self.get_dict_value_type(expr)
-        return RTuple([key_type, value_type])
-
-    def _analyze_iterable_item_type(self, expr: Expression) -> Type:
-        """Return the item type given by 'expr' in an iterable context."""
-        # This logic is copied from mypy's TypeChecker.analyze_iterable_item_type.
-        if expr not in self.types:
-            # Mypy thinks this is unreachable.
-            iterable: ProperType = AnyType(TypeOfAny.from_error)
-        else:
-            iterable = get_proper_type(self.types[expr])
-        echk = self.graph[self.module_name].type_checker().expr_checker
-        iterator = echk.check_method_call_by_name("__iter__", iterable, [], [], expr)[0]
-
-        from mypy.join import join_types
-
-        if isinstance(iterable, TupleType):
-            joined: Type = UninhabitedType()
-            for item in iterable.items:
-                joined = join_types(joined, item)
-            return joined
-        else:
-            # Non-tuple iterable.
-            return echk.check_method_call_by_name("__next__", iterator, [], [], expr)[0]
-
-    def is_native_module(self, module: str) -> bool:
-        """Is the given module one compiled by mypyc?"""
-        return module in self.mapper.group_map
-
-    def is_native_ref_expr(self, expr: RefExpr) -> bool:
-        if expr.node is None:
-            return False
-        if "." in expr.node.fullname:
-            return self.is_native_module(expr.node.fullname.rpartition(".")[0])
-        return True
-
-    def is_native_module_ref_expr(self, expr: RefExpr) -> bool:
-        return self.is_native_ref_expr(expr) and expr.kind == GDEF
-
-    def is_synthetic_type(self, typ: TypeInfo) -> bool:
-        """Is a type something other than just a class we've created?"""
-        return typ.is_named_tuple or typ.is_newtype or typ.typeddict_type is not None
-
-    def get_final_ref(self, expr: MemberExpr) -> tuple[str, Var, bool] | None:
-        """Check if `expr` is a final attribute.
-
-        This needs to be done differently for class and module attributes to
-        correctly determine fully qualified name. Return a tuple that consists of
-        the qualified name, the corresponding Var node, and a flag indicating whether
-        the final name was defined in a compiled module. Return None if `expr` does not
-        refer to a final attribute.
-        """
-        final_var = None
-        if isinstance(expr.expr, RefExpr) and isinstance(expr.expr.node, TypeInfo):
-            # a class attribute
-            sym = expr.expr.node.get(expr.name)
-            if sym and isinstance(sym.node, Var):
-                # Enum attribute are treated as final since they are added to the global cache
-                expr_fullname = expr.expr.node.bases[0].type.fullname
-                is_final = sym.node.is_final or expr_fullname == "enum.Enum"
-                if is_final:
-                    final_var = sym.node
-                    fullname = f"{sym.node.info.fullname}.{final_var.name}"
-                    native = self.is_native_module(expr.expr.node.module_name)
-        elif self.is_module_member_expr(expr):
-            # a module attribute
-            if isinstance(expr.node, Var) and expr.node.is_final:
-                final_var = expr.node
-                fullname = expr.node.fullname
-                native = self.is_native_ref_expr(expr)
-        if final_var is not None:
-            return fullname, final_var, native
-        return None
-
-    def emit_load_final(
-        self, final_var: Var, fullname: str, name: str, native: bool, typ: Type, line: int
-    ) -> Value | None:
-        """Emit code for loading value of a final name (if possible).
-
-        Args:
-            final_var: Var corresponding to the final name
-            fullname: its qualified name
-            name: shorter name to show in errors
-            native: whether the name was defined in a compiled module
-            typ: its type
-            line: line number where loading occurs
-        """
-        if final_var.final_value is not None:  # this is safe even for non-native names
-            return self.load_literal_value(final_var.final_value)
-        elif native and module_prefix(self.graph, fullname):
-            return self.load_final_static(fullname, self.mapper.type_to_rtype(typ), line, name)
-        else:
-            return None
-
-    def is_module_member_expr(self, expr: MemberExpr) -> bool:
-        return isinstance(expr.expr, RefExpr) and isinstance(expr.expr.node, MypyFile)
-
-    def call_refexpr_with_args(
-        self, expr: CallExpr, callee: RefExpr, arg_values: list[Value]
-    ) -> Value:
-        # Handle data-driven special-cased primitive call ops.
-        if callee.fullname and expr.arg_kinds == [ARG_POS] * len(arg_values):
-            fullname = get_call_target_fullname(callee)
-            call_c_ops_candidates = function_ops.get(fullname, [])
-            target = self.builder.matching_call_c(
-                call_c_ops_candidates, arg_values, expr.line, self.node_type(expr)
-            )
-            if target:
-                return target
-
-        # Standard native call if signature and fullname are good and all arguments are positional
-        # or named.
-        callee_node = callee.node
-        if isinstance(callee_node, OverloadedFuncDef):
-            callee_node = callee_node.impl
-        # TODO: use native calls for any decorated functions which have all their decorators
-        # removed, not just singledispatch functions (which we don't do now just in case those
-        # decorated functions are callable classes or cannot be called without the python API for
-        # some other reason)
-        if (
-            isinstance(callee_node, Decorator)
-            and callee_node.func not in self.fdefs_to_decorators
-            and callee_node.func in self.singledispatch_impls
-        ):
-            callee_node = callee_node.func
-        if (
-            callee_node is not None
-            and callee.fullname
-            and callee_node in self.mapper.func_to_decl
-            and all(kind in (ARG_POS, ARG_NAMED) for kind in expr.arg_kinds)
-        ):
-            decl = self.mapper.func_to_decl[callee_node]
-            return self.builder.call(decl, arg_values, expr.arg_kinds, expr.arg_names, expr.line)
-
-        # Fall back to a Python call
-        function = self.accept(callee)
-        return self.py_call(
-            function, arg_values, expr.line, arg_kinds=expr.arg_kinds, arg_names=expr.arg_names
-        )
-
-    def shortcircuit_expr(self, expr: OpExpr) -> Value:
-        return self.builder.shortcircuit_helper(
-            expr.op,
-            self.node_type(expr),
-            lambda: self.accept(expr.left),
-            lambda: self.accept(expr.right),
-            expr.line,
-        )
-
-    # Basic helpers
-
-    def flatten_classes(self, arg: RefExpr | TupleExpr) -> list[ClassIR] | None:
-        """Flatten classes in isinstance(obj, (A, (B, C))).
-
-        If at least one item is not a reference to a native class, return None.
-        """
-        if isinstance(arg, RefExpr):
-            if isinstance(arg.node, TypeInfo) and self.is_native_module_ref_expr(arg):
-                ir = self.mapper.type_to_ir.get(arg.node)
-                if ir:
-                    return [ir]
-            return None
-        else:
-            res: list[ClassIR] = []
-            for item in arg.items:
-                if isinstance(item, (RefExpr, TupleExpr)):
-                    item_part = self.flatten_classes(item)
-                    if item_part is None:
-                        return None
-                    res.extend(item_part)
-                else:
-                    return None
-            return res
-
-    def enter(self, fn_info: FuncInfo | str = "") -> None:
-        if isinstance(fn_info, str):
-            fn_info = FuncInfo(name=fn_info)
-        self.builder = LowLevelIRBuilder(self.errors, self.options)
-        self.builder.set_module(self.module_name, self.module_path)
-        self.builders.append(self.builder)
-        self.symtables.append({})
-        self.runtime_args.append([])
-        self.fn_info = fn_info
-        self.fn_infos.append(self.fn_info)
-        self.ret_types.append(none_rprimitive)
-        if fn_info.is_generator:
-            self.nonlocal_control.append(GeneratorNonlocalControl())
-        else:
-            self.nonlocal_control.append(BaseNonlocalControl())
-        self.activate_block(BasicBlock())
-
-    def leave(self) -> tuple[list[Register], list[RuntimeArg], list[BasicBlock], RType, FuncInfo]:
-        builder = self.builders.pop()
-        self.symtables.pop()
-        runtime_args = self.runtime_args.pop()
-        ret_type = self.ret_types.pop()
-        fn_info = self.fn_infos.pop()
-        self.nonlocal_control.pop()
-        self.builder = self.builders[-1]
-        self.fn_info = self.fn_infos[-1]
-        return builder.args, runtime_args, builder.blocks, ret_type, fn_info
-
-    @contextmanager
-    def enter_method(
-        self,
-        class_ir: ClassIR,
-        name: str,
-        ret_type: RType,
-        fn_info: FuncInfo | str = "",
-        self_type: RType | None = None,
-    ) -> Iterator[None]:
-        """Generate IR for a method.
-
-        If the method takes arguments, you should immediately afterwards call
-        add_argument() for each non-self argument (self is created implicitly).
-
-        Args:
-            class_ir: Add method to this class
-            name: Short name of the method
-            ret_type: Return type of the method
-            fn_info: Optionally, additional information about the method
-            self_type: If not None, override default type of the implicit 'self'
-                argument (by default, derive type from class_ir)
-        """
-        self.enter(fn_info)
-        self.function_name_stack.append(name)
-        self.class_ir_stack.append(class_ir)
-        self.ret_types[-1] = ret_type
-        if self_type is None:
-            self_type = RInstance(class_ir)
-        self.add_argument(SELF_NAME, self_type)
-        try:
-            yield
-        finally:
-            arg_regs, args, blocks, ret_type, fn_info = self.leave()
-            sig = FuncSignature(args, ret_type)
-            name = self.function_name_stack.pop()
-            class_ir = self.class_ir_stack.pop()
-            decl = FuncDecl(name, class_ir.name, self.module_name, sig)
-            ir = FuncIR(decl, arg_regs, blocks)
-            class_ir.methods[name] = ir
-            class_ir.method_decls[name] = ir.decl
-            self.functions.append(ir)
-
-    def add_argument(self, var: str | Var, typ: RType, kind: ArgKind = ARG_POS) -> Register:
-        """Declare an argument in the current function.
-
-        You should use this instead of directly calling add_local() in new code.
-        """
-        if isinstance(var, str):
-            var = Var(var)
-        reg = self.add_local(var, typ, is_arg=True)
-        self.runtime_args[-1].append(RuntimeArg(var.name, typ, kind))
-        return reg
-
-    def lookup(self, symbol: SymbolNode) -> SymbolTarget:
-        return self.symtables[-1][symbol]
-
-    def add_local(self, symbol: SymbolNode, typ: RType, is_arg: bool = False) -> Register:
-        """Add register that represents a symbol to the symbol table.
-
-        Args:
-            is_arg: is this a function argument
-        """
-        assert isinstance(symbol, SymbolNode)
-        reg = Register(
-            typ, remangle_redefinition_name(symbol.name), is_arg=is_arg, line=symbol.line
-        )
-        self.symtables[-1][symbol] = AssignmentTargetRegister(reg)
-        if is_arg:
-            self.builder.args.append(reg)
-        return reg
-
-    def add_local_reg(
-        self, symbol: SymbolNode, typ: RType, is_arg: bool = False
-    ) -> AssignmentTargetRegister:
-        """Like add_local, but return an assignment target instead of value."""
-        self.add_local(symbol, typ, is_arg)
-        target = self.symtables[-1][symbol]
-        assert isinstance(target, AssignmentTargetRegister)
-        return target
-
-    def add_self_to_env(self, cls: ClassIR) -> AssignmentTargetRegister:
-        """Low-level function that adds a 'self' argument.
-
-        This is only useful if using enter() instead of enter_method().
-        """
-        return self.add_local_reg(Var(SELF_NAME), RInstance(cls), is_arg=True)
-
-    def add_target(self, symbol: SymbolNode, target: SymbolTarget) -> SymbolTarget:
-        self.symtables[-1][symbol] = target
-        return target
-
-    def type_to_rtype(self, typ: Type | None) -> RType:
-        return self.mapper.type_to_rtype(typ)
-
-    def node_type(self, node: Expression) -> RType:
-        if isinstance(node, IntExpr):
-            # TODO: Don't special case IntExpr
-            return int_rprimitive
-        if node not in self.types:
-            return object_rprimitive
-        mypy_type = self.types[node]
-        return self.type_to_rtype(mypy_type)
-
-    def add_var_to_env_class(
-        self, var: SymbolNode, rtype: RType, base: FuncInfo | ImplicitClass, reassign: bool = False
-    ) -> AssignmentTarget:
-        # First, define the variable name as an attribute of the environment class, and then
-        # construct a target for that attribute.
-        name = remangle_redefinition_name(var.name)
-        self.fn_info.env_class.attributes[name] = rtype
-        attr_target = AssignmentTargetAttr(base.curr_env_reg, name)
-
-        if reassign:
-            # Read the local definition of the variable, and set the corresponding attribute of
-            # the environment class' variable to be that value.
-            reg = self.read(self.lookup(var), self.fn_info.fitem.line)
-            self.add(SetAttr(base.curr_env_reg, name, reg, self.fn_info.fitem.line))
-
-        # Override the local definition of the variable to instead point at the variable in
-        # the environment class.
-        return self.add_target(var, attr_target)
-
-    def is_builtin_ref_expr(self, expr: RefExpr) -> bool:
-        assert expr.node, "RefExpr not resolved"
-        return "." in expr.node.fullname and expr.node.fullname.split(".")[0] == "builtins"
-
-    def load_global(self, expr: NameExpr) -> Value:
-        """Loads a Python-level global.
-
-        This takes a NameExpr and uses its name as a key to retrieve the corresponding PyObject *
-        from the _globals dictionary in the C-generated code.
-        """
-        # If the global is from 'builtins', turn it into a module attr load instead
-        if self.is_builtin_ref_expr(expr):
-            assert expr.node, "RefExpr not resolved"
-            return self.load_module_attr_by_fullname(expr.node.fullname, expr.line)
-        if (
-            self.is_native_module_ref_expr(expr)
-            and isinstance(expr.node, TypeInfo)
-            and not self.is_synthetic_type(expr.node)
-        ):
-            assert expr.fullname
-            return self.load_native_type_object(expr.fullname)
-        return self.load_global_str(expr.name, expr.line)
-
-    def load_global_str(self, name: str, line: int) -> Value:
-        _globals = self.load_globals_dict()
-        reg = self.load_str(name)
-        return self.call_c(dict_get_item_op, [_globals, reg], line)
-
-    def load_globals_dict(self) -> Value:
-        return self.add(LoadStatic(dict_rprimitive, "globals", self.module_name))
-
-    def load_module_attr_by_fullname(self, fullname: str, line: int) -> Value:
-        module, _, name = fullname.rpartition(".")
-        left = self.load_module(module)
-        return self.py_get_attr(left, name, line)
-
-    def is_native_attr_ref(self, expr: MemberExpr) -> bool:
-        """Is expr a direct reference to a native (struct) attribute of an instance?"""
-        obj_rtype = self.node_type(expr.expr)
-        return (
-            isinstance(obj_rtype, RInstance)
-            and obj_rtype.class_ir.is_ext_class
-            and obj_rtype.class_ir.has_attr(expr.name)
-            and not obj_rtype.class_ir.get_method(expr.name)
-        )
-
-    def mark_block_unreachable(self) -> None:
-        """Mark statements in the innermost block being processed as unreachable.
-
-        This should be called after a statement that unconditionally leaves the
-        block, such as 'break' or 'return'.
-        """
-        self.block_reachable_stack[-1] = False
-
-    # Lacks a good type because there wasn't a reasonable type in 3.5 :(
-    def catch_errors(self, line: int) -> Any:
-        return catch_errors(self.module_path, line)
-
-    def warning(self, msg: str, line: int) -> None:
-        self.errors.warning(msg, self.module_path, line)
-
-    def error(self, msg: str, line: int) -> None:
-        self.errors.error(msg, self.module_path, line)
-
-    def note(self, msg: str, line: int) -> None:
-        self.errors.note(msg, self.module_path, line)
-
-    def add_function(self, func_ir: FuncIR, line: int) -> None:
-        name = (func_ir.class_name, func_ir.name)
-        if name in self.function_names:
-            self.error(f'Duplicate definition of "{name[1]}" not supported by mypyc', line)
-            return
-        self.function_names.add(name)
-        self.functions.append(func_ir)
-
-
-def gen_arg_defaults(builder: IRBuilder) -> None:
-    """Generate blocks for arguments that have default values.
-
-    If the passed value is an error value, then assign the default
-    value to the argument.
-    """
-    fitem = builder.fn_info.fitem
-    nb = 0
-    for arg in fitem.arguments:
-        if arg.initializer:
-            target = builder.lookup(arg.variable)
-
-            def get_default() -> Value:
-                assert arg.initializer is not None
-
-                # If it is constant, don't bother storing it
-                if is_constant(arg.initializer):
-                    return builder.accept(arg.initializer)
-
-                # Because gen_arg_defaults runs before calculate_arg_defaults, we
-                # add the static/attribute to final_names/the class here.
-                elif not builder.fn_info.is_nested:
-                    name = fitem.fullname + "." + arg.variable.name
-                    builder.final_names.append((name, target.type))
-                    return builder.add(LoadStatic(target.type, name, builder.module_name))
-                else:
-                    name = arg.variable.name
-                    builder.fn_info.callable_class.ir.attributes[name] = target.type
-                    return builder.add(
-                        GetAttr(builder.fn_info.callable_class.self_reg, name, arg.line)
-                    )
-
-            assert isinstance(target, AssignmentTargetRegister)
-            reg = target.register
-            if not reg.type.error_overlap:
-                builder.assign_if_null(target.register, get_default, arg.initializer.line)
-            else:
-                builder.assign_if_bitmap_unset(
-                    target.register, get_default, nb, arg.initializer.line
-                )
-                nb += 1
-
-
-def remangle_redefinition_name(name: str) -> str:
-    """Remangle names produced by mypy when allow-redefinition is used and a name
-    is used with multiple types within a single block.
-
-    We only need to do this for locals, because the name is used as the name of the register;
-    for globals, the name itself is stored in a register for the purpose of doing dict
-    lookups.
-    """
-    return name.replace("'", "__redef__")
-
-
-def get_call_target_fullname(ref: RefExpr) -> str:
-    if isinstance(ref.node, TypeAlias):
-        # Resolve simple type aliases. In calls they evaluate to the type they point to.
-        target = get_proper_type(ref.node.target)
-        if isinstance(target, Instance):
-            return target.type.fullname
-    return ref.fullname