Try more principled approach to method override inference

Author: ilevkivskyi

mypy/checker.py

@@ -17,6 +17,7 @@
     analyze_class_attribute_access,
     analyze_instance_member_access,
     analyze_member_access,
+    is_instance_var,
 )
 from mypy.checkpattern import PatternChecker
 from mypy.constraints import SUPERTYPE_OF
@@ -3408,10 +3409,17 @@ def get_variable_type_context(self, inferred: Var, rvalue: Expression) -> Type |
         type_contexts = []
         if inferred.info:
             for base in inferred.info.mro[1:]:
+                if inferred.name not in base.names:
+                    continue
                 # For inference within class body, get supertype attribute as it would look on
-                # a class object for lambdas overriding methods.
-                base_type, base_node = self.lvalue_type_from_base(
-                    inferred, base, is_class=isinstance(rvalue, LambdaExpr)
+                # a class object for lambdas overriding methods, etc.
+                base_node = base.names[inferred.name].node
+                base_type, _ = self.lvalue_type_from_base(
+                    inferred,
+                    base,
+                    is_class=is_method(base_node)
+                    or isinstance(base_node, Var)
+                    and not is_instance_var(base_node),
                 )
                 if (
                     base_type
@@ -9167,3 +9175,11 @@ def is_typeddict_type_context(lvalue_type: Type | None) -> bool:
         return False
     lvalue_proper = get_proper_type(lvalue_type)
     return isinstance(lvalue_proper, TypedDictType)
+
+
+def is_method(node: SymbolNode | None) -> bool:
+    if isinstance(node, OverloadedFuncDef):
+        return not node.is_property
+    if isinstance(node, Decorator):
+        return not node.var.is_property
+    return isinstance(node, FuncDef)

test-data/unit/check-classes.test

@@ -8613,6 +8613,26 @@ class C(B):
 
 reveal_type(C().f)  # N: Revealed type is "def (x: builtins.int) -> builtins.int"
 
+[case testGenericDecoratorInOverrideInference]
+from typing import Any, Callable, TypeVar
+from typing_extensions import ParamSpec, Concatenate
+
+P = ParamSpec("P")
+T = TypeVar("T")
+def wrap(f: Callable[Concatenate[Any, P], T]) -> Callable[Concatenate[Any, P], T]: ...
+
+class Base:
+    def g(self, a: int) -> int:
+        return a + 1
+
+class Derived(Base):
+    def _g(self, a: int) -> int:
+        return a + 2
+    g = wrap(_g)
+
+reveal_type(Derived().g)  # N: Revealed type is "def (a: builtins.int) -> builtins.int"
+[builtins fixtures/paramspec.pyi]
+
 [case testClassVarOverrideWithSubclass]
 class A: ...
 class B(A): ...