Reveal property at class level too

Author: sterliakov

mypy/checker.py

@@ -170,6 +170,7 @@
     ANY_STRATEGY,
     MYPYC_NATIVE_INT_NAMES,
     OVERLOAD_NAMES,
+    PROPERTY_DECORATOR_NAMES,
     AnyType,
     BoolTypeQuery,
     CallableType,
@@ -2147,6 +2148,20 @@ def check_method_override_for_base_with_name(
                                 defn.func,
                                 code=codes.OVERRIDE,
                             )
+            elif (
+                isinstance(defn, Decorator)
+                and isinstance(typ, Instance)
+                and typ.type.fullname == "builtins.property"
+            ):
+                self.msg.fail(
+                    "Property setter/deletter overrides are not supported.",
+                    defn.func,
+                    code=codes.MISC,
+                )
+                self.msg.note(
+                    "Consider overriding getter explicitly with super() call.", defn.func
+                )
+                return False
 
             if isinstance(original_type, AnyType) or isinstance(typ, AnyType):
                 pass
@@ -2215,6 +2230,20 @@ def check_method_override_for_base_with_name(
                 )
         return False
 
+    def get_property_instance(self, method: Decorator) -> Instance | None:
+        property_deco_name = next(
+            (
+                name
+                for d in method.original_decorators
+                for name in PROPERTY_DECORATOR_NAMES
+                if refers_to_fullname(d, name)
+            ),
+            None,
+        )
+        if property_deco_name is not None:
+            return self.named_type(property_deco_name)
+        return None
+
     def bind_and_map_method(
         self, sym: SymbolTableNode, typ: FunctionLike, sub_info: TypeInfo, super_info: TypeInfo
     ) -> FunctionLike:

mypy/checkexpr.py

@@ -409,7 +409,11 @@ def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
             # Reference to a module object.
             result = self.module_type(node)
         elif isinstance(node, Decorator):
-            result = self.analyze_var_ref(node.var, e)
+            property_type = self.chk.get_property_instance(node)
+            if property_type is not None:
+                result = property_type
+            else:
+                result = self.analyze_var_ref(node.var, e)
         elif isinstance(node, TypeAlias):
             # Something that refers to a type alias appears in runtime context.
             # Note that we suppress bogus errors for alias redefinitions,

mypy/checkmember.py

@@ -38,7 +38,6 @@
     is_final_node,
 )
 from mypy.plugin import AttributeContext
