Don't flag synthesized __replace__ as incompatible across unrelated bases

Fixes #21635.

On Python 3.13+, @DataClass synthesizes a __replace__(self, ...) -> Self
method to support copy.replace(). When mypy builds an ad-hoc intersection
type to narrow an expression via issubclass()/isinstance() against two
unrelated dataclasses, check_multiple_inheritance sees each dataclass's
synthesized __replace__ returning its own concrete type (e.g. A vs M) and
flags them as incompatible, causing intersect_instances to fail and the
narrowed type to collapse to Never -- even when a real subclass of both
(itself decorated with @DataClass, and so getting its own compatible
synthesized __replace__) already exists in the code.

This exempts __replace__ from the cross-base compatibility check the same
way __init__/__new__/__init_subclass__ already are, but only when the
method was generated by a plugin (plugin_generated=True) on both sides --
hand-written __replace__ overrides with genuine incompatibilities are
still caught.

Author: ygale

mypy/checker.py

@@ -3138,6 +3138,16 @@ class C(B, A[int]): ...  # this is unsafe because...
             return
         first = base1.names[name]
         second = base2.names[name]
+        if name == "__replace__" and first.plugin_generated and second.plugin_generated:
+            # Plugin-synthesized __replace__ methods (e.g. those added by the
+            # @dataclass plugin on Python 3.13+ to support copy.replace())
+            # return Self and are regenerated fresh for every concrete
+            # subclass, so they can safely differ across unrelated bases --
+            # same reasoning as __init__ and friends above. We only skip this
+            # for methods a plugin generated, not ones the user wrote by
+            # hand, so real incompatible __replace__ overrides are still
+            # caught.
+            return
         # Specify current_class explicitly as this function is called after leaving the class.
         first_type, _ = self.node_type_from_base(name, base1, ctx, current_class=ctx)
         second_type, _ = self.node_type_from_base(name, base2, ctx, current_class=ctx)

test-data/unit/check-dataclasses.test

@@ -2609,6 +2609,40 @@ class Y(X):
 [builtins fixtures/tuple.pyi]
 
 
+[case testDunderReplaceDoesNotBlockAdHocIntersectionNarrowing]
+# https://github.com/python/mypy/issues/21635
+# flags: --python-version 3.13
+from dataclasses import dataclass
+
+@dataclass
+class A: ...
+@dataclass
+class M: ...
+@dataclass
+class B(A): ...
+@dataclass
+class C(M, A): ...
+
+alist: list[type[A]] = [B, C]
+mlist: list[type[M]] = [cls for cls in alist if issubclass(cls, M)]
+reveal_type(mlist)  # N: Revealed type is "builtins.list[type[__main__.M]]"
+[builtins fixtures/isinstancelist.pyi]
+
+[case testDunderReplaceHandwrittenStillCheckedForCompatibility]
+# flags: --python-version 3.13
+class A:
+    def __replace__(self) -> "A":
+        return A()
+
+class M:
+    def __replace__(self) -> "M":
+        return M()
+
+class C(M, A):  # E: Definition of "__replace__" in base class "M" is incompatible with definition in base class "A"
+    pass
+[builtins fixtures/tuple.pyi]
+
+
 [case testFrozenWithFinal]
 from dataclasses import dataclass
 from typing import Final