Move the deprecation attribute from the nodes CallableType and Overloaded to the symbol nodes FuncDef and OverloadedFuncDef

Author: tyralla

mypy/checker.py

@@ -2837,10 +2837,7 @@ def check_metaclass_compatibility(self, typ: TypeInfo) -> None:
     def visit_import_from(self, node: ImportFrom) -> None:
         for name, _ in node.names:
             if (sym := self.globals.get(name)) is not None:
-                if isinstance(sym.node, TypeInfo):
-                    self.warn_deprecated(sym.node, node)
-                elif isinstance(typ := get_proper_type(sym.type), (CallableType, Overloaded)):
-                    self.warn_deprecated(typ, node)
+                self.warn_deprecated(sym.node, node)
         self.check_import(node)
 
     def visit_import_all(self, node: ImportAll) -> None:
@@ -4683,8 +4680,17 @@ 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)
-            if isinstance(method_type := get_proper_type(method_type), (CallableType, Overloaded)):
-                self.warn_deprecated(method_type, s)
+            if (
+                isinstance(inst := get_proper_type(lvalue_type), Instance)
+                and isinstance(defn := inst.type.get_method(method), OverloadedFuncDef)
+            ):
+                for item in defn.items:
+                    if (
+                        isinstance(item, Decorator)
+                        and isinstance(typ := item.func.type, CallableType)
+                        and (bind_self(typ) == method_type)
+                    ):
+                        self.warn_deprecated(item.func, s)
             if not is_subtype(rvalue_type, lvalue_type):
                 self.msg.incompatible_operator_assignment(s.op, s)
         else:
@@ -7537,20 +7543,28 @@ def has_valid_attribute(self, typ: Type, name: str) -> bool:
     def get_expression_type(self, node: Expression, type_context: Type | None = None) -> Type:
         return self.expr_checker.accept(node, type_context=type_context)
 
-    def check_deprecated(
-        self, typ: CallableType | Overloaded | TypeInfo, context: Context
-    ) -> None:
+    def check_deprecated(self, typ: SymbolNode | None, context: Context) -> None:
         """Warn if deprecated and not directly imported with a `from` statement."""
