fix(mypyc): preserve inherited class attribute defaults under separate=True

Under separate=True, find_attr_initializers walked the full MRO and pulled
default-value AssignmentStmt nodes out of info.defn.defs.body. After mypy
loads a base class from its incremental cache, that body is always empty
(ClassDef.serialize deliberately doesn't serialize defs). When the
subclass got recompiled but the parent stayed cache-loaded, the
subclass's emitted __mypyc_defaults_setup silently dropped every
inherited initialization. Any access to an inherited attribute through
compiled code then raised "AttributeError: attribute X of <base>
undefined".

This fix changes the strategy under separate=True only: each class's
__mypyc_defaults_setup now sets just that class's own defaults, then
calls the nearest ancestor's __mypyc_defaults_setup to fold in inherited
ones (same shape as Python's __init__ chain). The chain is robust to
cache-loaded bases because it doesn't need their AST -- only that the
ancestor has a method_decl entry for __mypyc_defaults_setup, which the
cached ClassIR retains.

Without separate=True the original inline-everything path is preserved
as an optimization (the AST is always in memory, so the MRO walk is
safe and the chain call would be needless runtime overhead).

Added testIncrementalCrossModuleInheritedAttrDefaultsWithOverride to
run-multimodule.test which exercises the fix end-to-end under both
TestRunSeparate and TestRunMultiFile. It fails on master and passes
with the fix.

Author: georgesittas

mypyc/irbuild/classdef.py

@@ -7,6 +7,7 @@
 from typing import Final
 
 from mypy.nodes import (
+    ARG_POS,
     EXCLUDED_ENUM_ATTRIBUTES,
     TYPE_VAR_TUPLE_KIND,
     AssignmentStmt,
@@ -745,6 +746,20 @@ def find_attr_initializers(
 ) -> tuple[set[str], list[tuple[AssignmentStmt, str]]]:
     """Find initializers of attributes in a class body.
 
+    Under separate compilation, only this class's own body is walked, and
+    generate_attr_defaults_init emits a runtime call to the parent's
+    __mypyc_defaults_setup so inherited defaults are produced by chaining,
+    not by inlining. Walking the MRO here would break under separate=True
+    with mypy's incremental cache: a base class loaded from the cache has
+    an empty ClassDef.defs.body (mypy/nodes.py::ClassDef.serialize doesn't
+    serialize the class body), so inherited assignments would be silently
+    dropped and the subclass's __mypyc_defaults_setup would leave inherited
+    slots in the "undefined" state at runtime.
+
+    Without separate compilation, all modules are parsed in the same pass
+    and the MRO walk is safe; we keep the original inline-all behavior
+    there as an optimization (no chain call needed for instance creation).
+
     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.
@@ -758,7 +773,12 @@ def find_attr_initializers(
     # Pull out all assignments in classes in the mro so we can initialize them
     # TODO: Support nested statements
     default_assignments: list[tuple[AssignmentStmt, str]] = []
-    for info in reversed(cdef.info.mro):
+    if builder.options.separate:
+        infos: list[TypeInfo] = [cdef.info]
+    else:
+        infos = list(reversed(cdef.info.mro))
+
+    for info in infos:
         if info not in builder.mapper.type_to_ir:
             continue
         for stmt in info.defn.defs.body:
@@ -800,15 +820,39 @@ def find_attr_initializers(
 def generate_attr_defaults_init(
     builder: IRBuilder, cdef: ClassDef, default_assignments: list[tuple[AssignmentStmt, str]]
 ) -> None:
-    """Generate an initialization method for default attr values (from class vars)."""
-    if not default_assignments:
-        return
+    """Generate an initialization method for default attr values (from class vars).
+
+    Under separate compilation, the emitted __mypyc_defaults_setup chains to
+    the nearest ancestor that has the method (Python __init__ style), then
+    sets only this class's own defaults; inherited defaults are produced by
+    the chain at runtime. Without separate compilation, find_attr_initializers
+    has already collected the full MRO's defaults into default_assignments,
+    so we inline them all as before.
+    """
     cls = builder.mapper.type_to_ir[cdef.info]
     if cls.builtin_base:
         return
 
+    parent_with_defaults: ClassIR | None = None
+    if builder.options.separate:
+        for ancestor in cls.mro[1:]:
+            if "__mypyc_defaults_setup" in ancestor.method_decls:
+                parent_with_defaults = ancestor
+                break
+
+    if not default_assignments and parent_with_defaults is None:
+        return
+
     with builder.enter_method(cls, "__mypyc_defaults_setup", bool_rprimitive):
         self_var = builder.self()
+
+        # Chain to the parent's __mypyc_defaults_setup first, so inherited
+        # defaults are set before we overwrite any of them with this class's
+        # overrides below.
+        if parent_with_defaults is not None:
+            decl = parent_with_defaults.method_decl("__mypyc_defaults_setup")
+            builder.builder.call(decl, [self_var], [ARG_POS], [None], cdef.line)
+
         for stmt, origin_module in default_assignments:
             lvalue = stmt.lvalues[0]
             assert isinstance(lvalue, NameExpr), lvalue

mypyc/test-data/run-multimodule.test

@@ -1680,3 +1680,56 @@ def _force_recompile() -> int:
 [file driver.py]
 from native import test
 test()
+
+[case testIncrementalCrossModuleInheritedAttrDefaultsWithOverride]
+# Regression: same shape as testIncrementalCrossModuleInheritedAttrDefaults,
+# but the subclass adds an attribute of its own, so generate_attr_defaults_init
+# emits a __mypyc_defaults_setup for it. Before the fix, the recompiled
+# subclass walked the parent's ClassDef.defs.body to collect inherited
+# defaults; when the parent was loaded from mypy's incremental cache that
+# body was empty, so the inherited initialization was dropped and any
+# access to an inherited attribute through compiled code raised
+# "AttributeError: attribute '<name>' of '<base>' undefined".
+import other_a
+
+def test() -> None:
+    c = other_a.Child()
+    # Inherited attributes must still be initialized after the subclass
+    # has been recompiled against a cache-loaded parent.
+    assert c.x == 1
+    assert c.y == "hello"
+    # Own override is set by the subclass's own __mypyc_defaults_setup.
+    assert c.z is True
+    # Method defined on the parent reads an inherited attribute through
+    # the compiled path; this is what crashes pre-fix.
+    assert c.use() == 1
+
+[file other_b.py]
+class Parent:
+    x: int = 1
+    y: str = "hello"
+    z: bool = False
+
+    def use(self) -> int:
+        if self.x:
+            return 1
+        return 0
+
+[file other_a.py]
+from other_b import Parent
+
+class Child(Parent):
+    z: bool = True
+
+[file other_a.py.2]
+from other_b import Parent
+
+class Child(Parent):
+    z: bool = True
+
+def _force_recompile() -> int:
+    return 1
+
+[file driver.py]
+from native import test
+test()