Some more fixes

Author: ilevkivskyi

mypy/checker.py

@@ -6,8 +6,8 @@
 from collections import defaultdict
 from collections.abc import Iterable, Iterator, Mapping, Sequence, Set as AbstractSet
 from contextlib import ExitStack, contextmanager
-from typing import Callable, Final, Generic, NamedTuple, Optional, TypeVar, Union, cast, overload, TypeGuard
-from typing_extensions import TypeAlias as _TypeAlias
+from typing import Callable, Final, Generic, NamedTuple, Optional, TypeVar, Union, cast, overload
+from typing_extensions import TypeAlias as _TypeAlias, TypeGuard
 
 import mypy.checkexpr
 from mypy import errorcodes as codes, join, message_registry, nodes, operators
@@ -648,8 +648,10 @@ def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
             assert isinstance(defn.items[0], Decorator)
             self.visit_decorator(defn.items[0])
             assert isinstance(defn.items[1], Decorator)
-            self.visit_decorator(defn.items[1])
-            defn.items[0].var.setter_type = defn.items[1].func.type
+            self.visit_func_def(defn.items[1].func)
+            setter_type = self.function_type(defn.items[1].func)
+            assert isinstance(setter_type, CallableType)
+            defn.items[0].var.setter_type = setter_type
         for fdef in defn.items:
             assert isinstance(fdef, Decorator)
             if defn.is_property:
@@ -2057,39 +2059,18 @@ def check_setter_type_override(
                 base_node, expanded_type, fill_typevars(defn.info)
             ))
         else:
+            assert isinstance(original_type, CallableType)
             original_type = self.bind_and_map_method(base_attr, original_type, defn.info, base)
-        original_type = get_setter_type(original_type)
+            assert isinstance(original_type, CallableType)
+            original_type = get_proper_type(original_type.arg_types[0])
 
         typ = get_raw_setter_type(defn)
         assert isinstance(typ, CallableType)
         typ = bind_self(typ, self.scope.active_self_type())
-        typ = get_setter_type(typ)
+        typ = get_proper_type(typ.arg_types[0])
 
         if not is_subtype(original_type, typ):
