PEP 702 (@deprecated): improve the handling of overloaded functions and methods

Author: tyralla

mypy/checker.py

@@ -4648,9 +4648,6 @@ def check_member_assignment(
 
         # Search for possible deprecations:
         mx.chk.check_deprecated(dunder_set, mx.context)
-        mx.chk.warn_deprecated_overload_item(
-            dunder_set, mx.context, target=inferred_dunder_set_type, selftype=attribute_type
-        )
 
         # In the following cases, a message already will have been recorded in check_call.
         if (not isinstance(inferred_dunder_set_type, CallableType)) or (
@@ -7894,21 +7891,6 @@ def warn_deprecated(self, node: Node | None, context: Context) -> None:
             warn = self.msg.note if self.options.report_deprecated_as_note else self.msg.fail
             warn(deprecated, context, code=codes.DEPRECATED)
 
-    def warn_deprecated_overload_item(
-        self, node: Node | None, context: Context, *, target: Type, selftype: Type | None = None
-    ) -> None:
-        """Warn if the overload item corresponding to the given callable is deprecated."""
-        target = get_proper_type(target)
-        if isinstance(node, OverloadedFuncDef) and isinstance(target, CallableType):
-            for item in node.items:
-                if isinstance(item, Decorator) and isinstance(
-                    candidate := item.func.type, CallableType
-                ):
-                    if selftype is not None and not node.is_static:
-                        candidate = bind_self(candidate, selftype)
-                    if candidate == target:
-                        self.warn_deprecated(item.func, context)
-
     # leafs
 
     def visit_pass_stmt(self, o: PassStmt, /) -> None:

mypy/checkexpr.py

@@ -1476,15 +1476,6 @@ def check_call_expr_with_callee_type(
             object_type=object_type,
         )
         proper_callee = get_proper_type(callee_type)
-        if isinstance(e.callee, (NameExpr, MemberExpr)):
-            node = e.callee.node
-            if node is None and member is not None and isinstance(object_type, Instance):
-                if (symbol := object_type.type.get(member)) is not None:
-                    node = symbol.node
-            self.chk.check_deprecated(node, e)
-            self.chk.warn_deprecated_overload_item(
-                node, e, target=callee_type, selftype=object_type
-            )
         if isinstance(e.callee, RefExpr) and isinstance(proper_callee, CallableType):
             # Cache it for find_isinstance_check()
             if proper_callee.type_guard is not None:
@@ -2652,6 +2643,25 @@ def check_overload_call(
         context: Context,
     ) -> tuple[Type, Type]:
         """Checks a call to an overloaded function."""
+
+        # The following hack tries to update the `definition` attribute of the given callable
+        # type's items with the related decorator symbols to allow checking for deprecations:
+        funcdef = None
+        if callable_name is not None:
+            if isinstance(inst := get_proper_type(object_type), Instance):
+                if (sym := inst.type.get(callable_name.rpartition(".")[-1])) is not None:
+                    funcdef = sym.node
+            else:
+                name_module, _, name = callable_name.rpartition(".")
+                if (
+                    (module := self.chk.modules.get(name_module)) is not None
+                    and (sym := module.names.get(name)) is not None
+                ):
+                    funcdef = sym.node
+        if isinstance(funcdef, OverloadedFuncDef):
+            for typ, defn in zip(callee.items, funcdef.items):
+                typ.definition = defn
+
         # Normalize unpacked kwargs before checking the call.
         callee = callee.with_unpacked_kwargs()
         arg_types = self.infer_arg_types_in_empty_context(args)
@@ -2714,19 +2724,25 @@ def check_overload_call(
             object_type,
             context,
         )
-        # If any of checks succeed, stop early.
+        # If any of checks succeed, perform deprecation tests and stop early.
         if inferred_result is not None and unioned_result is not None:
             # Both unioned and direct checks succeeded, choose the more precise type.
             if (
                 is_subtype(inferred_result[0], unioned_result[0])
                 and not isinstance(get_proper_type(inferred_result[0]), AnyType)
                 and not none_type_var_overlap
             ):
-                return inferred_result
-            return unioned_result
-        elif unioned_result is not None:
+                unioned_result = None
+            else:
+                inferred_result = None
+        if unioned_result is not None:
+            for inferred_type in inferred_types:
+                if isinstance(c := get_proper_type(inferred_type), CallableType):
+                    self.chk.warn_deprecated(c.definition, context)
             return unioned_result
-        elif inferred_result is not None:
+        if inferred_result is not None:
+            if isinstance(c := get_proper_type(inferred_result[1]), CallableType):
+                self.chk.warn_deprecated(c.definition, context)
             return inferred_result
 
         # Step 4: Failure. At this point, we know there is no match. We fall back to trying
@@ -4077,21 +4093,11 @@ def lookup_definer(typ: Instance, attr_name: str) -> str | None:
         results = []
         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)
+                result = self.check_method_call(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

@@ -7,6 +7,7 @@
 
 from mypy import message_registry, subtypes
 from mypy.erasetype import erase_typevars
+import mypy.errorcodes as codes
 from mypy.expandtype import (
     expand_self_type,
     expand_type_by_instance,
@@ -701,6 +702,10 @@ def analyze_descriptor_access(
         object_type=descriptor_type,
     )
 
+    deprecated_disabled = False
+    if assignment and codes.DEPRECATED in mx.chk.options.enabled_error_codes:
+        mx.chk.options.enabled_error_codes.remove(codes.DEPRECATED)
+        deprecated_disabled = True
     _, inferred_dunder_get_type = mx.chk.expr_checker.check_call(
         dunder_get_type,
         [
@@ -712,12 +717,10 @@ def analyze_descriptor_access(
         object_type=descriptor_type,
         callable_name=callable_name,
     )
-
+    if deprecated_disabled:
+        mx.chk.options.enabled_error_codes.add(codes.DEPRECATED)
     if not assignment:
         mx.chk.check_deprecated(dunder_get, mx.context)
-        mx.chk.warn_deprecated_overload_item(
-            dunder_get, mx.context, target=inferred_dunder_get_type, selftype=descriptor_type
-        )
 
     inferred_dunder_get_type = get_proper_type(inferred_dunder_get_type)
     if isinstance(inferred_dunder_get_type, AnyType):

mypy/server/astdiff.py

@@ -252,6 +252,16 @@ def snapshot_definition(node: SymbolNode | None, common: SymbolSnapshot) -> Symb
                 setter_type = snapshot_optional_type(first_item.var.setter_type)
         is_trivial_body = impl.is_trivial_body if impl else False
         dataclass_transform_spec = find_dataclass_transform_spec(node)
+
+        deprecated = None
+        if isinstance(node, FuncDef):
+            deprecated = node.deprecated
+        elif isinstance(node, OverloadedFuncDef):
+            deprecated_list = [node.deprecated] + [i.func.deprecated for i in node.items]
+            deprecated_list_cleaned = [d for d in deprecated_list if d is not None]
+            if deprecated_list_cleaned:
+                deprecated = ",".join(deprecated_list_cleaned)
+
         return (
             "Func",
             common,
@@ -262,7 +272,7 @@ def snapshot_definition(node: SymbolNode | None, common: SymbolSnapshot) -> Symb
             signature,
             is_trivial_body,
             dataclass_transform_spec.serialize() if dataclass_transform_spec is not None else None,
-            node.deprecated if isinstance(node, FuncDef) else None,
+            deprecated,
             setter_type,  # multi-part properties are stored as OverloadedFuncDef
         )
     elif isinstance(node, Var):

test-data/unit/check-deprecated.test

@@ -429,8 +429,8 @@ b.h("x")  # E: function __main__.A.h is deprecated: use `h2` instead
 [case testDeprecatedOverloadedClassMethods]
 # flags: --enable-error-code=deprecated
 
-from typing import Iterator, Union, overload
-from typing_extensions import deprecated
+from typing import Iterator, Union
+from typing_extensions import deprecated, overload
 
 class A:
     @overload
@@ -487,8 +487,8 @@ b.h("x")  # E: function __main__.A.h is deprecated: use `h2`  instead
 [case testDeprecatedOverloadedStaticMethods]
 # flags: --enable-error-code=deprecated
 
-from typing import Iterator, Union, overload
-from typing_extensions import deprecated
+from typing import Iterator, Union
+from typing_extensions import deprecated, overload
 
 class A:
     @overload
@@ -545,8 +545,8 @@ b.h("x")  # E: function __main__.A.h is deprecated: use `h2`  instead
 [case testDeprecatedOverloadedSpecialMethods]
 # flags: --enable-error-code=deprecated
 
-from typing import Iterator, Union, overload
-from typing_extensions import deprecated
+from typing import Iterator, Union
+from typing_extensions import deprecated, overload
 
 class A:
     @overload
@@ -671,8 +671,8 @@ C().g = "x"  # E: function __main__.C.g is deprecated: use g2 instead \
 [case testDeprecatedDescriptor]
 # flags: --enable-error-code=deprecated
 
-from typing import Any, Optional, Union, overload
-from typing_extensions import deprecated
+from typing import Any, Optional, Union
+from typing_extensions import deprecated, overload
 
 @deprecated("use E1 instead")
 class D1:
@@ -725,8 +725,8 @@ c.d3 = "x"  # E: overload def (self: __main__.D3, obj: __main__.C, value: builti
 [case testDeprecatedOverloadedFunction]
 # flags: --enable-error-code=deprecated
 
-from typing import Union, overload
-from typing_extensions import deprecated
+from typing import Union
+from typing_extensions import deprecated, overload
 
 @overload
 def f(x: int) -> int: ...
@@ -788,65 +788,14 @@ m.g("x")
 
 [file m.py]
 
-from typing import Union, overload
-from typing_extensions import deprecated
+from typing import Union
+from typing_extensions import deprecated, overload
 
 @overload
 @deprecated("work with str instead")
 def g(x: int) -> int: ...
 @overload
 def g(x: str) -> str: ...
 def g(x: Union[int, str]) -> Union[int, str]: ...
-[builtins fixtures/tuple.pyi]
-
-[case testDeprecatedExclude]
-# flags: --enable-error-code=deprecated --deprecated-calls-exclude=m.C --deprecated-calls-exclude=m.D --deprecated-calls-exclude=m.E.f --deprecated-calls-exclude=m.E.g --deprecated-calls-exclude=m.E.__add__
-from m import C, D, E
-
-[file m.py]
-from typing import Union, overload
-from typing_extensions import deprecated
-
-@deprecated("use C2 instead")
-class C:
-    def __init__(self) -> None: ...
-
-c: C
-C()
-C.__init__(c)
-
-class D:
-    @deprecated("use D.g instead")
-    def f(self) -> None: ...
-
-    def g(self) -> None: ...
-
-D.f
-D().f
-D().f()
-
-class E:
-    @overload
-    def f(self, x: int) -> int: ...
-    @overload
-    def f(self, x: str) -> str: ...
-    @deprecated("use E.f2 instead")
-    def f(self, x: Union[int, str]) -> Union[int, str]: ...
-
-    @deprecated("use E.h instead")
-    def g(self) -> None: ...
-
-    @overload
-    @deprecated("no A + int")
-    def __add__(self, v: int) -> None: ...
-    @overload
-    def __add__(self, v: str) -> None: ...
-    def __add__(self, v: Union[int, str]) -> None: ...
-
-E().f(1)
-E().f("x")
 
-e = E()
-e.g()
-e + 1
 [builtins fixtures/tuple.pyi]