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

jaclang/vendor/mypyc/irbuild/classdef.py

@@ -1,850 +0,0 @@
-"""Transform class definitions from the mypy AST form to IR."""
-
-from __future__ import annotations
-
-import typing_extensions
-from abc import abstractmethod
-from typing import Callable, Final
-
-from mypy.nodes import (
-    AssignmentStmt,
-    CallExpr,
-    ClassDef,
-    Decorator,
-    ExpressionStmt,
-    FuncDef,
-    Lvalue,
-    MemberExpr,
-    NameExpr,
-    OverloadedFuncDef,
-    PassStmt,
-    RefExpr,
-    StrExpr,
-    TempNode,
-    TypeInfo,
-    is_class_var,
-)
-from mypy.types import ENUM_REMOVED_PROPS, Instance, UnboundType, get_proper_type
-from mypyc.common import PROPSET_PREFIX
-from mypyc.ir.class_ir import ClassIR, NonExtClassInfo
-from mypyc.ir.func_ir import FuncDecl, FuncSignature
-from mypyc.ir.ops import (
-    NAMESPACE_TYPE,
-    BasicBlock,
-    Branch,
-    Call,
-    InitStatic,
-    LoadAddress,
-    LoadErrorValue,
-    LoadStatic,
-    MethodCall,
-    Register,
-    Return,
-    SetAttr,
-    TupleSet,
-    Value,
-)
-from mypyc.ir.rtypes import (
-    RType,
-    bool_rprimitive,
-    dict_rprimitive,
-    is_none_rprimitive,
-    is_object_rprimitive,
-    is_optional_type,
-    object_rprimitive,
-)
-from mypyc.irbuild.builder import IRBuilder
-from mypyc.irbuild.function import (
-    gen_property_getter_ir,
-    gen_property_setter_ir,
-    handle_ext_method,
-    handle_non_ext_method,
-    load_type,
-)
-from mypyc.irbuild.util import dataclass_type, get_func_def, is_constant, is_dataclass_decorator
-from mypyc.primitives.dict_ops import dict_new_op, dict_set_item_op
-from mypyc.primitives.generic_ops import py_hasattr_op, py_setattr_op
-from mypyc.primitives.misc_ops import (
-    dataclass_sleight_of_hand,
-    not_implemented_op,
-    py_calc_meta_op,
-    pytype_from_template_op,
-    type_object_op,
-)
-
-
-def transform_class_def(builder: IRBuilder, cdef: ClassDef) -> None:
-    """Create IR for a class definition.
-
-    This can generate both extension (native) and non-extension
-    classes.  These are generated in very different ways. In the
-    latter case we construct a Python type object at runtime by doing
-    the equivalent of "type(name, bases, dict)" in IR. Extension
-    classes are defined via C structs that are generated later in
-    mypyc.codegen.emitclass.
-
-    This is the main entry point to this module.
-    """
-    ir = builder.mapper.type_to_ir[cdef.info]
-
-    # We do this check here because the base field of parent
-    # classes aren't necessarily populated yet at
-    # prepare_class_def time.
-    if any(ir.base_mro[i].base != ir.base_mro[i + 1] for i in range(len(ir.base_mro) - 1)):
-        builder.error("Multiple inheritance is not supported (except for traits)", cdef.line)
-
-    if ir.allow_interpreted_subclasses:
-        for parent in ir.mro:
-            if not parent.allow_interpreted_subclasses:
-                builder.error(
-                    'Base class "{}" does not allow interpreted subclasses'.format(
-                        parent.fullname
-                    ),
-                    cdef.line,
-                )
-
-    # Currently, we only create non-extension classes for classes that are
-    # decorated or inherit from Enum. Classes decorated with @trait do not
-    # apply here, and are handled in a different way.
-    if ir.is_ext_class:
-        cls_type = dataclass_type(cdef)
-        if cls_type is None:
-            cls_builder: ClassBuilder = ExtClassBuilder(builder, cdef)
-        elif cls_type in ["dataclasses", "attr-auto"]:
-            cls_builder = DataClassBuilder(builder, cdef)
-        elif cls_type == "attr":
-            cls_builder = AttrsClassBuilder(builder, cdef)
-        else:
-            raise ValueError(cls_type)
-    else:
-        cls_builder = NonExtClassBuilder(builder, cdef)
-
-    for stmt in cdef.defs.body:
-        if isinstance(stmt, OverloadedFuncDef) and stmt.is_property:
-            if isinstance(cls_builder, NonExtClassBuilder):
-                # properties with both getters and setters in non_extension
-                # classes not supported
-                builder.error("Property setters not supported in non-extension classes", stmt.line)
-            for item in stmt.items:
-                with builder.catch_errors(stmt.line):
-                    cls_builder.add_method(get_func_def(item))
-        elif isinstance(stmt, (FuncDef, Decorator, OverloadedFuncDef)):
-            # Ignore plugin generated methods (since they have no
-            # bodies to compile and will need to have the bodies
-            # provided by some other mechanism.)
-            if cdef.info.names[stmt.name].plugin_generated:
-                continue
-            with builder.catch_errors(stmt.line):
-                cls_builder.add_method(get_func_def(stmt))
-        elif isinstance(stmt, PassStmt):
-            continue
-        elif isinstance(stmt, AssignmentStmt):
-            if len(stmt.lvalues) != 1:
-                builder.error("Multiple assignment in class bodies not supported", stmt.line)
-                continue
-            lvalue = stmt.lvalues[0]
-            if not isinstance(lvalue, NameExpr):
-                builder.error(
-                    "Only assignment to variables is supported in class bodies", stmt.line
-                )
-                continue
-            # We want to collect class variables in a dictionary for both real
-            # non-extension classes and fake dataclass ones.
-            cls_builder.add_attr(lvalue, stmt)
-
-        elif isinstance(stmt, ExpressionStmt) and isinstance(stmt.expr, StrExpr):
-            # Docstring. Ignore
-            pass
-        else:
-            builder.error("Unsupported statement in class body", stmt.line)
-
-    # Generate implicit property setters/getters
-    for name, decl in ir.method_decls.items():
-        if decl.implicit and decl.is_prop_getter:
-            getter_ir = gen_property_getter_ir(builder, decl, cdef, ir.is_trait)
-            builder.functions.append(getter_ir)
-            ir.methods[getter_ir.decl.name] = getter_ir
-
-            setter_ir = None
-            setter_name = PROPSET_PREFIX + name
-            if setter_name in ir.method_decls:
-                setter_ir = gen_property_setter_ir(
-                    builder, ir.method_decls[setter_name], cdef, ir.is_trait
-                )
-                builder.functions.append(setter_ir)
-                ir.methods[setter_name] = setter_ir
-
-            ir.properties[name] = (getter_ir, setter_ir)
-            # TODO: Generate glue method if needed?
-            # TODO: Do we need interpreted glue methods? Maybe not?
-
-    cls_builder.finalize(ir)
-
-
-class ClassBuilder:
-    """Create IR for a class definition.
-
-    This is an abstract base class.
-    """
-
-    def __init__(self, builder: IRBuilder, cdef: ClassDef) -> None:
-        self.builder = builder
-        self.cdef = cdef
-        self.attrs_to_cache: list[tuple[Lvalue, RType]] = []
-
-    @abstractmethod
-    def add_method(self, fdef: FuncDef) -> None:
-        """Add a method to the class IR"""
-
-    @abstractmethod
-    def add_attr(self, lvalue: NameExpr, stmt: AssignmentStmt) -> None:
-        """Add an attribute to the class IR"""
-
-    @abstractmethod
-    def finalize(self, ir: ClassIR) -> None:
-        """Perform any final operations to complete the class IR"""
-
-
-class NonExtClassBuilder(ClassBuilder):
-    def __init__(self, builder: IRBuilder, cdef: ClassDef) -> None:
-        super().__init__(builder, cdef)
-        self.non_ext = self.create_non_ext_info()
-
-    def create_non_ext_info(self) -> NonExtClassInfo:
-        non_ext_bases = populate_non_ext_bases(self.builder, self.cdef)
-        non_ext_metaclass = find_non_ext_metaclass(self.builder, self.cdef, non_ext_bases)
-        non_ext_dict = setup_non_ext_dict(
-            self.builder, self.cdef, non_ext_metaclass, non_ext_bases
-        )
-        # We populate __annotations__ for non-extension classes
-        # because dataclasses uses it to determine which attributes to compute on.
-        # TODO: Maybe generate more precise types for annotations
-        non_ext_anns = self.builder.call_c(dict_new_op, [], self.cdef.line)
-        return NonExtClassInfo(non_ext_dict, non_ext_bases, non_ext_anns, non_ext_metaclass)
-
-    def add_method(self, fdef: FuncDef) -> None:
-        handle_non_ext_method(self.builder, self.non_ext, self.cdef, fdef)
-
-    def add_attr(self, lvalue: NameExpr, stmt: AssignmentStmt) -> None:
-        add_non_ext_class_attr_ann(self.builder, self.non_ext, lvalue, stmt)
-        add_non_ext_class_attr(
-            self.builder, self.non_ext, lvalue, stmt, self.cdef, self.attrs_to_cache
-        )
-
-    def finalize(self, ir: ClassIR) -> None:
-        # Dynamically create the class via the type constructor
-        non_ext_class = load_non_ext_class(self.builder, ir, self.non_ext, self.cdef.line)
-        non_ext_class = load_decorated_class(self.builder, self.cdef, non_ext_class)
-
-        # Save the decorated class
-        self.builder.add(
-            InitStatic(non_ext_class, self.cdef.name, self.builder.module_name, NAMESPACE_TYPE)
-        )
-
-        # Add the non-extension class to the dict
-        self.builder.call_c(
-            dict_set_item_op,
-            [
-                self.builder.load_globals_dict(),
-                self.builder.load_str(self.cdef.name),
-                non_ext_class,
-            ],
-            self.cdef.line,
-        )
-
-        # Cache any cacheable class attributes
-        cache_class_attrs(self.builder, self.attrs_to_cache, self.cdef)
-
-
-class ExtClassBuilder(ClassBuilder):
-    def __init__(self, builder: IRBuilder, cdef: ClassDef) -> None:
-        super().__init__(builder, cdef)
-        # If the class is not decorated, generate an extension class for it.
-        self.type_obj: Value | None = allocate_class(builder, cdef)
-
-    def skip_attr_default(self, name: str, stmt: AssignmentStmt) -> bool:
-        """Controls whether to skip generating a default for an attribute."""
-        return False
-
-    def add_method(self, fdef: FuncDef) -> None:
-        handle_ext_method(self.builder, self.cdef, fdef)
-
-    def add_attr(self, lvalue: NameExpr, stmt: AssignmentStmt) -> None:
-        # Variable declaration with no body
-        if isinstance(stmt.rvalue, TempNode):
-            return
-        # Only treat marked class variables as class variables.
-        if not (is_class_var(lvalue) or stmt.is_final_def):
-            return
-        typ = self.builder.load_native_type_object(self.cdef.fullname)
-        value = self.builder.accept(stmt.rvalue)
-        self.builder.call_c(
-            py_setattr_op, [typ, self.builder.load_str(lvalue.name), value], stmt.line
-        )
-        if self.builder.non_function_scope() and stmt.is_final_def:
-            self.builder.init_final_static(lvalue, value, self.cdef.name)
-
-    def finalize(self, ir: ClassIR) -> None:
-        attrs_with_defaults, default_assignments = find_attr_initializers(
-            self.builder, self.cdef, self.skip_attr_default
-        )
-        ir.attrs_with_defaults.update(attrs_with_defaults)
-        generate_attr_defaults_init(self.builder, self.cdef, default_assignments)
-        create_ne_from_eq(self.builder, self.cdef)
-
-
-class DataClassBuilder(ExtClassBuilder):
-    # controls whether an __annotations__ attribute should be added to the class
-    # __dict__.  This is not desirable for attrs classes where auto_attribs is
-    # disabled, as attrs will reject it.
-    add_annotations_to_dict = True
-
-    def __init__(self, builder: IRBuilder, cdef: ClassDef) -> None:
-        super().__init__(builder, cdef)
-        self.non_ext = self.create_non_ext_info()
-
-    def create_non_ext_info(self) -> NonExtClassInfo:
-        """Set up a NonExtClassInfo to track dataclass attributes.
-
-        In addition to setting up a normal extension class for dataclasses,
-        we also collect its class attributes like a non-extension class so
-        that we can hand them to the dataclass decorator.
-        """
-        return NonExtClassInfo(
-            self.builder.call_c(dict_new_op, [], self.cdef.line),
-            self.builder.add(TupleSet([], self.cdef.line)),
-            self.builder.call_c(dict_new_op, [], self.cdef.line),
-            self.builder.add(LoadAddress(type_object_op.type, type_object_op.src, self.cdef.line)),
-        )
-
-    def skip_attr_default(self, name: str, stmt: AssignmentStmt) -> bool:
-        return stmt.type is not None
-
-    def get_type_annotation(self, stmt: AssignmentStmt) -> TypeInfo | None:
-        # We populate __annotations__ because dataclasses uses it to determine
-        # which attributes to compute on.
-        ann_type = get_proper_type(stmt.type)
-        if isinstance(ann_type, Instance):
-            return ann_type.type
-        return None
-
-    def add_attr(self, lvalue: NameExpr, stmt: AssignmentStmt) -> None:
-        add_non_ext_class_attr_ann(
-            self.builder, self.non_ext, lvalue, stmt, self.get_type_annotation
-        )
-        add_non_ext_class_attr(
-            self.builder, self.non_ext, lvalue, stmt, self.cdef, self.attrs_to_cache
-        )
-        super().add_attr(lvalue, stmt)
-
-    def finalize(self, ir: ClassIR) -> None:
-        """Generate code to finish instantiating a dataclass.
-
-        This works by replacing all of the attributes on the class
-        (which will be descriptors) with whatever they would be in a
-        non-extension class, calling dataclass, then switching them back.
-
-        The resulting class is an extension class and instances of it do not
-        have a __dict__ (unless something else requires it).
-        All methods written explicitly in the source are compiled and
-        may be called through the vtable while the methods generated
-        by dataclasses are interpreted and may not be.
-
-        (If we just called dataclass without doing this, it would think that all
-        of the descriptors for our attributes are default values and generate an
-        incorrect constructor. We need to do the switch so that dataclass gets the
-        appropriate defaults.)
-        """
-        super().finalize(ir)
-        assert self.type_obj
-        add_dunders_to_non_ext_dict(
-            self.builder, self.non_ext, self.cdef.line, self.add_annotations_to_dict
-        )
-        dec = self.builder.accept(
-            next(d for d in self.cdef.decorators if is_dataclass_decorator(d))
-        )
-        self.builder.call_c(
-            dataclass_sleight_of_hand,
-            [dec, self.type_obj, self.non_ext.dict, self.non_ext.anns],
-            self.cdef.line,
-        )
-
-
-class AttrsClassBuilder(DataClassBuilder):
-    """Create IR for an attrs class where auto_attribs=False (the default).
-
-    When auto_attribs is enabled, attrs classes behave similarly to dataclasses
-    (i.e. types are stored as annotations on the class) and are thus handled
-    by DataClassBuilder, but when auto_attribs is disabled the types are
-    provided via attr.ib(type=...)
-    """
-
-    add_annotations_to_dict = False
-
-    def skip_attr_default(self, name: str, stmt: AssignmentStmt) -> bool:
-        return True
-
-    def get_type_annotation(self, stmt: AssignmentStmt) -> TypeInfo | None:
-        if isinstance(stmt.rvalue, CallExpr):
-            # find the type arg in `attr.ib(type=str)`
-            callee = stmt.rvalue.callee
-            if (
-                isinstance(callee, MemberExpr)
-                and callee.fullname in ["attr.ib", "attr.attr"]
-                and "type" in stmt.rvalue.arg_names
-            ):
-                index = stmt.rvalue.arg_names.index("type")
-                type_name = stmt.rvalue.args[index]
-                if isinstance(type_name, NameExpr) and isinstance(type_name.node, TypeInfo):
-                    lvalue = stmt.lvalues[0]
-                    assert isinstance(lvalue, NameExpr)
-                    return type_name.node
-        return None
-
-
-def allocate_class(builder: IRBuilder, cdef: ClassDef) -> Value:
-    # OK AND NOW THE FUN PART
-    base_exprs = cdef.base_type_exprs + cdef.removed_base_type_exprs
-    if base_exprs:
-        bases = [builder.accept(x) for x in base_exprs]
-        tp_bases = builder.new_tuple(bases, cdef.line)
-    else:
-        tp_bases = builder.add(LoadErrorValue(object_rprimitive, is_borrowed=True))
-    modname = builder.load_str(builder.module_name)
-    template = builder.add(
-        LoadStatic(object_rprimitive, cdef.name + "_template", builder.module_name, NAMESPACE_TYPE)
-    )
-    # Create the class
-    tp = builder.call_c(pytype_from_template_op, [template, tp_bases, modname], cdef.line)
-    # Immediately fix up the trait vtables, before doing anything with the class.
-    ir = builder.mapper.type_to_ir[cdef.info]
-    if not ir.is_trait and not ir.builtin_base:
-        builder.add(
-            Call(
-                FuncDecl(
-                    cdef.name + "_trait_vtable_setup",
-                    None,
-                    builder.module_name,
-                    FuncSignature([], bool_rprimitive),
-                ),
-                [],
-                -1,
-            )
-        )
-    # Populate a '__mypyc_attrs__' field containing the list of attrs
-    builder.call_c(
-        py_setattr_op,
-        [
-            tp,
-            builder.load_str("__mypyc_attrs__"),
-            create_mypyc_attrs_tuple(builder, builder.mapper.type_to_ir[cdef.info], cdef.line),
-        ],
-        cdef.line,
-    )
-
-    # Save the class
-    builder.add(InitStatic(tp, cdef.name, builder.module_name, NAMESPACE_TYPE))
-
-    # Add it to the dict
-    builder.call_c(
-        dict_set_item_op, [builder.load_globals_dict(), builder.load_str(cdef.name), tp], cdef.line
-    )
-
-    return tp
-
-
-# Mypy uses these internally as base classes of TypedDict classes. These are
-# lies and don't have any runtime equivalent.
-MAGIC_TYPED_DICT_CLASSES: Final[tuple[str, ...]] = (
-    "typing._TypedDict",
-    "typing_extensions._TypedDict",
-)
-
-
-def populate_non_ext_bases(builder: IRBuilder, cdef: ClassDef) -> Value:
-    """Create base class tuple of a non-extension class.
-
-    The tuple is passed to the metaclass constructor.
-    """
-    is_named_tuple = cdef.info.is_named_tuple
-    ir = builder.mapper.type_to_ir[cdef.info]
-    bases = []
-    for cls in cdef.info.mro[1:]:
-        if cls.fullname == "builtins.object":
-            continue
-        if is_named_tuple and cls.fullname in (
-            "typing.Sequence",
-            "typing.Iterable",
-            "typing.Collection",
-            "typing.Reversible",
-            "typing.Container",
-            "typing.Sized",
-        ):
-            # HAX: Synthesized base classes added by mypy don't exist at runtime, so skip them.
-            #      This could break if they were added explicitly, though...
-            continue
-        # Add the current class to the base classes list of concrete subclasses
-        if cls in builder.mapper.type_to_ir:
-            base_ir = builder.mapper.type_to_ir[cls]
-            if base_ir.children is not None:
-                base_ir.children.append(ir)
-
-        if cls.fullname in MAGIC_TYPED_DICT_CLASSES:
-            # HAX: Mypy internally represents TypedDict classes differently from what
-            #      should happen at runtime. Replace with something that works.
-            module = "typing"
-            if builder.options.capi_version < (3, 9):
-                name = "TypedDict"
-                if builder.options.capi_version < (3, 8):
-                    # TypedDict was added to typing in Python 3.8.
-                    module = "typing_extensions"
-                    # TypedDict is not a real type on typing_extensions 4.7.0+
-                    name = "_TypedDict"
-                    if isinstance(typing_extensions.TypedDict, type):
-                        raise RuntimeError(
-                            "It looks like you may have an old version "
-                            "of typing_extensions installed. "
-                            "typing_extensions>=4.7.0 is required on Python 3.7."
-                        )
-            else:
-                # In Python 3.9 TypedDict is not a real type.
-                name = "_TypedDict"
-            base = builder.get_module_attr(module, name, cdef.line)
-        elif is_named_tuple and cls.fullname == "builtins.tuple":
-            if builder.options.capi_version < (3, 9):
-                name = "NamedTuple"
-            else:
-                # This was changed in Python 3.9.
-                name = "_NamedTuple"
-            base = builder.get_module_attr("typing", name, cdef.line)
-        else:
-            cls_module = cls.fullname.rsplit(".", 1)[0]
-            if cls_module == builder.current_module:
-                base = builder.load_global_str(cls.name, cdef.line)
-            else:
-                base = builder.load_module_attr_by_fullname(cls.fullname, cdef.line)
-        bases.append(base)
-        if cls.fullname in MAGIC_TYPED_DICT_CLASSES:
-            # The remaining base classes are synthesized by mypy and should be ignored.
-            break
-    return builder.new_tuple(bases, cdef.line)
-
-
-def find_non_ext_metaclass(builder: IRBuilder, cdef: ClassDef, bases: Value) -> Value:
-    """Find the metaclass of a class from its defs and bases."""
-    if cdef.metaclass:
-        declared_metaclass = builder.accept(cdef.metaclass)
-    else:
-        if cdef.info.typeddict_type is not None and builder.options.capi_version >= (3, 9):
-            # In Python 3.9, the metaclass for class-based TypedDict is typing._TypedDictMeta.
-            # We can't easily calculate it generically, so special case it.
-            return builder.get_module_attr("typing", "_TypedDictMeta", cdef.line)
-        elif cdef.info.is_named_tuple and builder.options.capi_version >= (3, 9):
-            # In Python 3.9, the metaclass for class-based NamedTuple is typing.NamedTupleMeta.
-            # We can't easily calculate it generically, so special case it.
-            return builder.get_module_attr("typing", "NamedTupleMeta", cdef.line)
-
-        declared_metaclass = builder.add(
-            LoadAddress(type_object_op.type, type_object_op.src, cdef.line)
-        )
-
-    return builder.call_c(py_calc_meta_op, [declared_metaclass, bases], cdef.line)
-
-
-def setup_non_ext_dict(
-    builder: IRBuilder, cdef: ClassDef, metaclass: Value, bases: Value
-) -> Value:
-    """Initialize the class dictionary for a non-extension class.
-
-    This class dictionary is passed to the metaclass constructor.
-    """
-    # Check if the metaclass defines a __prepare__ method, and if so, call it.
-    has_prepare = builder.call_c(
-        py_hasattr_op, [metaclass, builder.load_str("__prepare__")], cdef.line
-    )
-
-    non_ext_dict = Register(dict_rprimitive)
-
-    true_block, false_block, exit_block = BasicBlock(), BasicBlock(), BasicBlock()
-    builder.add_bool_branch(has_prepare, true_block, false_block)
-
-    builder.activate_block(true_block)
-    cls_name = builder.load_str(cdef.name)
-    prepare_meth = builder.py_get_attr(metaclass, "__prepare__", cdef.line)
-    prepare_dict = builder.py_call(prepare_meth, [cls_name, bases], cdef.line)
-    builder.assign(non_ext_dict, prepare_dict, cdef.line)
-    builder.goto(exit_block)
-
-    builder.activate_block(false_block)
-    builder.assign(non_ext_dict, builder.call_c(dict_new_op, [], cdef.line), cdef.line)
-    builder.goto(exit_block)
-    builder.activate_block(exit_block)
-
-    return non_ext_dict
-
-
-def add_non_ext_class_attr_ann(
-    builder: IRBuilder,
-    non_ext: NonExtClassInfo,
-    lvalue: NameExpr,
-    stmt: AssignmentStmt,
-    get_type_info: Callable[[AssignmentStmt], TypeInfo | None] | None = None,
-) -> None:
-    """Add a class attribute to __annotations__ of a non-extension class."""
-    # FIXME: try to better preserve the special forms and type parameters of generics.
-    typ: Value | None = None
-    if get_type_info is not None:
-        type_info = get_type_info(stmt)
-        if type_info:
-            typ = load_type(builder, type_info, stmt.line)
-
-    if typ is None:
-        # FIXME: if get_type_info is not provided, don't fall back to stmt.type?
-        ann_type = get_proper_type(stmt.type)
-        if (
-            isinstance(stmt.unanalyzed_type, UnboundType)
-            and stmt.unanalyzed_type.original_str_expr is not None
-        ):
-            # Annotation is a forward reference, so don't attempt to load the actual
-            # type and load the string instead.
-            #
-            # TODO: is it possible to determine whether a non-string annotation is
-            # actually a forward reference due to the __annotations__ future?
-            typ = builder.load_str(stmt.unanalyzed_type.original_str_expr)
-        elif isinstance(ann_type, Instance):
-            typ = load_type(builder, ann_type.type, stmt.line)
-        else:
-            typ = builder.add(LoadAddress(type_object_op.type, type_object_op.src, stmt.line))
-
-    key = builder.load_str(lvalue.name)
-    builder.call_c(dict_set_item_op, [non_ext.anns, key, typ], stmt.line)
-
-
-def add_non_ext_class_attr(
-    builder: IRBuilder,
-    non_ext: NonExtClassInfo,
-    lvalue: NameExpr,
-    stmt: AssignmentStmt,
-    cdef: ClassDef,
-    attr_to_cache: list[tuple[Lvalue, RType]],
-) -> None:
-    """Add a class attribute to __dict__ of a non-extension class."""
-    # Only add the attribute to the __dict__ if the assignment is of the form:
-    # x: type = value (don't add attributes of the form 'x: type' to the __dict__).
-    if not isinstance(stmt.rvalue, TempNode):
-        rvalue = builder.accept(stmt.rvalue)
-        builder.add_to_non_ext_dict(non_ext, lvalue.name, rvalue, stmt.line)
-        # We cache enum attributes to speed up enum attribute lookup since they
-        # are final.
-        if (
-            cdef.info.bases
-            and cdef.info.bases[0].type.fullname == "enum.Enum"
-            # Skip these since Enum will remove it
-            and lvalue.name not in ENUM_REMOVED_PROPS
-        ):
-            # Enum values are always boxed, so use object_rprimitive.
-            attr_to_cache.append((lvalue, object_rprimitive))
-
-
-def find_attr_initializers(
-    builder: IRBuilder, cdef: ClassDef, skip: Callable[[str, AssignmentStmt], bool] | None = None
-) -> tuple[set[str], list[AssignmentStmt]]:
-    """Find initializers of attributes in a class body.
-
-    If provided, the skip arg should be a callable which will return whether
-    to skip generating a default for an attribute.  It will be passed the name of
-    the attribute and the corresponding AssignmentStmt.
-    """
-    cls = builder.mapper.type_to_ir[cdef.info]
-    if cls.builtin_base:
-        return set(), []
-
-    attrs_with_defaults = set()
-
-    # Pull out all assignments in classes in the mro so we can initialize them
-    # TODO: Support nested statements
-    default_assignments = []
-    for info in reversed(cdef.info.mro):
-        if info not in builder.mapper.type_to_ir:
-            continue
-        for stmt in info.defn.defs.body:
-            if (
-                isinstance(stmt, AssignmentStmt)
-                and isinstance(stmt.lvalues[0], NameExpr)
-                and not is_class_var(stmt.lvalues[0])
-                and not isinstance(stmt.rvalue, TempNode)
-            ):
-                name = stmt.lvalues[0].name
-                if name == "__slots__":
-                    continue
-
-                if name == "__deletable__":
-                    check_deletable_declaration(builder, cls, stmt.line)
-                    continue
-
-                if skip is not None and skip(name, stmt):
-                    continue
-
-                attr_type = cls.attr_type(name)
-
-                # If the attribute is initialized to None and type isn't optional,
-                # doesn't initialize it to anything (special case for "# type:" comments).
-                if isinstance(stmt.rvalue, RefExpr) and stmt.rvalue.fullname == "builtins.None":
-                    if (
-                        not is_optional_type(attr_type)
-                        and not is_object_rprimitive(attr_type)
-                        and not is_none_rprimitive(attr_type)
-                    ):
-                        continue
-
-                attrs_with_defaults.add(name)
-                default_assignments.append(stmt)
-
-    return attrs_with_defaults, default_assignments
-
-
-def generate_attr_defaults_init(
-    builder: IRBuilder, cdef: ClassDef, default_assignments: list[AssignmentStmt]
-) -> None:
-    """Generate an initialization method for default attr values (from class vars)."""
-    if not default_assignments:
-        return
-    cls = builder.mapper.type_to_ir[cdef.info]
-    if cls.builtin_base:
-        return
-
-    with builder.enter_method(cls, "__mypyc_defaults_setup", bool_rprimitive):
-        self_var = builder.self()
-        for stmt in default_assignments:
-            lvalue = stmt.lvalues[0]
-            assert isinstance(lvalue, NameExpr)
-            if not stmt.is_final_def and not is_constant(stmt.rvalue):
-                builder.warning("Unsupported default attribute value", stmt.rvalue.line)
-
-            attr_type = cls.attr_type(lvalue.name)
-            val = builder.coerce(builder.accept(stmt.rvalue), attr_type, stmt.line)
-            init = SetAttr(self_var, lvalue.name, val, -1)
-            init.mark_as_initializer()
-            builder.add(init)
-
-        builder.add(Return(builder.true()))
-
-
-def check_deletable_declaration(builder: IRBuilder, cl: ClassIR, line: int) -> None:
-    for attr in cl.deletable:
-        if attr not in cl.attributes:
-            if not cl.has_attr(attr):
-                builder.error(f'Attribute "{attr}" not defined', line)
-                continue
-            for base in cl.mro:
-                if attr in base.property_types:
-                    builder.error(f'Cannot make property "{attr}" deletable', line)
-                    break
-            else:
-                _, base = cl.attr_details(attr)
-                builder.error(
-                    ('Attribute "{}" not defined in "{}" ' + '(defined in "{}")').format(
-                        attr, cl.name, base.name
-                    ),
-                    line,
-                )
-
-
-def create_ne_from_eq(builder: IRBuilder, cdef: ClassDef) -> None:
-    """Create a "__ne__" method from a "__eq__" method (if only latter exists)."""
-    cls = builder.mapper.type_to_ir[cdef.info]
-    if cls.has_method("__eq__") and not cls.has_method("__ne__"):
-        gen_glue_ne_method(builder, cls, cdef.line)
-
-
-def gen_glue_ne_method(builder: IRBuilder, cls: ClassIR, line: int) -> None:
-    """Generate a "__ne__" method from a "__eq__" method."""
-    with builder.enter_method(cls, "__ne__", object_rprimitive):
-        rhs_arg = builder.add_argument("rhs", object_rprimitive)
-
-        # If __eq__ returns NotImplemented, then __ne__ should also
-        not_implemented_block, regular_block = BasicBlock(), BasicBlock()
-        eqval = builder.add(MethodCall(builder.self(), "__eq__", [rhs_arg], line))
-        not_implemented = builder.add(
-            LoadAddress(not_implemented_op.type, not_implemented_op.src, line)
-        )
-        builder.add(
-            Branch(
-                builder.translate_is_op(eqval, not_implemented, "is", line),
-                not_implemented_block,
-                regular_block,
-                Branch.BOOL,
-            )
-        )
-
-        builder.activate_block(regular_block)
-        retval = builder.coerce(builder.unary_op(eqval, "not", line), object_rprimitive, line)
-        builder.add(Return(retval))
-
-        builder.activate_block(not_implemented_block)
-        builder.add(Return(not_implemented))
-
-
-def load_non_ext_class(
-    builder: IRBuilder, ir: ClassIR, non_ext: NonExtClassInfo, line: int
-) -> Value:
-    cls_name = builder.load_str(ir.name)
-
-    add_dunders_to_non_ext_dict(builder, non_ext, line)
-
-    class_type_obj = builder.py_call(
-        non_ext.metaclass, [cls_name, non_ext.bases, non_ext.dict], line
-    )
-    return class_type_obj
-
-
-def load_decorated_class(builder: IRBuilder, cdef: ClassDef, type_obj: Value) -> Value:
-    """Apply class decorators to create a decorated (non-extension) class object.
-
-    Given a decorated ClassDef and a register containing a
-    non-extension representation of the ClassDef created via the type
-    constructor, applies the corresponding decorator functions on that
-    decorated ClassDef and returns a register containing the decorated
-    ClassDef.
-    """
-    decorators = cdef.decorators
-    dec_class = type_obj
-    for d in reversed(decorators):
-        decorator = d.accept(builder.visitor)
-        assert isinstance(decorator, Value)
-        dec_class = builder.py_call(decorator, [dec_class], dec_class.line)
-    return dec_class
-
-
-def cache_class_attrs(
-    builder: IRBuilder, attrs_to_cache: list[tuple[Lvalue, RType]], cdef: ClassDef
-) -> None:
-    """Add class attributes to be cached to the global cache."""
-    typ = builder.load_native_type_object(cdef.info.fullname)
-    for lval, rtype in attrs_to_cache:
-        assert isinstance(lval, NameExpr)
-        rval = builder.py_get_attr(typ, lval.name, cdef.line)
-        builder.init_final_static(lval, rval, cdef.name, type_override=rtype)
-
-
-def create_mypyc_attrs_tuple(builder: IRBuilder, ir: ClassIR, line: int) -> Value:
-    attrs = [name for ancestor in ir.mro for name in ancestor.attributes]
-    if ir.inherits_python:
-        attrs.append("__dict__")
-    items = [builder.load_str(attr) for attr in attrs]
-    return builder.new_tuple(items, line)
-
-
-def add_dunders_to_non_ext_dict(
-    builder: IRBuilder, non_ext: NonExtClassInfo, line: int, add_annotations: bool = True
-) -> None:
-    if add_annotations:
-        # Add __annotations__ to the class dict.
-        builder.add_to_non_ext_dict(non_ext, "__annotations__", non_ext.anns, line)
-
-    # We add a __doc__ attribute so if the non-extension class is decorated with the
-    # dataclass decorator, dataclass will not try to look for __text_signature__.
-    # https://github.com/python/cpython/blob/3.7/Lib/dataclasses.py#L957
-    filler_doc_str = "mypyc filler docstring"
-    builder.add_to_non_ext_dict(non_ext, "__doc__", builder.load_str(filler_doc_str), line)
-    builder.add_to_non_ext_dict(non_ext, "__module__", builder.load_str(builder.module_name), line)