Value types are working for basic class definitions

Author: jairov4

mypyc/analysis/attrdefined.py

@@ -90,7 +90,7 @@ def foo(self) -> int:
     SetMem,
     Unreachable,
 )
-from mypyc.ir.rtypes import RInstance
+from mypyc.ir.rtypes import RInstance, RInstanceValue
 
 # If True, print out all always-defined attributes of native classes (to aid
 # debugging and testing)

mypyc/codegen/emit.py

@@ -49,7 +49,7 @@
     is_tuple_rprimitive,
     is_uint8_rprimitive,
     object_rprimitive,
-    optional_value_type,
+    optional_value_type, RInstanceValue,
 )
 from mypyc.namegen import NameGenerator, exported_name
 from mypyc.sametype import is_same_type
@@ -322,6 +322,8 @@ def c_undefined_value(self, rtype: RType) -> str:
             return rtype.c_undefined
         elif isinstance(rtype, RTuple):
             return self.tuple_undefined_value(rtype)
+        elif isinstance(rtype, RInstanceValue):
+            return self.rinstance_value_undefined_value(rtype)
         assert False, rtype
 
     def c_error_value(self, rtype: RType) -> str:
@@ -427,6 +429,8 @@ def error_value_check(self, rtype: RType, value: str, compare: str) -> str:
             return self.tuple_undefined_check_cond(
                 rtype, value, self.c_error_value, compare, check_exception=False
             )
+        elif isinstance(rtype, RInstanceValue):
+            return f"{value}.vtable {compare} NULL"
         else:
             return f"{value} {compare} {self.c_error_value(rtype)}"
 
@@ -468,6 +472,10 @@ def tuple_undefined_value(self, rtuple: RTuple) -> str:
         """Undefined tuple value suitable in an expression."""
         return f"({rtuple.struct_name}) {self.c_initializer_undefined_value(rtuple)}"
 
+    def rinstance_value_undefined_value(self, rinstance_value: RInstanceValue) -> str:
+        """Undefined value for an unboxed instance."""
+        return f"(({rinstance_value.struct_name(self.names)}){self.c_initializer_undefined_value(rinstance_value)})"
+
     def c_initializer_undefined_value(self, rtype: RType) -> str:
         """Undefined value represented in a form suitable for variable initialization."""
         if isinstance(rtype, RTuple):
@@ -477,6 +485,8 @@ def c_initializer_undefined_value(self, rtype: RType) -> str:
                 return f"{{ {int_rprimitive.c_undefined} }}"
             items = ", ".join([self.c_initializer_undefined_value(t) for t in rtype.types])
             return f"{{ {items} }}"
+        elif isinstance(rtype, RInstanceValue):
+            return "{0}"
         else:
             return self.c_undefined_value(rtype)
 
@@ -987,7 +997,17 @@ def emit_unbox(
             self.emit_line("}")
             if optional:
                 self.emit_line("}")
+        elif isinstance(typ, RInstanceValue):
+            if declare_dest:
+                self.emit_line(f"{self.ctype(typ)} {dest};")
+            if optional:
+                self.emit_line(f"if ({src} == NULL) {{")
+                self.emit_line(f"{dest} = {self.c_error_value(typ)};")
+                self.emit_line("} else {")
 
+            self.emit_line(f"{dest} = *({self.ctype(typ)} *){src};")
+            if optional:
+                self.emit_line("}")
         else:
             assert False, "Unboxing not implemented: %s" % typ
 
@@ -1041,6 +1061,22 @@ def emit_box(
                     inner_name = self.temp_name()
                     self.emit_box(f"{src}.f{i}", inner_name, typ.types[i], declare_dest=True)
                     self.emit_line(f"PyTuple_SET_ITEM({dest}, {i}, {inner_name});")
+        elif isinstance(typ, RInstanceValue):
+            cl = typ.class_ir
+            generate_full = not cl.is_trait and not cl.builtin_base
+            assert generate_full, "Only full classes can be boxed"  # only those have setup method
+            name_prefix = cl.name_prefix(self.names)
+            setup_name = f"{name_prefix}_setup"
+            py_type_struct = self.type_struct_name(cl)
+            temp_dest = self.temp_name()
+            self.emit_line(f"{self.ctype_spaced(typ)}*{temp_dest} = ({self.ctype_spaced(typ)}*){setup_name}({py_type_struct});")
+            self.emit_line(f"if (unlikely({temp_dest} == NULL))")
+            self.emit_line("    CPyError_OutOfMemory();")
+            for attr, attr_type in cl.attributes.items():
+                attr_name = self.attr(attr)
+                self.emit_line(f"{temp_dest}->{attr_name} = {src}.{attr_name};", ann="box")
+
+            self.emit_line(f"{declaration}{dest} = (PyObject *){temp_dest};")
         else:
             assert not typ.is_unboxed
             # Type is boxed -- trivially just assign.
@@ -1054,6 +1090,8 @@ def emit_error_check(self, value: str, rtype: RType, failure: str) -> None:
             else:
                 cond = self.tuple_undefined_check_cond(rtype, value, self.c_error_value, "==")
                 self.emit_line(f"if ({cond}) {{")
+        elif isinstance(rtype, RInstanceValue):
+            self.emit_line(f"if ({value}.vtable == NULL) {{")
         elif rtype.error_overlap:
             # The error value is also valid as a normal value, so we need to also check
             # for a raised exception.

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, struct_type
+from mypyc.codegen.emitfunc import native_function_header
 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, RInstance
+from mypyc.ir.rtypes import RTuple, RType, object_rprimitive
 from mypyc.namegen import NameGenerator
 from mypyc.sametype import is_same_type
 
@@ -294,7 +294,10 @@ def emit_line() -> None:
         # Declare setup method that allocates and initializes an object. type is the
         # type of the class being initialized, which could be another class if there
         # is an interpreted subclass.
-        emitter.emit_line(f"static PyObject *{setup_name}(PyTypeObject *type);")
+        emitter.context.declarations[setup_name] = HeaderDeclaration(
+            f"PyObject *{setup_name}(PyTypeObject *type);", needs_export=True
+        )
+
         assert cl.ctor is not None
         emitter.emit_line(native_function_header(cl.ctor, emitter) + ";")
 
@@ -397,13 +400,7 @@ def generate_object_struct(cl: ClassIR, emitter: Emitter) -> None:
 
             for attr, rtype in base.attributes.items():
                 if (attr, rtype) not in seen_attrs:
-                    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)};")
-
+                    lines.append(f"{emitter.ctype_spaced(rtype)}{emitter.attr(attr)};")
                     seen_attrs.add((attr, rtype))
 
                     if isinstance(rtype, RTuple):
