mypy-dev 1.9.0.dev0__py3-none-any.whl

mypyc/irbuild/classdef.py

@@ -0,0 +1,850 @@
+"""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)