refactor: get rid of the memberaccess parameter

Author: tyralla

mypy/checker.py

@@ -2856,8 +2856,8 @@ def visit_import_from(self, node: ImportFrom) -> None:
             if (sym := self.globals.get(name)) is not None:
                 if isinstance(sym.node, TypeInfo):
                     self.warn_deprecated(sym.node, node)
-                elif isinstance(co := get_proper_type(sym.type), (CallableType, Overloaded)):
-                    self.warn_deprecated(co, node)
+                elif isinstance(typ := get_proper_type(sym.type), (CallableType, Overloaded)):
+                    self.warn_deprecated(typ, node)
         self.check_import(node)
 
     def visit_import_all(self, node: ImportAll) -> None:
@@ -2954,7 +2954,7 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
                     and isinstance(var := lvalue.node, Var)
                     and isinstance(instance := get_proper_type(var.type), Instance)
                 ):
-                    self.check_deprecated_class(instance.type, s, False)
+                    self.check_deprecated_class(instance.type, s)
 
         # Avoid type checking type aliases in stubs to avoid false
         # positives about modern type syntax available in stubs such
@@ -4700,7 +4700,8 @@ def visit_operator_assignment_stmt(self, s: OperatorAssignmentStmt) -> None:
         if inplace:
             # There is __ifoo__, treat as x = x.__ifoo__(y)
             rvalue_type, method_type = self.expr_checker.check_op(method, lvalue_type, s.rvalue, s)
-            self.check_deprecated_function(method_type, s, True)
+            if isinstance(method_type := get_proper_type(method_type), (CallableType, Overloaded)):
+                self.warn_deprecated(method_type, s)
             if not is_subtype(rvalue_type, lvalue_type):
                 self.msg.incompatible_operator_assignment(s.op, s)
         else:
@@ -7595,19 +7596,15 @@ def get_deprecation_warning(
             return f"{name} is deprecated: {deprecation}"
         return f"{name} is deprecated [overload {typ}]: {deprecation}"
 
-    def check_deprecated_function(self, typ: Type, context: Context, memberaccess: bool) -> None:
+    def check_deprecated_function(self, typ: Type, context: Context) -> None:
         if isinstance(typ := get_proper_type(typ), (CallableType, Overloaded)):
-            self._check_deprecated(typ, context, memberaccess)
+            self._check_deprecated(typ, context)
 
-    def check_deprecated_class(self, typ: TypeInfo, context: Context, memberaccess: bool) -> None:
-        self._check_deprecated(typ, context, memberaccess)
+    def check_deprecated_class(self, typ: TypeInfo, context: Context) -> None:
+        self._check_deprecated(typ, context)
 
-    def _check_deprecated(
-        self, typ: CallableType | Overloaded | TypeInfo, context: Context, memberaccess: bool
-    ) -> None:
-        if memberaccess:
-            self.warn_deprecated(typ, context)
-        elif typ.deprecated is not None:
+    def _check_deprecated(self, typ: CallableType | Overloaded | TypeInfo, context: Context) -> None:
+        if typ.deprecated is not None:
             for imp in self.tree.imports:
                 if isinstance(imp, ImportFrom) and any(typ.name == n[0] for n in imp.names):
                     break

mypy/checkexpr.py

@@ -356,9 +356,9 @@ def visit_name_expr(self, e: NameExpr) -> Type:
         result = self.analyze_ref_expr(e)
         narrowed = self.narrow_type_from_binder(e, result)
         if isinstance(e.node, TypeInfo):
-            self.chk.check_deprecated_class(e.node, e, False)
+            self.chk.check_deprecated_class(e.node, e)
         else:
-            self.chk.check_deprecated_function(narrowed, e, False)
+            self.chk.check_deprecated_function(narrowed, e)
         return narrowed
 
     def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
@@ -1479,7 +1479,7 @@ def check_call_expr_with_callee_type(
             callable_name=callable_name,
             object_type=object_type,
         )
-        self.chk.check_deprecated_function(callee_type, e, False)
+        self.chk.check_deprecated_function(callee_type, e)
         proper_callee = get_proper_type(callee_type)
         if isinstance(e.callee, RefExpr) and isinstance(proper_callee, CallableType):
             # Cache it for find_isinstance_check()
@@ -3260,9 +3260,9 @@ def visit_member_expr(self, e: MemberExpr, is_lvalue: bool = False) -> Type:
         result = self.analyze_ordinary_member_access(e, is_lvalue)
         narrowed = self.narrow_type_from_binder(e, result)
         if isinstance(e.node, TypeInfo):
-            self.chk.check_deprecated_class(e.node, e, True)
-        else:
-            self.chk.check_deprecated_function(narrowed, e, True)
+            self.chk.warn_deprecated(e.node, e)
+        elif isinstance(typ := get_proper_type(narrowed), (CallableType, Overloaded)):
+            self.chk.warn_deprecated(typ, e)
         return narrowed
 
     def analyze_ordinary_member_access(self, e: MemberExpr, is_lvalue: bool) -> Type:
@@ -3488,7 +3488,7 @@ def visit_op_expr(self, e: OpExpr) -> Type:
             else:
                 assert_never(use_reverse)
             e.method_type = method_type
-            self.chk.check_deprecated_function(method_type, e, False)
+            self.chk.check_deprecated_function(method_type, e)
             return result
         else:
             raise RuntimeError(f"Unknown operator {e.op}")
@@ -3805,7 +3805,8 @@ def check_method_call_by_name(
             chk=self.chk,
             in_literal_context=self.is_literal_context(),
         )
-        self.chk.check_deprecated_function(method_type, context, True)
+        if isinstance(mt := get_proper_type(method_type), (CallableType, Overloaded)):
+            self.chk.warn_deprecated(mt, context)
         return self.check_method_call(method, base_type, method_type, args, arg_kinds, context)
 
     def check_union_method_call_by_name(