Promote immutable RInstances to value types

Author: jairov4

mypyc/codegen/emitclass.py

@@ -5,7 +5,7 @@
 from typing import Callable, Mapping, Tuple
 
 from mypyc.codegen.emit import Emitter, HeaderDeclaration, ReturnHandler
-from mypyc.codegen.emitfunc import native_function_header
+from mypyc.codegen.emitfunc import native_function_header, struct_type
 from mypyc.codegen.emitwrapper import (
     generate_bin_op_wrapper,
     generate_bool_wrapper,
@@ -21,7 +21,7 @@
 from mypyc.common import BITMAP_BITS, BITMAP_TYPE, NATIVE_PREFIX, PREFIX, REG_PREFIX
 from mypyc.ir.class_ir import ClassIR, VTableEntries
 from mypyc.ir.func_ir import FUNC_CLASSMETHOD, FUNC_STATICMETHOD, FuncDecl, FuncIR
-from mypyc.ir.rtypes import RTuple, RType, object_rprimitive
+from mypyc.ir.rtypes import RTuple, RType, object_rprimitive, RInstance
 from mypyc.namegen import NameGenerator
 from mypyc.sametype import is_same_type
 
@@ -394,9 +394,16 @@ def generate_object_struct(cl: ClassIR, emitter: Emitter) -> None:
                         if attr not in bitmap_attrs:
                             lines.append(f"{BITMAP_TYPE} {attr};")
                             bitmap_attrs.append(attr)
+
             for attr, rtype in base.attributes.items():
                 if (attr, rtype) not in seen_attrs:
-                    lines.append(f"{emitter.ctype_spaced(rtype)}{emitter.attr(attr)};")
+                    if isinstance(rtype, RInstance) and rtype.class_ir.is_value_type:
+                        # value types use structs directly
+                        rtype_struct = struct_type(rtype.class_ir, emitter)
+                        lines.append(f"{emitter.ctype_spaced(rtype_struct)}{emitter.attr(attr)};")
+                    else:
+                        lines.append(f"{emitter.ctype_spaced(rtype)}{emitter.attr(attr)};")
+
                     seen_attrs.add((attr, rtype))
 
                     if isinstance(rtype, RTuple):

mypyc/codegen/emitfunc.py

@@ -71,6 +71,7 @@
 )
 from mypyc.ir.pprint import generate_names_for_ir
 from mypyc.ir.rtypes import (
+    c_pyssize_t_rprimitive,
     RArray,
     RInstance,
     RStruct,
@@ -81,9 +82,19 @@
     is_int_rprimitive,
     is_pointer_rprimitive,
     is_tagged,
+    PyObject,
 )
 
 
+def struct_type(class_ir: ClassIR, emitter: Emitter) -> RStruct:
+    """Return the struct type for this instance type."""
+    python_fields: list[tuple[str, RType]] = [("head", PyObject), ("vtable", c_pyssize_t_rprimitive)]
+    class_fields = list(class_ir.attributes.items())
+    attr_names = [emitter.attr(name) for name, _ in python_fields + class_fields]
+    attr_types = [rtype for _, rtype in python_fields + class_fields]
+    return RStruct(class_ir.struct_name(emitter.names), attr_names, attr_types)
+
+
 def native_function_type(fn: FuncIR, emitter: Emitter) -> str:
     args = ", ".join(emitter.ctype(arg.type) for arg in fn.args) or "void"
     ret = emitter.ctype(fn.ret_type)
@@ -383,8 +394,18 @@ def visit_get_attr(self, op: GetAttr) -> None:
         else:
             # Otherwise, use direct or offset struct access.
             attr_expr = self.get_attr_expr(obj, op, decl_cl)
-            self.emitter.emit_line(f"{dest} = {attr_expr};")
             always_defined = cl.is_always_defined(op.attr)
