Fix inference for properties with __call__

mypy/checkmember.py

@@ -776,47 +776,50 @@ def analyze_var(
         freeze_all_type_vars(t)
         result: Type = t
         typ = get_proper_type(typ)
-        if (
-            var.is_initialized_in_class
-            and (not is_instance_var(var) or mx.is_operator)
-            and isinstance(typ, FunctionLike)
-            and not typ.is_type_obj()
-        ):
-            if mx.is_lvalue:
-                if var.is_property:
-                    if not var.is_settable_property:
-                        mx.msg.read_only_property(name, itype.type, mx.context)
-                else:
-                    mx.msg.cant_assign_to_method(mx.context)
-
-            if not var.is_staticmethod:
-                # Class-level function objects and classmethods become bound methods:
-                # the former to the instance, the latter to the class.
-                functype = typ
-                # Use meet to narrow original_type to the dispatched type.
-                # For example, assume
-                # * A.f: Callable[[A1], None] where A1 <: A (maybe A1 == A)
-                # * B.f: Callable[[B1], None] where B1 <: B (maybe B1 == B)
-                # * x: Union[A1, B1]
-                # In `x.f`, when checking `x` against A1 we assume x is compatible with A
-                # and similarly for B1 when checking against B
-                dispatched_type = meet.meet_types(mx.original_type, itype)
-                signature = freshen_all_functions_type_vars(functype)
-                bound = get_proper_type(expand_self_type(var, signature, mx.original_type))
-                assert isinstance(bound, FunctionLike)
-                signature = bound
-                signature = check_self_arg(
-                    signature, dispatched_type, var.is_classmethod, mx.context, name, mx.msg
-                )
-                signature = bind_self(signature, mx.self_type, var.is_classmethod)
-                expanded_signature = expand_type_by_instance(signature, itype)
-                freeze_all_type_vars(expanded_signature)
-                if var.is_property:
-                    # A property cannot have an overloaded type => the cast is fine.
-                    assert isinstance(expanded_signature, CallableType)
-                    result = expanded_signature.ret_type
-                else:
-                    result = expanded_signature
+        if var.is_initialized_in_class and (not is_instance_var(var) or mx.is_operator):
+            call_type: ProperType
+            if isinstance(typ, FunctionLike) and not typ.is_type_obj():
+                call_type = typ
+            elif var.is_property:
+                call_type = get_proper_type(_analyze_member_access("__call__", typ, mx))
+            else:
+                call_type = typ
+            if isinstance(call_type, FunctionLike) and not call_type.is_type_obj():
+                if mx.is_lvalue:
+                    if var.is_property:
+                        if not var.is_settable_property:
+                            mx.msg.read_only_property(name, itype.type, mx.context)
+                    else:
+                        mx.msg.cant_assign_to_method(mx.context)
+
+                if not var.is_staticmethod:
+                    # Class-level function objects and classmethods become bound methods:
+                    # the former to the instance, the latter to the class.
+                    functype = call_type
+                    # Use meet to narrow original_type to the dispatched type.
+                    # For example, assume
+                    # * A.f: Callable[[A1], None] where A1 <: A (maybe A1 == A)
+                    # * B.f: Callable[[B1], None] where B1 <: B (maybe B1 == B)
+                    # * x: Union[A1, B1]
+                    # In `x.f`, when checking `x` against A1 we assume x is compatible with A
+                    # and similarly for B1 when checking against B
+                    dispatched_type = meet.meet_types(mx.original_type, itype)
+                    signature = freshen_all_functions_type_vars(functype)
+                    bound = get_proper_type(expand_self_type(var, signature, mx.original_type))
+                    assert isinstance(bound, FunctionLike)
+                    signature = bound
+                    signature = check_self_arg(
+                        signature, dispatched_type, var.is_classmethod, mx.context, name, mx.msg
+                    )
+                    signature = bind_self(signature, mx.self_type, var.is_classmethod)
+                    expanded_signature = expand_type_by_instance(signature, itype)
+                    freeze_all_type_vars(expanded_signature)
+                    if var.is_property:
+                        # A property cannot have an overloaded type => the cast is fine.
+                        assert isinstance(expanded_signature, CallableType)
+                        result = expanded_signature.ret_type
+                    else:
+                        result = expanded_signature
     else:
         if not var.is_ready and not mx.no_deferral:
             mx.not_ready_callback(var.name, mx.context)

test-data/unit/check-functions.test

@@ -3158,3 +3158,20 @@ class C(A, B):
 class D(A, B):
     def f(self, z: int) -> str: pass  # E: Method "f" is not using @override but is overriding a method in class "__main__.A"
 [typing fixtures/typing-override.pyi]
+
+[case testCallableProperty]
+from typing import Callable
+
+class something_callable:
+    def __call__(self, fn) -> str: ...
+
+def decorator(fn: Callable[..., int]) -> something_callable: ...
+
+class A:
+    @property
+    @decorator
+    def f(self) -> int: ...
+
+reveal_type(A.f)  # N: Revealed type is "__main__.something_callable"
+reveal_type(A().f)  # N: Revealed type is "builtins.str"
+[builtins fixtures/property.pyi]