[mypyc] Support inheriting native int attributes from traits (#14490)

Regular trait attributes are accessed via looking up the field offset
from a vtable. This doesn't work with native ints, since they may also
require access to a defined attributes bitmap, and also looking that up
from a vtable would be too complicated.

Work around this may always accessing trait native int attributes using
accessor methods. These can raise an exception if an attribute is
undefined.

Add empty accessor methods in traits for each attribute with overlapping
error values. Also synthesize real accessors in each concrete subclass.

When accessing the attribute using a concrete subclass, still prefer
direct field and bitmap access. Only attribute access through a trait
type requires accessors to be used.

Work on mypyc/mypyc#837.

Author: JukkaL

mypyc/analysis/attrdefined.py

@@ -415,6 +415,9 @@ def update_always_defined_attrs_using_subclasses(cl: ClassIR, seen: set[ClassIR]
 
 
 def detect_undefined_bitmap(cl: ClassIR, seen: Set[ClassIR]) -> None:
+    if cl.is_trait:
+        return
+
     if cl in seen:
         return
     seen.add(cl)
@@ -426,3 +429,9 @@ def detect_undefined_bitmap(cl: ClassIR, seen: Set[ClassIR]) -> None:
     for n, t in cl.attributes.items():
         if t.error_overlap and not cl.is_always_defined(n):
             cl.bitmap_attrs.append(n)
+
+    for base in cl.mro[1:]:
+        if base.is_trait:
+            for n, t in base.attributes.items():
+                if t.error_overlap and not cl.is_always_defined(n) and n not in cl.bitmap_attrs:
+                    cl.bitmap_attrs.append(n)

mypyc/codegen/emitfunc.py

@@ -330,7 +330,8 @@ def visit_get_attr(self, op: GetAttr) -> None:
         rtype = op.class_type
         cl = rtype.class_ir
         attr_rtype, decl_cl = cl.attr_details(op.attr)
-        if cl.get_method(op.attr):
+        prefer_method = cl.is_trait and attr_rtype.error_overlap
+        if cl.get_method(op.attr, prefer_method=prefer_method):
             # Properties are essentially methods, so use vtable access for them.
             version = "_TRAIT" if cl.is_trait else ""
             self.emit_line(

mypyc/ir/class_ir.py

@@ -294,10 +294,13 @@ def get_method_and_class(
 
         return None
 
-    def get_method(self, name: str) -> FuncIR | None:
-        res = self.get_method_and_class(name)
+    def get_method(self, name: str, *, prefer_method: bool = False) -> FuncIR | None:
+        res = self.get_method_and_class(name, prefer_method=prefer_method)
         return res[0] if res else None
 
+    def has_method_decl(self, name: str) -> bool:
+        return any(name in ir.method_decls for ir in self.mro)
+
     def subclasses(self) -> set[ClassIR] | None:
         """Return all subclasses of this class, both direct and indirect.
 

mypyc/irbuild/classdef.py

@@ -161,14 +161,16 @@ def transform_class_def(builder: IRBuilder, cdef: ClassDef) -> None:
     # 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)
+            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)
+                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
 

mypyc/irbuild/function.py

@@ -1028,21 +1028,28 @@ def get_native_impl_ids(builder: IRBuilder, singledispatch_func: FuncDef) -> dic
     return {impl: i for i, (typ, impl) in enumerate(impls) if not is_decorated(builder, impl)}
 
 
-def gen_property_getter_ir(builder: IRBuilder, func_decl: FuncDecl, cdef: ClassDef) -> FuncIR:
+def gen_property_getter_ir(
+    builder: IRBuilder, func_decl: FuncDecl, cdef: ClassDef, is_trait: bool
+) -> FuncIR:
     """Generate an implicit trivial property getter for an attribute.
 
     These are used if an attribute can also be accessed as a property.
     """
     name = func_decl.name
     builder.enter(name)
     self_reg = builder.add_argument("self", func_decl.sig.args[0].type)
-    value = builder.builder.get_attr(self_reg, name, func_decl.sig.ret_type, -1)
-    builder.add(Return(value))
+    if not is_trait:
+        value = builder.builder.get_attr(self_reg, name, func_decl.sig.ret_type, -1)
+        builder.add(Return(value))
+    else:
+        builder.add(Unreachable())
     args, _, blocks, ret_type, fn_info = builder.leave()
     return FuncIR(func_decl, args, blocks)
 
 
-def gen_property_setter_ir(builder: IRBuilder, func_decl: FuncDecl, cdef: ClassDef) -> FuncIR:
+def gen_property_setter_ir(
+    builder: IRBuilder, func_decl: FuncDecl, cdef: ClassDef, is_trait: bool
+) -> FuncIR:
     """Generate an implicit trivial property setter for an attribute.
 
     These are used if an attribute can also be accessed as a property.
@@ -1053,7 +1060,8 @@ def gen_property_setter_ir(builder: IRBuilder, func_decl: FuncDecl, cdef: ClassD
     value_reg = builder.add_argument("value", func_decl.sig.args[1].type)
     assert name.startswith(PROPSET_PREFIX)
     attr_name = name[len(PROPSET_PREFIX) :]
-    builder.add(SetAttr(self_reg, attr_name, value_reg, -1))
+    if not is_trait:
+        builder.add(SetAttr(self_reg, attr_name, value_reg, -1))
     builder.add(Return(builder.none()))
     args, _, blocks, ret_type, fn_info = builder.leave()
     return FuncIR(func_decl, args, blocks)

mypyc/irbuild/prepare.py

@@ -305,7 +305,15 @@ def prepare_methods_and_attributes(
         if isinstance(node.node, Var):
             assert node.node.type, "Class member %s missing type" % name
             if not node.node.is_classvar and name not in ("__slots__", "__deletable__"):
-                ir.attributes[name] = mapper.type_to_rtype(node.node.type)
+                attr_rtype = mapper.type_to_rtype(node.node.type)
+                if ir.is_trait and attr_rtype.error_overlap:
+                    # Traits don't have attribute definedness bitmaps, so use
+                    # property accessor methods to access attributes that need them.
+                    # We will generate accessor implementations that use the class bitmap
+                    # for any concrete subclasses.
+                    add_getter_declaration(ir, name, attr_rtype, module_name)
+                    add_setter_declaration(ir, name, attr_rtype, module_name)
+                ir.attributes[name] = attr_rtype
         elif isinstance(node.node, (FuncDef, Decorator)):
             prepare_method_def(ir, module_name, cdef, mapper, node.node)
         elif isinstance(node.node, OverloadedFuncDef):
@@ -329,11 +337,20 @@ def prepare_methods_and_attributes(
 def prepare_implicit_property_accessors(
     info: TypeInfo, ir: ClassIR, module_name: str, mapper: Mapper
 ) -> None:
+    concrete_attributes = set()
     for base in ir.base_mro:
         for name, attr_rtype in base.attributes.items():
+            concrete_attributes.add(name)
             add_property_methods_for_attribute_if_needed(
                 info, ir, name, attr_rtype, module_name, mapper
             )
+    for base in ir.mro[1:]:
+        if base.is_trait:
+            for name, attr_rtype in base.attributes.items():
+                if name not in concrete_attributes:
+                    add_property_methods_for_attribute_if_needed(
+                        info, ir, name, attr_rtype, module_name, mapper
+                    )
 
 
 def add_property_methods_for_attribute_if_needed(
@@ -350,6 +367,7 @@ def add_property_methods_for_attribute_if_needed(
     """
     for base in info.mro[1:]:
         if base in mapper.type_to_ir:
+            base_ir = mapper.type_to_ir[base]
             n = base.names.get(attr_name)
             if n is None:
                 continue
@@ -361,6 +379,9 @@ def add_property_methods_for_attribute_if_needed(
                 # Defined as a read-write property in base class/trait
                 add_getter_declaration(ir, attr_name, attr_rtype, module_name)
                 add_setter_declaration(ir, attr_name, attr_rtype, module_name)
+            elif base_ir.is_trait and attr_rtype.error_overlap:
+                add_getter_declaration(ir, attr_name, attr_rtype, module_name)
+                add_setter_declaration(ir, attr_name, attr_rtype, module_name)
 
 
 def add_getter_declaration(

mypyc/irbuild/vtable.py

@@ -40,7 +40,7 @@ def compute_vtable(cls: ClassIR) -> None:
     for t in [cls] + cls.traits:
         for fn in itertools.chain(t.methods.values()):
             # TODO: don't generate a new entry when we overload without changing the type
-            if fn == cls.get_method(fn.name):
+            if fn == cls.get_method(fn.name, prefer_method=True):
                 cls.vtable[fn.name] = len(entries)
                 # If the class contains a glue method referring to itself, that is a
                 # shadow glue method to support interpreted subclasses.
@@ -60,7 +60,7 @@ def specialize_parent_vtable(cls: ClassIR, parent: ClassIR) -> VTableEntries:
     for entry in parent.vtable_entries:
         # Find the original method corresponding to this vtable entry.
         # (This may not be the method in the entry, if it was overridden.)
-        orig_parent_method = entry.cls.get_method(entry.name)
+        orig_parent_method = entry.cls.get_method(entry.name, prefer_method=True)
         assert orig_parent_method
         method_cls = cls.get_method_and_class(entry.name, prefer_method=True)
         if method_cls:

mypyc/test-data/run-i64.test

@@ -1433,3 +1433,65 @@ def test_read_only_property_in_trait_implemented_as_property() -> None:
     assert t.x == 6
     with assertRaises(TypeError):
         t.y
+
+@trait
+class T2:
+    x: i64
+    y: i64
+
+class C2(T2):
+    pass
+
+def test_inherit_trait_attribute() -> None:
+    c = C2()
+    c.x = 5
+    assert c.x == 5
+    c.x = MAGIC
+    assert c.x == MAGIC
+    with assertRaises(AttributeError):
+        c.y
+    c.y = 6
+    assert c.y == 6
+    t: T2 = C2()
+    with assertRaises(AttributeError):
+        t.y
+    t = c
+    assert t.x == MAGIC
+    c.x = 55
+    assert t.x == 55
+    assert t.y == 6
+    a: Any = c
+    assert a.x == 55
+    assert a.y == 6
+    a.x = 7
+    a.y = 8
+    assert a.x == 7
+    assert a.y == 8
+
+class D2(T2):
+    x: i64
+    y: i64 = 4
+
+def test_implement_trait_attribute() -> None:
+    d = D2()
+    d.x = 5
+    assert d.x == 5
+    d.x = MAGIC
+    assert d.x == MAGIC
+    assert d.y == 4
+    d.y = 6
+    assert d.y == 6
+    t: T2 = D2()
+    assert t.y == 4
+    t = d
+    assert t.x == MAGIC
+    d.x = 55
+    assert t.x == 55
+    assert t.y == 6
+    a: Any = d
+    assert a.x == 55
+    assert a.y == 6
+    a.x = 7
+    a.y = 8
+    assert a.x == 7
+    assert a.y == 8