+            # This steals the reference to src, so we don't need to increment the arg
+            if isinstance(attr_rtype, RInstance) and attr_rtype.class_ir.is_value_type:
+                # special case for value types, it is unboxed in the struct
+                struct_name = attr_rtype.class_ir.struct_name(self.names)
+                temp = self.emitter.temp_name()
+                self.emitter.emit_line(f"{struct_name} {temp} = {attr_expr};")
+                self.emitter.emit_line(f"{dest} = (PyObject *)&{temp};")
+                always_defined = True
+            else:
+                self.emitter.emit_line(f"{dest} = {attr_expr};")
+
             merged_branch = None
             if not always_defined:
                 self.emitter.emit_undefined_attr_check(
@@ -481,7 +502,12 @@ def visit_set_attr(self, op: SetAttr) -> None:
                 self.emitter.emit_attr_bitmap_set(src, obj, attr_rtype, cl, op.attr)
 
             # This steals the reference to src, so we don't need to increment the arg
-            self.emitter.emit_line(f"{attr_expr} = {src};")
+            if isinstance(attr_rtype, RInstance) and attr_rtype.class_ir.is_value_type:
+                # special case for value types, it is unboxed in the struct
+                struct_name = attr_rtype.class_ir.struct_name(self.names)
+                self.emitter.emit_line(f"{attr_expr} = *({struct_name} *)({src});")
+            else:
+                self.emitter.emit_line(f"{attr_expr} = {src};")
             if op.error_kind == ERR_FALSE:
                 self.emitter.emit_line(f"{dest} = 1;")
 
@@ -522,8 +548,42 @@ def get_dest_assign(self, dest: Value) -> str:
         else:
             return ""
 
+    def try_emit_new_value_type_call(self, op: Call) -> bool:
+        if not isinstance(op.type, RInstance):
+            return False
+
+        cl = op.type.class_ir
+        if op.fn.fullname != op.type.name or not cl.is_value_type:
+            return False
+
+        assert not op.type.is_refcounted, "Value types must not be refcounted"
+        dest = self.get_dest_assign(op)
+        struct_name = cl.struct_name(self.names)
+        temp_name = self.emitter.temp_name()
+        temp_name2 = self.emitter.temp_name()
+        self.emit_line(f"{struct_name} {temp_name};")
+        init_fn = cl.get_method("__init__")
+        if init_fn:
+            args = [self.reg(arg) for arg in op.args]
+            self.emitter.emit_line(
+                "char {} = {}{}{}({});".format(
+                    temp_name2,
+                    self.emitter.get_group_prefix(init_fn.decl),
+                    NATIVE_PREFIX,
+                    init_fn.cname(self.emitter.names),
+                    ", ".join([f"&{temp_name}"] + args),
+                )
+            )
+            self.emit_line(f"{dest}{temp_name2} != 2 ? (PyObject *)&{temp_name} : NULL;")
+        else:
+            self.emit_line(f"{dest}(PyObject *)&{temp_name};")
+        return True
+
     def visit_call(self, op: Call) -> None:
         """Call native function."""
+        if self.try_emit_new_value_type_call(op):
+            return
+
         dest = self.get_dest_assign(op)
         args = ", ".join(self.reg(arg) for arg in op.args)
         lib = self.emitter.get_group_prefix(op.fn)

mypyc/ir/class_ir.py

@@ -94,6 +94,7 @@ def __init__(
         is_abstract: bool = False,
         is_ext_class: bool = True,
         is_final_class: bool = False,
+        is_immutable: bool = False,
     ) -> None:
         self.name = name
         self.module_name = module_name
@@ -102,6 +103,7 @@ def __init__(
         self.is_abstract = is_abstract
         self.is_ext_class = is_ext_class
         self.is_final_class = is_final_class
+        self.is_immutable = is_immutable
         # An augmented class has additional methods separate from what mypyc generates.
         # Right now the only one is dataclasses.
         self.is_augmented = False
@@ -202,14 +204,18 @@ def __repr__(self) -> str:
             "name={self.name}, module_name={self.module_name}, "
             "is_trait={self.is_trait}, is_generated={self.is_generated}, "
             "is_abstract={self.is_abstract}, is_ext_class={self.is_ext_class}, "
-            "is_final_class={self.is_final_class}"
+            "is_final_class={self.is_final_class}, is_immutable={self.is_immutable}"
             ")".format(self=self)
         )
 
     @property
     def fullname(self) -> str:
         return f"{self.module_name}.{self.name}"
 
+    @property
+    def is_value_type(self) -> bool:
+        return self.is_ext_class and self.is_immutable and not self.has_dict
+
     def real_base(self) -> ClassIR | None:
         """Return the actual concrete base class, if there is one."""
         if len(self.mro) > 1 and not self.mro[1].is_trait:
@@ -352,6 +358,7 @@ def serialize(self) -> JsonDict:
             "is_generated": self.is_generated,
             "is_augmented": self.is_augmented,
             "is_final_class": self.is_final_class,
+            "is_immutable": self.is_immutable,
             "inherits_python": self.inherits_python,
             "has_dict": self.has_dict,
             "allow_interpreted_subclasses": self.allow_interpreted_subclasses,
@@ -408,6 +415,7 @@ def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> ClassIR:
         ir.is_ext_class = data["is_ext_class"]
         ir.is_augmented = data["is_augmented"]
         ir.is_final_class = data["is_final_class"]
+        ir.is_immutable = data["is_immutable"]
         ir.inherits_python = data["inherits_python"]
         ir.has_dict = data["has_dict"]
         ir.allow_interpreted_subclasses = data["allow_interpreted_subclasses"]

mypyc/ir/rtypes.py

@@ -798,7 +798,7 @@ def deserialize(cls, data: JsonDict, ctx: DeserMaps) -> RStruct:
 class RInstance(RType):
     """Instance of user-defined class (compiled to C extension class).
 
-    The runtime representation is 'PyObject *', and these are always
+    The runtime representation is typically 'PyObject *', and these are
     boxed and thus reference-counted.
 
     These support fast method calls and fast attribute access using
@@ -819,6 +819,7 @@ def __init__(self, class_ir: ClassIR) -> None:
         self.name = class_ir.fullname
         self.class_ir = class_ir
         self._ctype = "PyObject *"
+        self.is_refcounted = not class_ir.is_value_type
 
     def accept(self, visitor: RTypeVisitor[T]) -> T:
         return visitor.visit_rinstance(self)

mypyc/irbuild/classdef.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
-import typing_extensions
 from abc import abstractmethod
 from typing import Callable, Final
 
+import typing_extensions
+
 from mypy.nodes import (
     TYPE_VAR_TUPLE_KIND,
     AssignmentStmt,
@@ -68,7 +69,6 @@
     get_func_def,
     is_constant,
     is_dataclass_decorator,
-    is_final_class,
 )
 from mypyc.primitives.dict_ops import dict_new_op, dict_set_item_op
 from mypyc.primitives.generic_ops import (
@@ -301,7 +301,6 @@ def add_attr(self, lvalue: NameExpr, stmt: AssignmentStmt) -> None:
             self.builder.init_final_static(lvalue, value, self.cdef.name)
 
     def finalize(self, ir: ClassIR) -> None:
-        ir.is_final_class = is_final_class(self.cdef)
         attrs_with_defaults, default_assignments = find_attr_initializers(
             self.builder, self.cdef, self.skip_attr_default
         )

mypyc/irbuild/prepare.py

@@ -58,6 +58,7 @@
     is_dataclass,
     is_extension_class,
     is_trait,
+    is_immutable,
 )
 from mypyc.options import CompilerOptions
 from mypyc.sametype import is_same_type
@@ -81,7 +82,12 @@ def build_type_map(
     # references even if there are import cycles.
     for module, cdef in classes:
         class_ir = ClassIR(
-            cdef.name, module.fullname, is_trait(cdef), is_abstract=cdef.info.is_abstract
+            cdef.name,
+            module.fullname,
+            is_trait(cdef),
+            is_abstract=cdef.info.is_abstract,
+            is_immutable=is_immutable(cdef),
+            is_final_class=cdef.info.is_final,
         )
         class_ir.is_ext_class = is_extension_class(cdef)
         if class_ir.is_ext_class:

mypyc/irbuild/util.py

@@ -83,6 +83,15 @@ def dataclass_type(cdef: ClassDef) -> str | None:
     return None
 
 
+def is_immutable(cdef: ClassDef) -> bool:
+    """Check if a class is immutable by checking if all its variables are marked as Final."""
+    for v in cdef.info.names.values():
+        if isinstance(v.node, Var) and v.node.name not in ("__slots__",):
+            if not v.node.is_final and not v.node.is_property:
+                return False
+    return True
+
+
 def get_mypyc_attr_literal(e: Expression) -> Any:
     """Convert an expression from a mypyc_attr decorator to a value.