Enable support for decorated properties where possible

mypy/checker.py

@@ -4310,6 +4310,9 @@ def visit_decorator(self, e: Decorator) -> None:
         e.var.type = sig
         e.var.is_ready = True
         if e.func.is_property:
+            if isinstance(sig, CallableType):
+                if len([k for k in sig.arg_kinds if k.is_required()]) > 1:
+                    self.msg.fail("Too many arguments for property", e)
             self.check_incompatible_property_override(e)
         if e.func.info and not e.func.is_dynamic():
             self.check_method_override(e)

mypy/semanal.py

@@ -1049,6 +1049,8 @@ def analyze_overload_sigs_and_impl(
                 else:
                     item.func.is_overload = True
                     types.append(callable)
+                    if item.var.is_property:
+                        self.fail("An overload can not be a property", item)
             elif isinstance(item, FuncDef):
                 if i == len(defn.items) - 1 and not self.is_stub_file:
                     impl = item
@@ -1168,16 +1170,18 @@ def analyze_property_with_multi_part_definition(self, defn: OverloadedFuncDef) -
         deleted_items = []
         for i, item in enumerate(items[1:]):
             if isinstance(item, Decorator):
-                if len(item.decorators) == 1:
+                if len(item.decorators) >= 1:
                     node = item.decorators[0]
                     if isinstance(node, MemberExpr):
                         if node.name == "setter":
                             # The first item represents the entire property.
                             first_item.var.is_settable_property = True
                             # Get abstractness from the original definition.
                             item.func.abstract_status = first_item.func.abstract_status
-                else:
-                    self.fail("Decorated property not supported", item)
+                    else:
+                        self.fail(
+                            f"Only supported top decorator is @{first_item.func.name}.setter", item
+                        )
                 item.func.accept(self)
             else:
                 self.fail(f'Unexpected definition for property "{first_item.func.name}"', item)
@@ -1258,6 +1262,7 @@ def visit_decorator(self, dec: Decorator) -> None:
             d.accept(self)
         removed: List[int] = []
         no_type_check = False
+        could_be_decorated_property = False
         for i, d in enumerate(dec.decorators):
             # A bunch of decorators are special cased here.
             if refers_to_fullname(d, "abc.abstractmethod"):
@@ -1288,8 +1293,6 @@ def visit_decorator(self, dec: Decorator) -> None:
                 elif refers_to_fullname(d, "functools.cached_property"):
                     dec.var.is_settable_property = True
                 self.check_decorated_function_is_method("property", dec)
-                if len(dec.func.arguments) > 1:
-                    self.fail("Too many arguments", dec.func)
             elif refers_to_fullname(d, "typing.no_type_check"):
                 dec.var.type = AnyType(TypeOfAny.special_form)
                 no_type_check = True
@@ -1304,15 +1307,21 @@ def visit_decorator(self, dec: Decorator) -> None:
                     removed.append(i)
                 else:
                     self.fail("@final cannot be used with non-method functions", d)
+            elif not dec.var.is_property:
+                # We have seen a "non-trivial" decorator before seeing @property, if
+                # we will see a @property later, give an error, as we don't support this.
+                could_be_decorated_property = True
         for i in reversed(removed):
             del dec.decorators[i]
         if (not dec.is_overload or dec.var.is_property) and self.type:
             dec.var.info = self.type
             dec.var.is_initialized_in_class = True
         if not no_type_check and self.recurse_into_functions:
             dec.func.accept(self)
-        if dec.decorators and dec.var.is_property:
-            self.fail("Decorated property not supported", dec)
+        if could_be_decorated_property and dec.decorators and dec.var.is_property:
+            self.fail("Decorators on top of @property are not supported", dec)
+        if (dec.func.is_static or dec.func.is_class) and dec.var.is_property:
+            self.fail("Only instance methods can be decorated with @property", dec)
         if dec.func.abstract_status == IS_ABSTRACT and dec.func.is_final:
             self.fail(f"Method {dec.func.name} is both abstract and final", dec)
 

test-data/unit/check-abstract.test

@@ -1030,3 +1030,23 @@ def deco(cls: Type[T]) -> Type[T]: ...
 class A(metaclass=ABCMeta):
     @abstractmethod
     def foo(self, x: int) -> None: ...
+
+[case testAbstractPropertiesAllowed]
+from abc import abstractmethod
+
+class B:
+    @property
+    @abstractmethod
+    def x(self) -> int: ...
+    @property
+    @abstractmethod
+    def y(self) -> int: ...
+    @y.setter
+    @abstractmethod
+    def y(self, value: int) -> None: ...
+
+B()  # E: Cannot instantiate abstract class "B" with abstract attributes "x" and "y"
+b: B
+b.x = 1  # E: Property "x" defined in "B" is read-only
+b.y = 1
+[builtins fixtures/property.pyi]

test-data/unit/check-classes.test

@@ -7006,8 +7006,8 @@ class A:
     def y(self) -> int: ...
     @y.setter
     def y(self, value: int) -> None: ...
-    @dec
-    def y(self) -> None: ...  # TODO: This should generate an error
+    @dec  # E: Only supported top decorator is @y.setter
+    def y(self) -> None: ...
 
 reveal_type(A().y)  # N: Revealed type is "builtins.int"
 [builtins fixtures/property.pyi]
@@ -7044,7 +7044,7 @@ reveal_type(D1() + 0.5)  # N: Revealed type is "__main__.D1"
 [builtins fixtures/primitives.pyi]
 
 [case testRefMethodWithDecorator]
-from typing import Type
+from typing import Type, final
 
 class A:
     pass
@@ -7058,7 +7058,7 @@ class B:
         return A
 
 class C:
-    @property
+    @final
     @staticmethod
     def A() -> Type[A]:
         return A

test-data/unit/check-functions.test

@@ -2589,3 +2589,88 @@ def a(b: any): pass # E: Function "builtins.any" is not valid as a type \
 def a(b: callable): pass # E: Function "builtins.callable" is not valid as a type \
                          # N: Perhaps you meant "typing.Callable" instead of "callable"?
 [builtins fixtures/callable.pyi]
+
+[case testDecoratedProperty]
+from typing import TypeVar, Callable, final
+
+T = TypeVar("T")
+
+def dec(f: Callable[[T], int]) -> Callable[[T], str]: ...
+def dec2(f: T) -> T: ...
+
+class A:
+    @property
+    @dec
+    def f(self) -> int: pass
+    @property
+    @dec2
+    def g(self) -> int: pass
+reveal_type(A().f)  # N: Revealed type is "builtins.str"
+reveal_type(A().g)  # N: Revealed type is "builtins.int"
+
+class B:
+    @final
+    @property
+    @dec
+    def f(self) -> int: pass
+reveal_type(B().f)  # N: Revealed type is "builtins.str"
+
+class C:
+    @property  # E: Only instance methods can be decorated with @property
+    @classmethod
+    def f(cls) -> int: pass
+reveal_type(C().f)  # N: Revealed type is "builtins.int"
+[builtins fixtures/property.pyi]
+[out]
+
+[case testDecoratedPropertySetter]
+from typing import TypeVar, Callable, final
+
+T = TypeVar("T")
+def dec(f: T) -> T: ...
+
+class A:
+    @property
+    @dec
+    def f(self) -> int: pass
+    @f.setter
+    @dec
+    def f(self, v: int) -> None: pass
+reveal_type(A().f)  # N: Revealed type is "builtins.int"
+
+class B:
+    @property
+    @dec
+    def f(self) -> int: pass
+    @dec # E: Only supported top decorator is @f.setter
+    @f.setter
+    def f(self, v: int) -> None: pass
+
+class C:
+    @dec  # E: Decorators on top of @property are not supported
+    @property
+    def f(self) -> int: pass
+    @f.setter
+    @dec
+    def f(self, v: int) -> None: pass
+[builtins fixtures/property.pyi]
+[out]
+
+[case testInvalidArgCountForProperty]
+from typing import Callable, TypeVar
+
+T = TypeVar("T")
+def dec(f: Callable[[T], int]) -> Callable[[T, int], int]: ...
+
+class A:
+    @property  # E: Too many arguments for property
+    def f(self, x) -> int: pass
+    @property  # E: Too many arguments for property
+    @dec
+    def e(self) -> int: pass
+    @property
+    def g() -> int: pass   # E: Method must have at least one argument
+    @property
+    def h(self, *args, **kwargs) -> int: pass   # OK
+[builtins fixtures/property.pyi]
+[out]

test-data/unit/check-functools.test

@@ -119,8 +119,8 @@ class Child(Parent):
     def f(self) -> str: pass
     @cached_property
     def g(self) -> int: pass
-    @cached_property
-    def h(self, arg) -> int: pass  # E: Too many arguments
+    @cached_property  # E: Too many arguments for property
+    def h(self, arg) -> int: pass
 reveal_type(Parent().f)  # N: Revealed type is "builtins.str"
 reveal_type(Child().f)  # N: Revealed type is "builtins.str"
 reveal_type(Child().g)  # N: Revealed type is "builtins.int"

test-data/unit/fixtures/property.pyi

@@ -11,6 +11,7 @@ class type:
 class function: pass
 
 property = object()  # Dummy definition
+class classmethod: pass
 
 class dict: pass
 class int: pass

test-data/unit/semanal-errors.test

@@ -1205,23 +1205,13 @@ def f() -> int: pass
 [builtins fixtures/property.pyi]
 [out]
 
-[case testInvalidArgCountForProperty]
-import typing
-class A:
-    @property
-    def f(self, x) -> int: pass  # E: Too many arguments
-    @property
-    def g() -> int: pass   # E: Method must have at least one argument
-[builtins fixtures/property.pyi]
-[out]
-
 [case testOverloadedProperty]
 from typing import overload
 class A:
-    @overload  # E: Decorated property not supported
+    @overload  # E: Decorators on top of @property are not supported
     @property
     def f(self) -> int: pass
-    @property  # E: Decorated property not supported
+    @property  # E: Only supported top decorator is @f.setter
     @overload
     def f(self) -> int: pass
 [builtins fixtures/property.pyi]
@@ -1232,7 +1222,7 @@ from typing import overload
 class A:
     @overload  # E: An overloaded function outside a stub file must have an implementation
     def f(self) -> int: pass
-    @property  # E: Decorated property not supported
+    @property  # E: An overload can not be a property
     @overload
     def f(self) -> int: pass
 [builtins fixtures/property.pyi]
@@ -1242,10 +1232,10 @@ class A:
 import typing
 def dec(f): pass
 class A:
-    @dec  # E: Decorated property not supported
+    @dec  # E: Decorators on top of @property are not supported
     @property
     def f(self) -> int: pass
-    @property  # E: Decorated property not supported
+    @property  # OK
     @dec
     def g(self) -> int: pass
 [builtins fixtures/property.pyi]