Emit [mutable-override] for covariant override of union with method

Author: brianschubert

mypy/checker.py

@@ -2146,13 +2146,15 @@ def check_method_override_for_base_with_name(
                     override_class_or_static,
                     context,
                 )
+                # Check if this override is covariant.
                 if (
                     ok
                     and original_node
                     and codes.MUTABLE_OVERRIDE in self.options.enabled_error_codes
                     and self.is_writable_attribute(original_node)
                     and not is_subtype(original_type, typ, ignore_pos_arg_names=True)
                 ):
+                    # Covariant override of mutable attribute.
                     base_str, override_str = format_type_distinctly(
                         original_type, typ, options=self.options
                     )
@@ -2162,10 +2164,24 @@ def check_method_override_for_base_with_name(
                     )
                     self.fail(msg, context)
             elif isinstance(original_type, UnionType) and any(
-                is_subtype(orig_typ, typ, ignore_pos_arg_names=True)
+                is_subtype(typ, orig_typ, ignore_pos_arg_names=True)
                 for orig_typ in original_type.items
             ):
-                pass
+                # This method is a subtype of at least one union variant.
+                if (
+                    original_node
+                    and codes.MUTABLE_OVERRIDE in self.options.enabled_error_codes
+                    and self.is_writable_attribute(original_node)
+                ):
+                    # Covariant override of mutable attribute.
+                    base_str, override_str = format_type_distinctly(
+                        original_type, typ, options=self.options
+                    )
+                    msg = message_registry.COVARIANT_OVERRIDE_OF_MUTABLE_ATTRIBUTE.with_additional_msg(
+                        f' (base class "{base.name}" defined the type as {base_str},'
+                        f" override has type {override_str})"
+                    )
+                    self.fail(msg, context)
             elif is_equivalent(original_type, typ):
                 # Assume invariance for a non-callable attribute here. Note
                 # that this doesn't affect read-only properties which can have

test-data/unit/check-classes.test

@@ -779,21 +779,51 @@ class B(A):
 [case testOverrideCallableUnionAttributeWithMethod]
 from typing import Callable, Union
 
-class Base:
+class A:
     f1: Union[Callable[[str], str], str]
     f2: Union[Callable[[str], str], str]
     f3: Union[Callable[[str], str], str]
+    f4: Union[Callable[[str], str], str]
 
-class Derived(Base):
+class B(A):
     def f1(self, x: str) -> str:
         pass
 
+    def f2(self, x: object) -> str:
+        pass
+
+    @classmethod
+    def f3(cls, x: str) -> str:
+        pass
+
+    @staticmethod
+    def f4(x: str) -> str:
+        pass
+[builtins fixtures/classmethod.pyi]
+
+[case testOverrideCallableUnionAttributeWithMethodMutableOverride]
+# flags: --enable-error-code=mutable-override
+from typing import Callable, Union
+
+class A:
+    f1: Union[Callable[[str], str], str]
+    f2: Union[Callable[[str], str], str]
+    f3: Union[Callable[[str], str], str]
+    f4: Union[Callable[[str], str], str]
+
+class B(A):
+    def f1(self, x: str) -> str:     # E: Covariant override of a mutable attribute (base class "A" defined the type as "Union[Callable[[str], str], str]", override has type "Callable[[str], str]")
+        pass
+
+    def f2(self, x: object) -> str:  # E: Covariant override of a mutable attribute (base class "A" defined the type as "Union[Callable[[str], str], str]", override has type "Callable[[object], str]")
+        pass
+
     @classmethod
-    def f2(cls, x: str) -> str:
+    def f3(cls, x: str) -> str:      # E: Covariant override of a mutable attribute (base class "A" defined the type as "Union[Callable[[str], str], str]", override has type "Callable[[str], str]")
         pass
 
     @staticmethod
-    def f3(x: str) -> str:
+    def f4(x: str) -> str:           # E: Covariant override of a mutable attribute (base class "A" defined the type as "Union[Callable[[str], str], str]", override has type "Callable[[str], str]")
         pass
 [builtins fixtures/classmethod.pyi]