Fix alias assignments in class body

Author: sterliakov

mypy/checker.py

@@ -2336,18 +2336,23 @@ def check_method_override_for_base_with_name(
             )
         return False
 
-    def get_property_instance(self, method: Decorator) -> Instance | None:
+    def get_property_instance(self, method: Decorator | OverloadedFuncDef) -> Instance | None:
+        deco = method if isinstance(method, Decorator) else method.items[0]
         property_deco_name = next(
             (
                 name
-                for d in method.original_decorators
+                for d in deco.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)
+            # Extra attr preserves the underlying node to support alias assignments
+            # (see testPropertyAliasInClassBody)
+            return self.named_type(property_deco_name).copy_with_extra_attr(
+                "__mypy-wrapped-property", method.type
+            )
         return None
 
     def get_op_other_domain(self, tp: FunctionLike) -> Type | None:
@@ -4409,6 +4414,13 @@ def set_inferred_type(self, var: Var, lvalue: Lvalue, type: Type) -> None:
         refers to the variable (lvalue). If var is None, do nothing.
         """
         if var and not self.current_node_deferred:
+            p_type = get_proper_type(type)
+            if (
+                isinstance(p_type, Instance)
+                and p_type.extra_attrs
+                and "__mypy-wrapped-property" in p_type.extra_attrs.attrs
+            ):
+                type = p_type.extra_attrs.attrs["__mypy-wrapped-property"]
             var.type = type
             var.is_inferred = True
             var.is_ready = True

mypy/checkexpr.py

@@ -384,17 +384,19 @@ def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
             if isinstance(result, PartialType):
                 result = self.chk.handle_partial_var_type(result, lvalue, node, e)
         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, OverloadedFuncDef):
             result = node.type
             if result is None:
                 if self.chk.in_checked_function() and node.items:
                     self.chk.handle_cannot_determine_type(node.name, e)
                 result = AnyType(TypeOfAny.from_error)
-            elif isinstance(node.items[0], Decorator):
-                property_type = self.chk.get_property_instance(node.items[0])
-                if property_type is not None:
-                    result = property_type
+            elif property_type := self.chk.get_property_instance(node):
+                result = property_type
         elif isinstance(node, (FuncDef, TypeInfo, TypeAlias, MypyFile, TypeVarLikeExpr)):
             result = self.analyze_static_reference(node, e, e.is_alias_rvalue or lvalue)
         else:
@@ -435,11 +437,8 @@ def analyze_static_reference(
         special kinds (like TypeAlias, TypeInfo, etc.) on an instance or class object.
         # TODO: merge with analyze_ref_expr() when we are confident about performance.
         """
-        if isinstance(node, (Var, OverloadedFuncDef)):
+        if isinstance(node, (Var, Decorator, OverloadedFuncDef)):
             return node.type or AnyType(TypeOfAny.special_form)
-        elif isinstance(node, Decorator):
-            property_type = self.chk.get_property_instance(node)
-            return property_type or node.type or AnyType(TypeOfAny.special_form)
         elif isinstance(node, FuncDef):
             return function_type(node, self.named_type("builtins.function"))
         elif isinstance(node, TypeInfo):

mypy/checkmember.py

@@ -1226,15 +1226,15 @@ def analyze_class_attribute_access(
                     erase_vars.add(itype.type.self_type)
                 t = erase_typevars(t, {tv.id for tv in erase_vars})
 
-        if isinstance(node.node, Decorator) and node.node.func.is_property:
+        if (
+            isinstance(node.node, Decorator)
+            and node.node.func.is_property
+            or isinstance(node.node, OverloadedFuncDef)
+            and node.node.is_property
+        ):
             property_type = mx.chk.get_property_instance(node.node)
             if property_type is not None:
                 return property_type
-        elif isinstance(node.node, OverloadedFuncDef) and node.node.is_property:
-            assert isinstance(node.node.items[0], Decorator)
-            property_type = mx.chk.get_property_instance(node.node.items[0])
-            if property_type is not None:
-                return property_type
 
         is_classmethod = (
             (is_decorated and cast(Decorator, node.node).func.is_class)

test-data/unit/check-callable.test

@@ -628,6 +628,7 @@ class A:
 
     g2 = f2
 
+reveal_type(A().f)  # N: Revealed type is "builtins.int"
 reveal_type(A().g)  # N: Revealed type is "builtins.int"
 reveal_type(A().g2)  # N: Revealed type is "builtins.int"
 A().g = 1  # E: Property "g" defined in "A" is read-only

test-data/unit/check-protocols.test

@@ -3346,7 +3346,7 @@ def test(arg: P) -> None: ...
 # TODO: skip type mismatch diagnostics in this case.
 test(B)  # E: Argument 1 to "test" has incompatible type "type[B]"; expected "P" \
          # N: Following member(s) of "B" have conflicts: \
-         # N:     foo: expected "int", got "Callable[[B], int]" \
+         # N:     foo: expected "int", got "property" \
          # N: Only class variables allowed for class object access on protocols, foo is an instance variable of "B"
 test(C)  # E: Argument 1 to "test" has incompatible type "type[C]"; expected "P" \
          # N: Only class variables allowed for class object access on protocols, foo is an instance variable of "C"