@@ -562,7 +559,7 @@ def generate_setup_for_class(
     emitter: Emitter,
 ) -> None:
     """Generate a native function that allocates an instance of a class."""
-    emitter.emit_line("static PyObject *")
+    emitter.emit_line("PyObject *")
     emitter.emit_line(f"{func_name}(PyTypeObject *type)")
     emitter.emit_line("{")
     emitter.emit_line(f"{cl.struct_name(emitter.names)} *self;")
@@ -593,7 +590,7 @@ def generate_setup_for_class(
 
             # We don't need to set this field to NULL since tp_alloc() already
             # zero-initializes `self`.
-            if value != "NULL":
+            if value not in ("NULL", "0"):
                 emitter.emit_line(rf"self->{emitter.attr(attr)} = {value};")
 
     # Initialize attributes to default values, if necessary
@@ -622,10 +619,15 @@ def generate_constructor_for_class(
     """Generate a native function that allocates and initializes an instance of a class."""
     emitter.emit_line(f"{native_function_header(fn, emitter)}")
     emitter.emit_line("{")
-    emitter.emit_line(f"PyObject *self = {setup_name}({emitter.type_struct_name(cl)});")
-    emitter.emit_line("if (self == NULL)")
-    emitter.emit_line("    return NULL;")
-    args = ", ".join(["self"] + [REG_PREFIX + arg.name for arg in fn.sig.args])
+    if cl.is_value_type:
+        emitter.emit_line(f"{cl.struct_name(emitter.names)} self = {{0}};")
+        emitter.emit_line(f"self.vtable = {vtable_name};")
+        args = ", ".join(["(PyObject*)&self"] + [REG_PREFIX + arg.name for arg in fn.sig.args])
+    else:
+        emitter.emit_line(f"PyObject *self = {setup_name}({emitter.type_struct_name(cl)});")
+        emitter.emit_line("if (self == NULL)")
+        emitter.emit_line("    return NULL;")
+        args = ", ".join(["self"] + [REG_PREFIX + arg.name for arg in fn.sig.args])
     if init_fn is not None:
         emitter.emit_line(
             "char res = {}{}{}({});".format(
@@ -636,17 +638,25 @@ def generate_constructor_for_class(
             )
         )
         emitter.emit_line("if (res == 2) {")
-        emitter.emit_line("Py_DECREF(self);")
-        emitter.emit_line("return NULL;")
+        if cl.is_value_type:
+            emitter.emit_line("self.vtable = NULL;")
+            emitter.emit_line("return self;")
+        else:
+            emitter.emit_line("Py_DECREF(self);")
+            emitter.emit_line("return NULL;")
         emitter.emit_line("}")
 
     # If there is a nontrivial ctor that we didn't define, invoke it via tp_init
     elif len(fn.sig.args) > 1:
         emitter.emit_line(f"int res = {emitter.type_struct_name(cl)}->tp_init({args});")
 
         emitter.emit_line("if (res < 0) {")
-        emitter.emit_line("Py_DECREF(self);")
-        emitter.emit_line("return NULL;")
+        if cl.is_value_type:
+            emitter.emit_line("self.vtable = NULL;")
+            emitter.emit_line("return self;")
+        else:
+            emitter.emit_line("Py_DECREF(self);")
+            emitter.emit_line("return NULL;")
         emitter.emit_line("}")
 
     emitter.emit_line("return self;")

mypyc/codegen/emitfunc.py

@@ -83,6 +83,7 @@
     is_pointer_rprimitive,
     is_tagged,
     PyObject,
+    RInstanceValue,
 )
 
 
@@ -240,6 +241,8 @@ def visit_branch(self, op: Branch) -> None:
                 cond = self.emitter.tuple_undefined_check_cond(
                     typ, self.reg(op.value), self.c_error_value, compare
                 )
+            elif isinstance(typ, RInstanceValue):
+                cond = f"{self.reg(op.value)}.vtable {compare} NULL"
             else:
                 cond = f"{self.reg(op.value)} {compare} {self.c_error_value(typ)}"
         else:
@@ -363,7 +366,11 @@ def get_attr_expr(self, obj: str, op: GetAttr | SetAttr, decl_cl: ClassIR) -> st
             if op.class_type.class_ir.is_trait:
                 assert not decl_cl.is_trait
                 cast = f"({decl_cl.struct_name(self.emitter.names)} *)"
-            return f"({cast}{obj})->{self.emitter.attr(op.attr)}"
+
+            if op.obj.type.is_unboxed:
+                return f"{obj}.{self.emitter.attr(op.attr)}"
+            else:
+                return f"({cast}{obj})->{self.emitter.attr(op.attr)}"
 
     def visit_get_attr(self, op: GetAttr) -> None:
         dest = self.reg(op)
@@ -548,42 +555,8 @@ 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/codegen/emitmodule.py

@@ -63,6 +63,7 @@
 from mypyc.transform.lower import lower_ir
 from mypyc.transform.refcount import insert_ref_count_opcodes
 from mypyc.transform.uninit import insert_uninit_checks
+from mypyc.transform.value_type_init import patch_value_type_init_methods
 
 # All of the modules being compiled are divided into "groups". A group
 # is a set of modules that are placed into the same shared library.
@@ -231,6 +232,8 @@ def compile_scc_to_ir(
 
     for module in modules.values():
         for fn in module.functions:
+            # Patch init methods for Value Types
+            patch_value_type_init_methods(fn, compiler_options)
             # Insert uninit checks.
             insert_uninit_checks(fn)
             # Insert exception handling.

mypyc/codegen/emitwrapper.py

@@ -34,7 +34,7 @@
     is_bool_rprimitive,
     is_int_rprimitive,
     is_object_rprimitive,
-    object_rprimitive,
+    object_rprimitive, RInstanceValue,
 )
 from mypyc.namegen import NameGenerator
 

mypyc/ir/class_ir.py

@@ -7,7 +7,7 @@
 from mypyc.common import PROPSET_PREFIX, JsonDict
 from mypyc.ir.func_ir import FuncDecl, FuncIR, FuncSignature
 from mypyc.ir.ops import DeserMaps, Value
-from mypyc.ir.rtypes import RInstance, RType, deserialize_type
+from mypyc.ir.rtypes import RInstance, RType, deserialize_type, RInstanceValue
 from mypyc.namegen import NameGenerator, exported_name
 
 # Some notes on the vtable layout: Each concrete class has a vtable
@@ -116,6 +116,8 @@ def __init__(
         # Does this class need getseters to be generated for its attributes? (getseters are also
         # added if is_generated is False)
         self.needs_getseters = False
+        # A value type is a class that can be passed by value instead of by reference.
+        self.is_value_type = self.is_ext_class and self.is_immutable and not self.has_dict
         # Is this class declared as serializable (supports copy.copy
         # and pickle) using @mypyc_attr(serializable=True)?
         #
@@ -133,8 +135,10 @@ def __init__(
         # of the object for that class. We currently only support this
         # in a few ad-hoc cases.
         self.builtin_base: str | None = None
+        # The RType for instances of this class
+        self.rtype = RInstanceValue(self) if self.is_value_type else RInstance(self)
         # Default empty constructor
-        self.ctor = FuncDecl(name, None, module_name, FuncSignature([], RInstance(self)))
+        self.ctor = FuncDecl(name, None, module_name, FuncSignature([], self.rtype))
         # Attributes defined in the class (not inherited)
         self.attributes: dict[str, RType] = {}
         # Deletable attributes
@@ -212,10 +216,6 @@ def __repr__(self) -> str:
     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:
@@ -289,6 +289,12 @@ def name_prefix(self, names: NameGenerator) -> str:
     def struct_name(self, names: NameGenerator) -> str:
         return f"{exported_name(self.fullname)}Object"
 
+    def struct_name2(self) -> str:
+        return f"{exported_name(self.fullname)}Object"
+
+    def struct_data_name(self) -> str:
+        return f"{exported_name(self.fullname)}Data"
+
     def get_method_and_class(
         self, name: str, *, prefer_method: bool = False
     ) -> tuple[FuncIR, ClassIR] | None:

mypyc/ir/ops.py

@@ -35,7 +35,7 @@
     object_rprimitive,
     pointer_rprimitive,
     short_int_rprimitive,
-    void_rtype,
+    void_rtype, RInstanceValue,
 )
 
 if TYPE_CHECKING: