Alway visit deleter bodies; more tests

Author: ilevkivskyi

mypy/checker.py

@@ -654,6 +654,7 @@ def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
             assert isinstance(defn.items[0], Decorator)
             self.visit_decorator(defn.items[0])
             if defn.items[0].var.is_settable_property:
+                # TODO: here and elsewhere we assume setter immediately follows getter.
                 assert isinstance(defn.items[1], Decorator)
                 # Perform a reduced visit just to infer the actual setter type.
                 self.visit_decorator_inner(defn.items[1], skip_first_item=True)
@@ -673,9 +674,15 @@ def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
                     # TODO: keep precise type for callables with tricky but valid signatures.
                     setter_type = fallback_setter_type
                 defn.items[0].var.setter_type = setter_type
-        for fdef in defn.items:
+        for i, fdef in enumerate(defn.items):
             assert isinstance(fdef, Decorator)
-            if not defn.is_property:
+            if defn.is_property:
+                assert isinstance(defn.items[0], Decorator)
+                settable = defn.items[0].var.is_settable_property
+                # Do not visit the second time the items we checked above.
+                if (settable and i > 1) or (not settable and i > 0):
+                    self.check_func_item(fdef.func, name=fdef.func.name, allow_empty=True)
+            else:
                 # Perform full check for real overloads to infer type of all decorated
                 # overload variants.
                 self.visit_decorator_inner(fdef, allow_empty=True)

test-data/unit/check-classes.test

@@ -8508,6 +8508,33 @@ class C(B):
     @deco
     def bar(self, x: int, y: int) -> None: ...
 
+    @property
+    def baz(self) -> int: ...
+    @baz.setter
+    @deco_untyped
+    def baz(self, x: int) -> None: ...
+
+c: C
+c.baz = "yes"  # OK, because of untyped decorator
+
 T = TypeVar("T")
 def deco(fn: Callable[[T, int, int], None]) -> Callable[[T, int], None]: ...
+def deco_untyped(fn): ...
+[builtins fixtures/property.pyi]
+
+[case testPropertyDeleterBodyChecked]
+class C:
+    @property
+    def foo(self) -> int: ...
+    @foo.deleter
+    def foo(self) -> None:
+        1()  # E: "int" not callable
+
+    @property
+    def bar(self) -> int: ...
+    @bar.setter
+    def bar(self, x: str) -> None: ...
+    @bar.deleter
+    def bar(self) -> None:
+        1()  # E: "int" not callable
 [builtins fixtures/property.pyi]