Address CR

Author: ilevkivskyi

mypy/checker.py

@@ -647,19 +647,20 @@ def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
             # HACK: Infer the type of the property.
             assert isinstance(defn.items[0], Decorator)
             self.visit_decorator(defn.items[0])
-            assert isinstance(defn.items[1], Decorator)
-            self.visit_func_def(defn.items[1].func)
-            setter_type = self.function_type(defn.items[1].func)
-            assert isinstance(setter_type, CallableType)
-            if len(setter_type.arg_types) != 2:
-                self.fail("Invalid property setter signature", defn.items[1].func)
-                any_type = AnyType(TypeOfAny.from_error)
-                setter_type = setter_type.copy_modified(
-                    arg_types=[any_type, any_type],
-                    arg_kinds=[ARG_POS, ARG_POS],
-                    arg_names=[None, None],
-                )
-            defn.items[0].var.setter_type = setter_type
+            if defn.items[0].var.is_settable_property:
+                assert isinstance(defn.items[1], Decorator)
+                self.visit_func_def(defn.items[1].func)
+                setter_type = self.function_type(defn.items[1].func)
+                assert isinstance(setter_type, CallableType)
+                if len(setter_type.arg_types) != 2:
+                    self.fail("Invalid property setter signature", defn.items[1].func)
+                    any_type = AnyType(TypeOfAny.from_error)
+                    setter_type = setter_type.copy_modified(
+                        arg_types=[any_type, any_type],
+                        arg_kinds=[ARG_POS, ARG_POS],
+                        arg_names=[None, None],
+                    )
+                defn.items[0].var.setter_type = setter_type
         for fdef in defn.items:
             assert isinstance(fdef, Decorator)
             if defn.is_property:

mypy/server/astdiff.py

@@ -245,6 +245,11 @@ def snapshot_definition(node: SymbolNode | None, common: SymbolSnapshot) -> Symb
             impl = node
         elif isinstance(node, OverloadedFuncDef) and node.impl:
             impl = node.impl.func if isinstance(node.impl, Decorator) else node.impl
+        setter_type = None
+        if isinstance(node, OverloadedFuncDef) and node.items:
+            first_item = node.items[0]
+            if isinstance(first_item, Decorator) and first_item.func.is_property:
+                setter_type = snapshot_optional_type(first_item.var.setter_type)
         is_trivial_body = impl.is_trivial_body if impl else False
         dataclass_transform_spec = find_dataclass_transform_spec(node)
         return (
@@ -258,6 +263,7 @@ def snapshot_definition(node: SymbolNode | None, common: SymbolSnapshot) -> Symb
             is_trivial_body,
             dataclass_transform_spec.serialize() if dataclass_transform_spec is not None else None,
             node.deprecated if isinstance(node, FuncDef) else None,
+            setter_type,  # multi-part properties are stored as OverloadedFuncDef
         )
     elif isinstance(node, Var):
         return ("Var", common, snapshot_optional_type(node.type), node.is_final)

test-data/unit/check-classes.test

@@ -8410,3 +8410,33 @@ reveal_type(a.f)  # N: Revealed type is "builtins.int"
 a.f = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "str")
 reveal_type(a.f)  # N: Revealed type is "builtins.int"
 [builtins fixtures/property.pyi]
+
+[case testPropertySetterTypeGeneric]
+from typing import TypeVar, Generic, List
+
+T = TypeVar("T")
+
+class B(Generic[T]):
+    @property
+    def foo(self) -> int: ...
+    @foo.setter
+    def foo(self, x: T) -> None: ...
+
+class C(B[List[T]]): ...
+
+a = C[str]()
+a.foo = ["foo", "bar"]
+reveal_type(a.foo)  # N: Revealed type is "builtins.int"
+a.foo = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "List[str]")
+reveal_type(a.foo)  # N: Revealed type is "builtins.int"
+[builtins fixtures/property.pyi]
+
+[case testPropertyDeleterNoSetterOK]
+class C:
+    @property
+    def x(self) -> int:
+        return 0
+    @x.deleter
+    def x(self) -> None:
+        pass
+[builtins fixtures/property.pyi]

test-data/unit/check-incremental.test

@@ -6745,3 +6745,29 @@ from typing_extensions import TypeAlias
 IntOrStr: TypeAlias = int | str
 assert isinstance(1, IntOrStr)
 [builtins fixtures/type.pyi]
+
+[case testPropertySetterTypeIncremental]
+import b
+[file a.py]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.setter
+    def f(self, x: str) -> None:
+        pass
+[file b.py]
+from a import A
+[file b.py.2]
+from a import A
+a = A()
+a.f = ''  # OK
+reveal_type(a.f)
+a.f = 1
+reveal_type(a.f)
+[builtins fixtures/property.pyi]
+[out]
+[out2]
+tmp/b.py:4: note: Revealed type is "builtins.int"
+tmp/b.py:5: error: Incompatible types in assignment (expression has type "int", variable has type "str")
+tmp/b.py:6: note: Revealed type is "builtins.int"

test-data/unit/fine-grained.test

@@ -11161,3 +11161,53 @@ main:6: error: class a.D is deprecated: use D2 instead
 main:7: error: class a.D is deprecated: use D2 instead
 b.py:1: error: class a.C is deprecated: use C2 instead
 b.py:2: error: class a.D is deprecated: use D2 instead
+
+[case testPropertySetterTypeFineGrained]
+from a import A
+a = A()
+a.f = ''
+[file a.py]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.setter
+    def f(self, x: str) -> None:
+        pass
+[file a.py.2]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.setter
+    def f(self, x: int) -> None:
+        pass
+[builtins fixtures/property.pyi]
+[out]
+==
+main:3: error: Incompatible types in assignment (expression has type "str", variable has type "int")
+
+[case testPropertyDeleteSetterFineGrained]
+from a import A
+a = A()
+a.f = 1
+[file a.py]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.setter
+    def f(self, x: int) -> None:
+        pass
+[file a.py.2]
+class A:
+    @property
+    def f(self) -> int:
+        return 1
+    @f.deleter
+    def f(self) -> None:
+        pass
+[builtins fixtures/property.pyi]
+[out]
+==
+main:3: error: Property "f" defined in "A" is read-only

test-data/unit/fixtures/property.pyi

@@ -13,7 +13,7 @@ class function: pass
 property = object()  # Dummy definition
 class classmethod: pass
 
-class list: pass
+class list(typing.Generic[_T]): pass
 class dict: pass
 class int: pass
 class float: pass