-from mypy.semanal import refers_to_fullname
 from mypy.typeops import (
     bind_self,
     class_callable,
@@ -51,7 +50,6 @@
     type_object_type_from_function,
 )
 from mypy.types import (
-    PROPERTY_DECORATOR_NAMES,
     AnyType,
     CallableType,
     DeletedType,
@@ -1112,18 +1110,10 @@ def analyze_class_attribute_access(
             #     C[int].x -> int
             t = erase_typevars(expand_type_by_instance(t, isuper), {tv.id for tv in def_vars})
 
-        if is_decorated:
-            property_deco_name = next(
-                (
-                    name
-                    for d in cast(Decorator, node.node).original_decorators
-                    for name in PROPERTY_DECORATOR_NAMES
-                    if refers_to_fullname(d, name)
-                ),
-                None,
-            )
-            if property_deco_name is not None:
-                return mx.named_type(property_deco_name)
+        if is_decorated and cast(Decorator, node.node).func.is_property:
+            property_type = mx.chk.get_property_instance(cast(Decorator, node.node))
+            if property_type is not None:
+                return property_type
 
         is_classmethod = (is_decorated and cast(Decorator, node.node).func.is_class) or (
             isinstance(node.node, FuncBase) and node.node.is_class

mypy/semanal.py

@@ -7153,6 +7153,8 @@ def already_defined(
         self.fail(
             f'{noun} "{unmangle(name)}" already defined{extra_msg}', ctx, code=codes.NO_REDEF
         )
+        if isinstance(node, Decorator) and node.func.is_property:
+            self.note("Property setter and deleter must be adjacent to the getter.", ctx)
 
     def name_already_defined(
         self, name: str, ctx: Context, original_ctx: SymbolTableNode | SymbolNode | None = None

test-data/unit/check-classes.test

@@ -1621,8 +1621,7 @@ class A:
         self.x = 1
         self.x = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
         return ''
-[builtins fixtures/property.pyi]
-[out]
+[builtins fixtures/property-full.pyi]
 
 [case testDynamicallyTypedProperty]
 import typing
@@ -1632,7 +1631,7 @@ class A:
 a = A()
 a.f.xx
 a.f = '' # E: Property "f" defined in "A" is read-only
-[builtins fixtures/property.pyi]
+[builtins fixtures/property-full.pyi]
 
 [case testPropertyWithSetter]
 import typing
@@ -1649,7 +1648,7 @@ a.f.x # E: "int" has no attribute "x"
 a.f = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 a.f = 1
 reveal_type(a.f)  # N: Revealed type is "builtins.int"
-[builtins fixtures/property.pyi]
+[builtins fixtures/property-full.pyi]
 
 [case testPropertyWithDeleterButNoSetter]
 import typing
@@ -1663,18 +1662,21 @@ class A:
 a = A()
 a.f = a.f # E: Property "f" defined in "A" is read-only
 a.f.x # E: "int" has no attribute "x"
-[builtins fixtures/property.pyi]
+[builtins fixtures/property-full.pyi]
 
 [case testPropertyAccessOnClass]
 class Foo:
     @property
     def bar(self) -> bool:
         return True
 
+    reveal_type(bar)  # N: Revealed type is "builtins.property"
+
 reveal_type(Foo.bar)  # N: Revealed type is "builtins.property"
 reveal_type(Foo.bar(Foo()))  # E: "property" not callable \
                              # N: Revealed type is "Any"
-[builtins fixtures/property.pyi]
+
+[builtins fixtures/property-full.pyi]
 
 [case testPropertyAccessOnClass2]
 import functools
@@ -1689,11 +1691,67 @@ class Foo:
     def bar(self) -> bool:
         return True
 
+    reveal_type(foo)  # N: Revealed type is "functools.cached_property[Any]"
+    reveal_type(bar)  # N: Revealed type is "functools.cached_property[Any]"
+
 reveal_type(Foo.foo)  # N: Revealed type is "functools.cached_property[Any]"
 reveal_type(Foo.bar)  # N: Revealed type is "functools.cached_property[Any]"
 Foo.foo(Foo())  # E: "cached_property[Any]" not callable
 Foo.bar(Foo())  # E: "cached_property[Any]" not callable
-[builtins fixtures/property.pyi]
+[builtins fixtures/property-full.pyi]
+
+[case testPropertySetterOverrideInCubclass]
+# See https://github.com/python/mypy/issues/5936
+# Ideally we should support this, but at least be explicit that it isn't supported
+class Base:
+    def __init__(self, value: int) -> None:
+        self._value = value
+
+    @property
+    def value(self) -> int:
+        return self._value
+
+    reveal_type(value)  # N: Revealed type is "builtins.property"
+    reveal_type(value.setter)  # N: Revealed type is "def (def (Any, Any)) -> builtins.property"
+
+class Sub(Base):
+    @Base.value.setter
+    def value(self, value: int) -> None:  # E: Property setter/deletter overrides are not supported. \
+                                          # N: Consider overriding getter explicitly with super() call.
+        self._value = value
+
+reveal_type(Base.value)  # N: Revealed type is "builtins.property"
+reveal_type(Base(0).value)  # N: Revealed type is "builtins.int"
+Base(0).value = 2  # E: Property "value" defined in "Base" is read-only
+
+reveal_type(Sub.value)  # N: Revealed type is "Any"
+reveal_type(Sub(0).value)  # N: Revealed type is "Any"
+Sub(0).value = 2
+[builtins fixtures/property-full.pyi]
+
+[case testPropertySetterNonAdjacent]
+# See https://github.com/python/mypy/issues/1465
+# We want to support this later, but at least fail explicitly for now.
+class A(object):
+    @property
+    def val(self) -> int:
+        return 0
+
+    reveal_type(val)  # N: Revealed type is "builtins.property"
+
+    def _other(self) -> None: ...
+
+    @val.setter  # E: Name "val" already defined on line 4 \
+                 # N: Property setter and deleter must be adjacent to the getter.
+    def val(self, val: int) -> None:
+        pass
+
+    reveal_type(val)  # N: Revealed type is "builtins.property"
+
+reveal_type(A.val)  # N: Revealed type is "builtins.property"
+reveal_type(A().val)  # N: Revealed type is "builtins.int"
+A().val = 1  # E: Property "val" defined in "A" is read-only
+[builtins fixtures/property-full.pyi]
 
 -- Descriptors
 -- -----------

test-data/unit/fixtures/property-full.pyi

@@ -0,0 +1,43 @@
+from typing import Any, Callable, Generic, TypeVar
+
+_T = TypeVar('_T')
+
+class object:
+    def __init__(self) -> None: pass
+
+class type:
+    def __init__(self, x: Any) -> None: pass
+
+class function: pass
+
+class property:
+    fget: Callable[[Any], Any] | None
+    fset: Callable[[Any, Any], None] | None
+    fdel: Callable[[Any], None] | None
+    __isabstractmethod__: bool
+
+    def __init__(
+        self,
+        fget: Callable[[Any], Any] | None = ...,
+        fset: Callable[[Any, Any], None] | None = ...,
+        fdel: Callable[[Any], None] | None = ...,
+        doc: str | None = ...,
+    ) -> None: ...
+    def getter(self, fget: Callable[[Any], Any], /) -> property: ...
+    def setter(self, fset: Callable[[Any, Any], None], /) -> property: ...
+    def deleter(self, fdel: Callable[[Any], None], /) -> property: ...
+    def __get__(self, instance: Any, owner: type | None = None, /) -> Any: ...
+    def __set__(self, instance: Any, value: Any, /) -> None: ...
+    def __delete__(self, instance: Any, /) -> None: ...
+class classmethod: pass
+
+class list: pass
+class dict: pass
+class int: pass
+class float: pass
+class str: pass
+class bytes: pass
+class bool: pass
+class ellipsis: pass
+
+class tuple(Generic[_T]): pass