-            self.fail(
-                "Incompatible override of a setter type",
-                defn,
-                code=codes.OVERRIDE,
-            )
-            base_str, override_str = format_type_distinctly(
-                original_type, typ, options=self.options
-            )
-            self.note(
-                f' (base class "{base.name}" defined the type as {base_str},',
-                defn,
-                code = codes.OVERRIDE,
-            )
-            self.note(
-                f" override has type {override_str})",
-                defn,
-                code=codes.OVERRIDE,
-            )
-            if is_subtype(typ, original_typ):
-                self.note(
-                    " Setter types should behave contravariantly",
-                    defn,
-                    code=codes.OVERRIDE,
-                )
+            self.msg.incompatible_setter_override(defn.items[1], typ, original_type, base)
 
     def check_method_override_for_base_with_name(
         self, defn: FuncDef | OverloadedFuncDef | Decorator, name: str, base: TypeInfo
@@ -2273,6 +2254,7 @@ def check_method_override_for_base_with_name(
             self.msg.signature_incompatible_with_supertype(
                 defn.name, name, base.name, context, original=original_type, override=typ
             )
+        return False
 
     def bind_and_map_method(
         self, sym: SymbolTableNode, typ: FunctionLike, sub_info: TypeInfo, super_info: TypeInfo
@@ -3427,32 +3409,15 @@ def check_compatibility_all_supers(
                         # base classes are also incompatible
                         return True
                     if lvalue_type and custom_setter:
-                        base_type, _ = self.lvalue_type_from_base(lvalue_node, base, setter_type=True)
+                        base_type, _ = self.lvalue_type_from_base(
+                            lvalue_node, base, setter_type=True
+                        )
+                        # Setter type must be ready if the getter type is ready.
+                        assert base_type is not None
                         if not is_subtype(base_type, lvalue_type):
-                            self.fail(
-                                "Incompatible override of a setter type",
-                                lvalue,
-                                code=codes.OVERRIDE,
+                            self.msg.incompatible_setter_override(
+                                lvalue, lvalue_type, base_type, base
                             )
-                            base_str, override_str = format_type_distinctly(
-                                base_type, lvalue_type, options=self.options
-                            )
-                            self.note(
-                                f' (base class "{base.name}" defined the type as {base_str},',
-                                lvalue,
-                                code=codes.OVERRIDE,
-                            )
-                            self.note(
-                                f" override has type {override_str})",
-                                lvalue,
-                                code=codes.OVERRIDE,
-                            )
-                            if is_subtype(lvalue_type, base_type):
-                                self.note(
-                                    " Setter types should behave contravariantly",
-                                    lvalue,
-                                    code=codes.OVERRIDE,
-                                )
                             return True
                     if base is last_immediate_base:
                         # At this point, the attribute was found to be compatible with all
@@ -3559,39 +3524,41 @@ def lvalue_type_from_base(
             base_node = base_node.func
             base_type = base_node.type
 
-        if base_type:
-            if not has_no_typevars(base_type):
-                self_type = self.scope.active_self_type()
-                assert self_type is not None, "Internal error: base lookup outside class"
-                if isinstance(self_type, TupleType):
-                    instance = tuple_fallback(self_type)
+        if not base_type:
+            return None, None
+        if not has_no_typevars(base_type):
+            self_type = self.scope.active_self_type()
+            assert self_type is not None, "Internal error: base lookup outside class"
+            if isinstance(self_type, TupleType):
+                instance = tuple_fallback(self_type)
+            else:
+                instance = self_type
+            itype = map_instance_to_supertype(instance, base)
+            base_type = expand_type_by_instance(base_type, itype)
+
+        base_type = get_proper_type(base_type)
+        if isinstance(base_type, CallableType) and isinstance(base_node, FuncDef):
+            # If we are a property, return the Type of the return
+            # value, not the Callable
+            if base_node.is_property:
+                base_type = get_proper_type(base_type.ret_type)
+        if isinstance(base_type, FunctionLike) and isinstance(
+            base_node, OverloadedFuncDef
+        ):
+            # Same for properties with setter
+            if base_node.is_property:
+                if setter_type:
+                    assert isinstance(base_node.items[0], Decorator)
+                    base_type = base_node.items[0].var.setter_type
+                    assert isinstance(base_type, CallableType)
+                    base_type = self.bind_and_map_method(
+                        base_var, base_type, expr_node.info, base
+                    )
+                    assert isinstance(base_type, CallableType)
+                    base_type = get_proper_type(base_type.arg_types[0])
                 else:
-                    instance = self_type
-                itype = map_instance_to_supertype(instance, base)
-                base_type = expand_type_by_instance(base_type, itype)
-
-            base_type = get_proper_type(base_type)
-            if isinstance(base_type, CallableType) and isinstance(base_node, FuncDef):
-                # If we are a property, return the Type of the return
-                # value, not the Callable
-                if base_node.is_property:
-                    base_type = get_proper_type(base_type.ret_type)
-            if isinstance(base_type, FunctionLike) and isinstance(
-                base_node, OverloadedFuncDef
-            ):
-                # Same for properties with setter
-                if base_node.is_property:
-                    if setter_type:
-                        assert isinstance(base_node.items[0], Decorator)
-                        base_type = base_node.items[0].var.setter_type
-                        assert isinstance(base_type, CallableType)
-                        base_type = self.bind_and_map_method(
-                            base_var, base_type, expr_node.info, base
-                        )
-                        base_type = get_setter_type(base_type)
-                    else:
-                        base_type = base_type.items[0].ret_type
-            return base_type, base_node
+                    base_type = base_type.items[0].ret_type
+        return base_type, base_node
 
     def check_compatibility_classvar_super(
         self, node: Var, base: TypeInfo, base_node: Node | None
@@ -8807,23 +8774,31 @@ def is_settable_property(defn: SymbolNode | None) -> TypeGuard[OverloadedFuncDef
     return False
 
 
-def is_custom_settable_property(defn: SymbolNode) -> bool:
+def is_custom_settable_property(defn: SymbolNode | None) -> bool:
+    if defn is None:
+        return False
     if not is_settable_property(defn):
         return False
     first_item = defn.items[0]
     assert isinstance(first_item, Decorator)
     if not first_item.var.is_settable_property:
         return False
     var = first_item.var
-    if var.setter_type is None:
+    if var.type is None or var.setter_type is None or isinstance(var.type, PartialType):
+        # The caller should defer in case of partial types or not ready variables.
+        return False
+    setter_type = var.setter_type.arg_types[1]
+    if isinstance(get_proper_type(setter_type), AnyType):
         return False
     return not is_same_type(
-        get_property_type(get_proper_type(var.type)), get_setter_type(var.setter_type)
+        get_property_type(get_proper_type(var.type)), setter_type
     )
 
 
 def get_raw_setter_type(defn: OverloadedFuncDef | Var) -> ProperType:
     if isinstance(defn, Var):
+        # This function should not be called if the var is not ready.
+        assert defn.type is not None
         return get_proper_type(defn.type)
     first_item = defn.items[0]
     assert isinstance(first_item, Decorator)
@@ -8832,13 +8807,6 @@ def get_raw_setter_type(defn: OverloadedFuncDef | Var) -> ProperType:
     return var.setter_type
 
 
-def get_setter_type(t: ProperType) -> ProperType:
-    # TODO: handle deferrals.
-    if isinstance(t, CallableType):
-        return get_proper_type(t.arg_types[0])
-    return t
-
-
 def get_property_type(t: ProperType) -> ProperType:
     if isinstance(t, CallableType):
         return get_proper_type(t.ret_type)

mypy/checkmember.py

@@ -777,7 +777,7 @@ def analyze_var(
     original_itype = itype
     itype = map_instance_to_supertype(itype, var.info)
     if var.is_settable_property and mx.is_lvalue:
-        typ = var.setter_type
+        typ: Type | None = var.setter_type
         if typ is None and var.is_ready:
             # Existing synthetic properties may not set setter type. Fall back to getter.
             typ = var.type

mypy/messages.py

@@ -1165,6 +1165,34 @@ def overload_signature_incompatible_with_supertype(
         note_template = 'Overload variants must be defined in the same order as they are in "{}"'
         self.note(note_template.format(supertype), context, code=codes.OVERRIDE)
 
+    def incompatible_setter_override(
+        self, defn: Context, typ: Type, original_type: Type, base: TypeInfo
+    ) -> None:
+        self.fail(
+            "Incompatible override of a setter type",
+            defn,
+            code=codes.OVERRIDE,
+        )
+        base_str, override_str = format_type_distinctly(
+            original_type, typ, options=self.options
+        )
+        self.note(
+            f' (base class "{base.name}" defined the type as {base_str},',
+            defn,
+            code=codes.OVERRIDE,
+        )
+        self.note(
+            f" override has type {override_str})",
+            defn,
+            code=codes.OVERRIDE,
+        )
+        if is_subtype(typ, original_type):
+            self.note(
+                " Setter types should behave contravariantly",
+                defn,
+                code=codes.OVERRIDE,
+            )
+
     def signature_incompatible_with_supertype(
         self,
         name: str,

mypy/nodes.py

@@ -1012,7 +1012,7 @@ def __init__(self, name: str, type: mypy.types.Type | None = None) -> None:
         # TODO: Should be Optional[TypeInfo]
         self.info = VAR_NO_INFO
         self.type: mypy.types.Type | None = type  # Declared or inferred type, or None
-        self.setter_type: mypy.types.ProperType | None = None
+        self.setter_type: mypy.types.CallableType | None = None
         # Is this the first argument to an ordinary method (usually "self")?
         self.is_self = False
         # Is this the first argument to a classmethod (typically "cls")?
@@ -1092,6 +1092,7 @@ def deserialize(cls, data: JsonDict) -> Var:
         type = None if data["type"] is None else mypy.types.deserialize_type(data["type"])
         setter_type = None if data["setter_type"] is None else mypy.types.deserialize_type(data["setter_type"])
         v = Var(name, type)
+        assert setter_type is None or isinstance(setter_type, mypy.types.ProperType) and isinstance(setter_type, mypy.types.CallableType)
         v.setter_type = setter_type
         v.is_ready = False  # Override True default set in __init__
         v._fullname = data["fullname"]

test-data/unit/check-classes.test

@@ -784,7 +784,7 @@ class A:
     f: Callable[[str], None]
 
 class B(A):
-    @property  # E: Covariant override of a mutable attribute (base class "A" defined the type as "Callable[[str], None]", override has type "Callable[[object], None]")
+    @property
     def f(self) -> Callable[[object], None]: pass
     @func.setter
     def f(self, x: object) -> None: pass
@@ -8087,7 +8087,10 @@ class B2:
 class C2(B2):
     @property
     def foo(self) -> str: ...
-    @foo.setter
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B2" defined the type as "B", \
+                 # N:  override has type "C") \
+                 # N:  Setter types should behave contravariantly
     def foo(self, x: C) -> None: ...
 
 class B3:
@@ -8109,7 +8112,10 @@ class B4:
 class C4(B4):
     @property
     def foo(self) -> C: ...
-    @foo.setter
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B4" defined the type as "B", \
+                 # N:  override has type "C") \
+                 # N:  Setter types should behave contravariantly
     def foo(self, x: C) -> None: ...
 
 class B5:
@@ -8118,10 +8124,16 @@ class B5:
     @foo.setter
     def foo(self, x: B) -> None: ...
 class C5(B5):
-    @property
+    @property  # E: Signature of "foo" incompatible with supertype "B5" \
+               # N:      Superclass: \
+               # N:          str \
+               # N:      Subclass: \
+               # N:          C
     def foo(self) -> C: ...
-    @foo.setter
-    def foo(self, x: C) -> None: ...
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B5" defined the type as "B", \
+                 # N:  override has type "str")
+    def foo(self, x: str) -> None: ...
 
 class B6:
     @property
@@ -8144,12 +8156,15 @@ class B1:
 class C1(B1):
     @property
     def foo(self) -> B: ...
-    @foo.setter
+    @foo.setter  # E: Incompatible override of a setter type \
+                 # N:  (base class "B1" defined the type as "B", \
+                 # N:  override has type "C") \
+                 # N:  Setter types should behave contravariantly
     def foo(self, x: C) -> None: ...
 
 class B2:
     foo: C
-class C2(2):
+class C2(B2):
     @property
     def foo(self) -> C: ...
     @foo.setter
@@ -8190,7 +8205,10 @@ class B3:
     @foo.setter
     def foo(self, x: B) -> None: ...
 class C3(B3):
-    foo: C
+    foo: C  # E: Incompatible override of a setter type \
+            # N:  (base class "B3" defined the type as "B", \
+            # N:  override has type "C") \
+            # N:  Setter types should behave contravariantly
 [builtins fixtures/property.pyi]
 
 [case testOverrideMethodProperty]