Add missing map_type_from_supertype when checking attr override with property

Author: sterliakov

mypy/checker.py

@@ -2095,6 +2095,13 @@ def check_method_override_for_base_with_name(
                 if original_node and is_property(original_node):
                     original_type = get_property_type(original_type)
 
+            if isinstance(original_node, Var):
+                expanded_type = map_type_from_supertype(original_type, defn.info, base)
+                expanded_type = expand_self_type(
+                    original_node, expanded_type, fill_typevars(defn.info)
+                )
+                original_type = get_proper_type(expanded_type)
+
             if is_property(defn):
                 inner: FunctionLike | None
                 if isinstance(typ, FunctionLike):

test-data/unit/check-generic-subtyping.test

@@ -1065,3 +1065,66 @@ class F(E[T_co], Generic[T_co]): ...  # E: Variance of TypeVar "T_co" incompatib
 
 class G(Generic[T]): ...
 class H(G[T_contra], Generic[T_contra]): ...  # E: Variance of TypeVar "T_contra" incompatible with variance in parent type
+
+[case testParameterizedGenericOverrideWithProperty]
+from typing import TypeVar, Generic
+
+T = TypeVar("T")
+
+class A(Generic[T]):
+    def __init__(self, val: T):
+        self.member: T = val
+
+class B(A[str]):
+    member: str
+
+class GoodPropertyOverride(A[str]):
+    @property
+    def member(self) -> str: ...
+
+    @member.setter
+    def member(self, val: str): ...
+
+class BadPropertyOverride(A[str]):
+    @property  # E: Signature of "member" incompatible with supertype "A" \
+               # N:      Superclass: \
+               # N:          str \
+               # N:      Subclass: \
+               # N:          int
+    def member(self) -> int: ...
+
+    @member.setter
+    def member(self, val: int): ...
+
+class BadGenericPropertyOverride(A[str], Generic[T]):
+    @property  # E: Signature of "member" incompatible with supertype "A" \
+               # N:      Superclass: \
+               # N:          str \
+               # N:      Subclass: \
+               # N:          T
+    def member(self) -> T: ...
+
+    @member.setter
+    def member(self, val: T): ...
+[builtins fixtures/property.pyi]
+
+[case testParameterizedGenericOverrideWithSelfProperty]
+from typing import TypeVar, Generic
+from typing_extensions import Self
+
+T = TypeVar("T")
+
+class A(Generic[T]):
+    def __init__(self, val: T):
+        self.member: T = val
+
+class B(A["B"]):
+    member: Self
+
+class GoodPropertyOverride(A["GoodPropertyOverride"]):
+    @property
+    def member(self) -> Self: ...
+
+    @member.setter
+    def member(self, val: Self): ...
+[builtins fixtures/property.pyi]