Add tests for str and repr

Author: jairov4

mypyc/codegen/emitclass.py

@@ -17,6 +17,7 @@
     generate_len_wrapper,
     generate_richcompare_wrapper,
     generate_set_del_item_wrapper,
+    generate_str_wrapper,
 )
 from mypyc.common import BITMAP_BITS, BITMAP_TYPE, NATIVE_PREFIX, PREFIX, REG_PREFIX
 from mypyc.ir.class_ir import ClassIR, VTableEntries
@@ -44,8 +45,8 @@ def wrapper_slot(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
 SLOT_DEFS: SlotTable = {
     "__init__": ("tp_init", lambda c, t, e: generate_init_for_class(c, t, e)),
     "__call__": ("tp_call", lambda c, t, e: generate_call_wrapper(c, t, e)),
-    "__str__": ("tp_str", native_slot),
-    "__repr__": ("tp_repr", native_slot),
+    "__str__": ("tp_str", generate_str_wrapper),
+    "__repr__": ("tp_repr", generate_str_wrapper),
     "__next__": ("tp_iternext", native_slot),
     "__iter__": ("tp_iter", native_slot),
     "__hash__": ("tp_hash", generate_hash_wrapper),

mypyc/codegen/emitwrapper.py

@@ -554,6 +554,20 @@ def generate_get_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
     return name
 
 
+def generate_str_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
+    """Generates a wrapper for native __str__ and __repr__ methods."""
+    name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"
+    emitter.emit_line(f"static PyObject* {name}(PyObject *self) {{")
+    unbox_value_if_required("self", "obj_self", fn.args[0].type, emitter)
+    emitter.emit_line(
+        "return {}{}{}(obj_self);".format(
+            emitter.get_group_prefix(fn.decl), NATIVE_PREFIX, fn.cname(emitter.names)
+        )
+    )
+    emitter.emit_line("}")
+    return name
+
+
 def generate_hash_wrapper(cl: ClassIR, fn: FuncIR, emitter: Emitter) -> str:
     """Generates a wrapper for native __hash__ methods."""
     name = f"{DUNDER_PREFIX}{fn.name}{cl.name_prefix(emitter.names)}"

mypyc/ir/class_ir.py

@@ -300,9 +300,6 @@ def struct_name(self, names: NameGenerator) -> str:
     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/irbuild/prepare.py

@@ -79,6 +79,8 @@ def build_type_map(
         module_classes = [node for node in module.defs if isinstance(node, ClassDef)]
         classes.extend([(module, cdef) for cdef in module_classes])
 
+    module_by_fullname = {module.fullname: module for module in modules}
+
     # Collect all class mappings so that we can bind arbitrary class name
     # references even if there are import cycles.
     for module, cdef in classes:
@@ -92,9 +94,8 @@ def build_type_map(
             is_value_type=is_value_type(cdef),
         )
 
-        if class_ir.is_value_type and (not is_immutable(cdef) or not cdef.info.is_final):
-            # Because the value type have semantic differences we can not just ignore it
-            errors.error("Value types must be immutable and final", module.path, cdef.line)
+        if class_ir.is_value_type:
+            check_value_type(cdef, errors, module_by_fullname)
 
         if class_ir.is_ext_class:
             class_ir.deletable = cdef.info.deletable_attributes.copy()
@@ -144,6 +145,33 @@ def build_type_map(
                         )
 
 
+def check_value_type(
+    cdef: ClassDef, errors: Errors, module_by_fullname: dict[str, MypyFile]
+) -> None:
+    if not is_immutable(cdef) or not cdef.info.is_final:
+        module = module_by_fullname.get(cdef.info.module_name)
+        # Because the value type have semantic differences we can not just ignore it
+        errors.error("Value types must be immutable and final", module.path, cdef.line)
+
+    for mtd_name in (
+        "__iter__",
+        "__next__",
+        "__enter__",
+        "__exit__",
+        "__getitem__",
+        "__setitem__",
+        "__delitem__",
+    ):
+        mtd = cdef.info.get_method(mtd_name)
+        if mtd is not None:
+            module = module_by_fullname.get(mtd.info.module_name)
+            errors.error(
+                f"Value types must not define method '{mtd_name}'",
+                module.path if module else "",
+                mtd.line,
+            )
+
+
 def is_from_module(node: SymbolNode, module: MypyFile) -> bool:
     return node.fullname == module.fullname + "." + node.name
 

mypyc/test-data/run-valuetype.test

@@ -237,6 +237,15 @@ class A:
     def __contains__(self, item: object) -> bool:
         return isinstance(item, i32) and item == self.x
 
+    def __bool__(self) -> bool:
+        return self.x != 0
+
+    def __str__(self) -> str:
+        return f"A({self.x})"
+
+    def __repr__(self) -> str:
+        return f"A({self.x})"
+
 def test_value_type_in_key() -> None:
     a = A(1, 2)
     d = {a: 1}
@@ -246,10 +255,34 @@ def test_value_type_in_val() -> None:
     a = A(1, 2)
     d = {1: a}
     assert d[1].x == 1
+    assert d[1] == A(1, 2)
+
+def test_value_type_in_set() -> None:
+    a = A(1, 2)
+    s = {a}
+    assert A(1, 2) in s
+
+def test_hash() -> None:
+    a = A(1, 2)
+    assert hash(a) == hash(1)
+
+def test_eq() -> None:
+    assert A(1, 2) == A(1, 2)
+    assert A(1, 2) != A(2, 3)
+    assert A(1, 2) != 1
+    assert 1 != A(1, 2)
+
+def test_bool() -> None:
+    assert bool(A(1, 2))
+    assert not bool(A(0, 2))
 
 def test_len() -> None:
     assert len(A(1, 2)) == 1
 
+def test_str() -> None:
+    assert str(A(1, 2)) == "A(1)"
+    assert repr(A(1, 2)) == "A(1)"
+
 def test_cmp() -> None:
     a = A(1, 2)
     b = A(2, 3)
@@ -263,3 +296,24 @@ def test_cmp() -> None:
     assert not b <= a
     assert 1 in a
     assert 2 not in a
+
+[case testValueTypeLifetime]
+from typing import final, Final, NamedTuple
+from mypy_extensions import mypyc_attr
+
+class A(NamedTuple):
+    n: str
+
+@final
+@mypyc_attr(value_type=True)
+class B:
+    def __init__(self, a: A) -> None:
+        self.a: Final = a
+
+def f() -> B:
+    # A instance is created in the function scope
+    # should be keep alive after the function returns
+    return B(A(n="test"))
+
+def test_value_type_lifetime() -> None:
+    assert f().a.n == "test"