-        if typ.deprecated is not None:
+        if isinstance(typ, Decorator):
+            typ = typ.func
+        if (
+            isinstance(typ, (FuncDef, OverloadedFuncDef, TypeInfo))
+            and (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
             else:
                 self.warn_deprecated(typ, context)
 
-    def warn_deprecated(self, typ: CallableType | Overloaded | TypeInfo, context: Context) -> None:
+    def warn_deprecated(self, typ: SymbolNode | None, context: Context) -> None:
         """Warn if deprecated."""
-        if (deprecated := typ.deprecated) is not None:
+        if isinstance(typ, Decorator):
+            typ = typ.func
+        if (
+            isinstance(typ, (FuncDef, OverloadedFuncDef, TypeInfo))
+            and ((deprecated := typ.deprecated) is not None)
+        ):
             warn = self.msg.fail if self.options.report_deprecated_as_error else self.msg.note
             warn(deprecated, context, code=codes.DEPRECATED)
 

mypy/checkexpr.py

@@ -126,6 +126,7 @@
     validate_instance,
 )
 from mypy.typeops import (
+    bind_self,
     callable_type,
     custom_special_method,
     erase_to_union_or_bound,
@@ -355,10 +356,7 @@ def visit_name_expr(self, e: NameExpr) -> Type:
         self.chk.module_refs.update(extract_refexpr_names(e))
         result = self.analyze_ref_expr(e)
         narrowed = self.narrow_type_from_binder(e, result)
-        if isinstance(e.node, TypeInfo):
-            self.chk.check_deprecated(e.node, e)
-        elif isinstance(typ := get_proper_type(narrowed), (CallableType, Overloaded)):
-            self.chk.check_deprecated(typ, e)
+        self.chk.check_deprecated(e.node, e)
         return narrowed
 
     def analyze_ref_expr(self, e: RefExpr, lvalue: bool = False) -> Type:
@@ -1480,8 +1478,10 @@ def check_call_expr_with_callee_type(
             object_type=object_type,
         )
         proper_callee = get_proper_type(callee_type)
-        if isinstance(proper_callee, (CallableType, Overloaded)):
-            self.chk.check_deprecated(proper_callee, e)
+        if isinstance(e.callee, NameExpr) and isinstance(e.callee.node, OverloadedFuncDef):
+            for item in e.callee.node.items:
+                if isinstance(item, Decorator) and (item.func.type == callee_type):
+                    self.chk.check_deprecated(item.func, e)
         if isinstance(e.callee, RefExpr) and isinstance(proper_callee, CallableType):
             # Cache it for find_isinstance_check()
             if proper_callee.type_guard is not None:
@@ -3260,10 +3260,7 @@ def visit_member_expr(self, e: MemberExpr, is_lvalue: bool = False) -> Type:
         self.chk.module_refs.update(extract_refexpr_names(e))
         result = self.analyze_ordinary_member_access(e, is_lvalue)
         narrowed = self.narrow_type_from_binder(e, result)
-        if isinstance(e.node, TypeInfo):
-            self.chk.warn_deprecated(e.node, e)
-        elif isinstance(typ := get_proper_type(narrowed), (CallableType, Overloaded)):
-            self.chk.warn_deprecated(typ, e)
+        self.chk.warn_deprecated(e.node, e)
         return narrowed
 
     def analyze_ordinary_member_access(self, e: MemberExpr, is_lvalue: bool) -> Type:
@@ -3489,8 +3486,6 @@ def visit_op_expr(self, e: OpExpr) -> Type:
             else:
                 assert_never(use_reverse)
             e.method_type = method_type
-            if isinstance(mt := get_proper_type(method_type), (CallableType, Overloaded)):
-                self.chk.check_deprecated(mt, e)
             return result
         else:
             raise RuntimeError(f"Unknown operator {e.op}")
@@ -3807,8 +3802,6 @@ def check_method_call_by_name(
             chk=self.chk,
             in_literal_context=self.is_literal_context(),
         )
-        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(
@@ -3957,7 +3950,7 @@ def lookup_definer(typ: Instance, attr_name: str) -> str | None:
             # This is the case even if the __add__ method is completely missing and the __radd__
             # method is defined.
 
-            variants_raw = [(left_op, left_type, right_expr)]
+            variants_raw = [(op_name, left_op, left_type, right_expr)]
         elif (
             is_subtype(right_type, left_type)
             and isinstance(left_type, Instance)
@@ -3978,19 +3971,25 @@ def lookup_definer(typ: Instance, attr_name: str) -> str | None:
             # As a special case, the alt_promote check makes sure that we don't use the
             # __radd__ method of int if the LHS is a native int type.
 
-            variants_raw = [(right_op, right_type, left_expr), (left_op, left_type, right_expr)]
+            variants_raw = [
+                (rev_op_name, right_op, right_type, left_expr),
+                (op_name, left_op, left_type, right_expr),
+            ]
         else:
             # In all other cases, we do the usual thing and call __add__ first and
             # __radd__ second when doing "A() + B()".
 
-            variants_raw = [(left_op, left_type, right_expr), (right_op, right_type, left_expr)]
+            variants_raw = [
+                (op_name, left_op, left_type, right_expr),
+                (rev_op_name, right_op, right_type, left_expr),
+            ]
 
         # STEP 3:
         # We now filter out all non-existent operators. The 'variants' list contains
         # all operator methods that are actually present, in the order that Python
         # attempts to invoke them.
 
-        variants = [(op, obj, arg) for (op, obj, arg) in variants_raw if op is not None]
+        variants = [(na, op, obj, arg) for (na, op, obj, arg) in variants_raw if op is not None]
 
         # STEP 4:
         # We now try invoking each one. If an operation succeeds, end early and return
@@ -3999,13 +3998,24 @@ def lookup_definer(typ: Instance, attr_name: str) -> str | None:
 
         errors = []
         results = []
-        for method, obj, arg in variants:
+        for name, method, obj, arg in variants:
             with self.msg.filter_errors(save_filtered_errors=True) as local_errors:
                 result = self.check_method_call(op_name, obj, method, [arg], [ARG_POS], context)
             if local_errors.has_new_errors():
                 errors.append(local_errors.filtered_errors())
                 results.append(result)
             else:
+                if (
+                    isinstance(obj, Instance)
+                    and isinstance(defn := obj.type.get_method(name), OverloadedFuncDef)
+                ):
+                    for item in defn.items:
+                        if (
+                            isinstance(item, Decorator)
+                            and isinstance(typ := item.func.type, CallableType)
+                            and bind_self(typ) == result[1]
+                        ):
+                            self.chk.check_deprecated(item.func, context)
                 return result
 
         # We finish invoking above operators and no early return happens. Therefore,

mypy/checkmember.py

@@ -318,16 +318,9 @@ def analyze_instance_member_access(
             assert isinstance(method, OverloadedFuncDef)
             getter = method.items[0]
             assert isinstance(getter, Decorator)
-            if (
-                mx.is_lvalue
-                and (len(items := method.items) > 1)
-                and isinstance(setter := items[1], Decorator)
-            ):
-                if isinstance(co := setter.func.type, (CallableType, Overloaded)):
-                    mx.chk.warn_deprecated(co, mx.context)
+            if mx.is_lvalue and (len(items := method.items) > 1):
+                mx.chk.warn_deprecated(items[1], mx.context)
             return analyze_var(name, getter.var, typ, info, mx)
-        elif isinstance(co := method.type, (CallableType, Overloaded)):
-            mx.chk.warn_deprecated(co, mx.context)
 
         if mx.is_lvalue:
             mx.msg.cant_assign_to_method(mx.context)
@@ -503,6 +496,8 @@ def analyze_member_var_access(
     # It was not a method. Try looking up a variable.
     v = lookup_member_var_or_accessor(info, name, mx.is_lvalue)
 
+    mx.chk.warn_deprecated(v, mx.context)
+
     vv = v
     if isinstance(vv, Decorator):
         # The associated Var node of a decorator contains the type.
@@ -783,9 +778,6 @@ def analyze_var(
         result = t
         typ = get_proper_type(typ)
 
-        if var.is_property and isinstance(typ, CallableType):
-            mx.chk.warn_deprecated(typ, mx.context)
-
         call_type: ProperType | None = None
         if var.is_initialized_in_class and (not is_instance_var(var) or mx.is_operator):
             if isinstance(typ, FunctionLike) and not typ.is_type_obj():
@@ -1017,6 +1009,8 @@ def analyze_class_attribute_access(
         # on the class object itself rather than the instance.
         return None
 
+    mx.chk.warn_deprecated(node.node, mx.context)
+
     is_decorated = isinstance(node.node, Decorator)
     is_method = is_decorated or isinstance(node.node, FuncBase)
     if mx.is_lvalue:

mypy/errors.py

@@ -194,6 +194,9 @@ def on_error(self, file: str, info: ErrorInfo) -> bool:
         Return True to filter out the error, preventing it from being seen by other
         ErrorWatcher further down the stack and from being recorded by Errors
         """
+        if info.code == codes.DEPRECATED:
+            return False
+
         self._has_new_errors = True
         if isinstance(self._filter, bool):
             should_filter = self._filter

mypy/nodes.py

@@ -561,17 +561,19 @@ class OverloadedFuncDef(FuncBase, SymbolNode, Statement):
     Overloaded variants must be consecutive in the source file.
     """
 
-    __slots__ = ("items", "unanalyzed_items", "impl")
+    __slots__ = ("items", "unanalyzed_items", "impl", "deprecated")
 
     items: list[OverloadPart]
     unanalyzed_items: list[OverloadPart]
     impl: OverloadPart | None
+    deprecated: str | None
 
     def __init__(self, items: list[OverloadPart]) -> None:
         super().__init__()
         self.items = items
         self.unanalyzed_items = items.copy()
         self.impl = None
+        self.deprecated = None
         if items:
             # TODO: figure out how to reliably set end position (we don't know the impl here).
             self.set_line(items[0].line, items[0].column)
@@ -596,6 +598,7 @@ def serialize(self) -> JsonDict:
             "fullname": self._fullname,
             "impl": None if self.impl is None else self.impl.serialize(),
             "flags": get_flags(self, FUNCBASE_FLAGS),
+            "deprecated": self.deprecated,
         }
 
     @classmethod
@@ -615,6 +618,7 @@ def deserialize(cls, data: JsonDict) -> OverloadedFuncDef:
             res.type = typ
         res._fullname = data["fullname"]
         set_flags(res, data["flags"])
+        res.deprecated = data["deprecated"]
         # NOTE: res.info will be set in the fixup phase.
         return res
 
@@ -781,6 +785,7 @@ class FuncDef(FuncItem, SymbolNode, Statement):
         # Present only when a function is decorated with @typing.datasclass_transform or similar
         "dataclass_transform_spec",
         "docstring",
+        "deprecated",
     )
 
     __match_args__ = ("name", "arguments", "type", "body")
@@ -810,6 +815,7 @@ def __init__(
         self.is_mypy_only = False
         self.dataclass_transform_spec: DataclassTransformSpec | None = None
         self.docstring: str | None = None
+        self.deprecated: str | None = None
 
     @property
     def name(self) -> str:
@@ -840,6 +846,7 @@ def serialize(self) -> JsonDict:
                 if self.dataclass_transform_spec is None
                 else self.dataclass_transform_spec.serialize()
             ),
+            "deprecated": self.deprecated,
         }
 
     @classmethod
@@ -867,6 +874,7 @@ def deserialize(cls, data: JsonDict) -> FuncDef:
             if data["dataclass_transform_spec"] is not None
             else None
         )
+        ret.deprecated = data["deprecated"]
         # Leave these uninitialized so that future uses will trigger an error
         del ret.arguments
         del ret.max_pos

mypy/semanal.py

@@ -1267,14 +1267,12 @@ def process_deprecated_overload(self, defn: OverloadedFuncDef) -> None:
 
         if (
             isinstance(impl := defn.impl, Decorator)
-            and isinstance(type_ := impl.func.type, CallableType)
-            and ((deprecated := type_.deprecated) is not None)
+            and ((deprecated := impl.func.deprecated) is not None)
         ):
-            if isinstance(defn.type, Overloaded):
-                defn.type.deprecated = deprecated
+            defn.deprecated = deprecated
             for item in defn.items:
-                if isinstance(item, Decorator) and isinstance(item.func.type, Overloaded):
-                    item.func.type.deprecated = deprecated
+                if isinstance(item, Decorator):
+                    item.func.deprecated = deprecated
 
         for item in defn.items:
             deprecation = False
@@ -1285,10 +1283,13 @@ def process_deprecated_overload(self, defn: OverloadedFuncDef) -> None:
                     elif (deprecated := self.get_deprecated(d)) is not None:
                         deprecation = True
                         if isinstance(type_ := item.func.type, CallableType):
-                            type_.deprecated = (
-                                f"overload {type_} of function {defn.fullname} is deprecated: "
-                                f"{deprecated}"
-                            )
+                            typestr = f" {type_} "
+                        else:
+                            typestr = " "
+                        item.func.deprecated = (
+                            f"overload{typestr}of function {defn.fullname} is deprecated: "
+                            f"{deprecated}"
+                        )
 
     @staticmethod
     def get_deprecated(expression: Expression) -> str | None:
@@ -1503,10 +1504,9 @@ def analyze_property_with_multi_part_definition(self, defn: OverloadedFuncDef) -
             if isinstance(item, Decorator):
                 for d in item.decorators:
                     if (deprecated := self.get_deprecated(d)) is not None:
-                        if isinstance(type_ := item.func.type, CallableType):
-                            type_.deprecated = (
-                                f"function {item.fullname} is deprecated: {deprecated}"
-                            )
+                        item.func.deprecated = (
+                            f"function {item.fullname} is deprecated: {deprecated}"
+                        )
 
     def add_function_to_symbol_table(self, func: FuncDef | OverloadedFuncDef) -> None:
         if self.is_class_scope():
@@ -1712,8 +1712,7 @@ def visit_decorator(self, dec: Decorator) -> None:
             ):
                 dec.func.dataclass_transform_spec = self.parse_dataclass_transform_spec(d)
             elif (deprecated := self.get_deprecated(d)) is not None:
-                if isinstance(type_ := dec.func.type, CallableType):
-                    type_.deprecated = f"function {dec.fullname} is deprecated: {deprecated}"
+                dec.func.deprecated = f"function {dec.fullname} is deprecated: {deprecated}"
             elif not dec.var.is_property:
                 # We have seen a "non-trivial" decorator before seeing @property, if
                 # we will see a @property later, give an error, as we don't support this.