Fix regression in dataclass narrowing for Python >= 3.13 (#21675)

Fixes #21635

On Python >= 3.13, `@dataclass` synthesizes a `__replace__(self, ...) ->
Self`
method to support `copy.replace()`. When mypy tries to narrow a
`type[A]`
expression via `issubclass(cls, M)` (or `isinstance`) against a second,
unrelated dataclass `M`, it builds an ad-hoc `<subclass of A and M>`
type to
check whether that narrowing is sound (`intersect_instances` in
`checker.py`). Building that ad-hoc type runs
`check_multiple_inheritance`,
which sees `A`'s synthesized `__replace__` returning `A` and `M`'s
returning `M`, and flags them as incompatible.

That's a false positive: a real subclass of both (e.g. `class C(M, A)`,
itself decorated with `@dataclass`) gets its *own* freshly synthesized,
mutually compatible `__replace__`.

Author: ygale

mypy/checker.py

@@ -3133,7 +3133,7 @@ class C(B, A[int]): ...  # this is unsafe because...
             x: A[int] = C()
             x.foo  # ...runtime type is (str) -> None, while static type is (int) -> None
         """
-        if name in ("__init__", "__new__", "__init_subclass__"):
+        if name in {"__init__", "__new__", "__init_subclass__", "__replace__"}:
             # __init__ and friends can be incompatible -- it's a special case.
             return
         first = base1.names[name]

test-data/unit/check-dataclasses.test

@@ -2609,6 +2609,27 @@ class Y(X):
 [builtins fixtures/tuple.pyi]
 
 
+[case testDunderReplaceDoesNotBlockPlainIssubclassNarrowing]
+# 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): ...
+
+cls: type[A] = C
+if issubclass(cls, M):
+    reveal_type(cls)  # N: Revealed type is "type[__main__.<subclass of "__main__.A" and "__main__.M">]"
+    n: int = 'foo'  # E: Incompatible types in assignment (expression has type "str", variable has type "int")
+[builtins fixtures/isinstancelist.pyi]
+
+
 [case testFrozenWithFinal]
 from dataclasses import dataclass
 from typing import Final