Move the complete creation process of warning notes from checker.py to semanal.py.

Author: tyralla

mypy/checker.py

@@ -184,7 +184,6 @@
 )
 from mypy.types import (
     ANY_STRATEGY,
-    DEPRECATED_TYPE_NAMES,
     MYPYC_NATIVE_INT_NAMES,
     OVERLOAD_NAMES,
     AnyType,
@@ -637,10 +636,6 @@ def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
         if len(defn.items) == 1:
             self.fail(message_registry.MULTIPLE_OVERLOADS_REQUIRED, defn)
 
-        for item in defn.items:
-            if isinstance(item, Decorator) and isinstance(ct := item.func.type, CallableType):
-                self.create_deprecation_warning(ct, item.decorators)
-
         if defn.is_property:
             # HACK: Infer the type of the property.
             assert isinstance(defn.items[0], Decorator)
@@ -659,17 +654,6 @@ def _visit_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
             self.fail(message_registry.INCONSISTENT_ABSTRACT_OVERLOAD, defn)
         if defn.impl:
             defn.impl.accept(self)
-            if (
-                isinstance(defn.impl, Decorator)
-                and isinstance(defn.impl.func.type, CallableType)
-                and ((deprecated := defn.impl.func.type.deprecated) is not None)
-            ):
-                if isinstance(defn.type, (CallableType, Overloaded)):
-                    defn.type.deprecated = deprecated
-                for subdef in defn.items:
-                    type_ = get_proper_type(subdef.type)
-                    if isinstance(type_, (CallableType, Overloaded)):
-                        type_.deprecated = deprecated
         if not defn.is_property:
             self.check_overlapping_overloads(defn)
             if defn.type is None:
@@ -2422,7 +2406,6 @@ def check__exit__return_type(self, defn: FuncItem) -> None:
     def visit_class_def(self, defn: ClassDef) -> None:
         """Type check a class definition."""
         typ = defn.info
-        self.create_deprecation_warning(typ, defn.decorators)
         for base in typ.mro[1:]:
             if base.is_final:
                 self.fail(message_registry.CANNOT_INHERIT_FROM_FINAL.format(base.name), defn)
@@ -5027,8 +5010,6 @@ def visit_del_stmt(self, s: DelStmt) -> None:
                     )
 
     def visit_decorator(self, e: Decorator) -> None:
-        if isinstance(ct := e.func.type, CallableType):
-            self.create_deprecation_warning(ct, e.decorators)
         for d in e.decorators:
             if isinstance(d, RefExpr):
                 if d.fullname == "typing.no_type_check":
@@ -7556,52 +7537,6 @@ 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 create_deprecation_warning(
-        self, typ: CallableType | Overloaded | TypeInfo, decorators: Iterable[Expression]
-    ) -> None:
-        """Create a warning when visiting a deprecated (decorated) callable, overload or
-        class that may be used later if the deprecated feature is used."""
-
-        if isinstance(typ, CallableType):
-            if (defn := typ.definition) is None:
-                name = f"function {typ.name}"
-            else:
-                name = f"function {defn.fullname}"
-        elif isinstance(typ, Overloaded):
-            if isinstance(func := typ.items[0].definition, FuncDef):
-                name = f"function {func.fullname}"
-            else:
-                name = f"function {typ.name}"
-        else:
-            name = f"class {typ.fullname}"
-
-        overload = False
-        deprecation: str | None = None
-        for decorator in decorators:
-            if (
-                isinstance(typ, CallableType)
-                and isinstance(decorator, NameExpr)
-                and (decorator.fullname in OVERLOAD_NAMES)
-            ):
-                overload = True
-                if deprecation is not None:
-                    self.msg.note("@overload should be placed before @deprecated", decorator)
-            elif (
-                isinstance(decorator, CallExpr)
-                and isinstance(callee := decorator.callee, NameExpr)
-                and (callee.fullname in DEPRECATED_TYPE_NAMES)
-                and (len(args := decorator.args) >= 1)
-                and isinstance(arg := args[0], StrExpr)
-                and ((value := arg.value) is not None)
-            ):
-                deprecation = value
-
-        if deprecation is not None:
-            if overload:
-                typ.deprecated = f"overload {typ} of {name} is deprecated: {deprecation}"
-            else:
-                typ.deprecated = f"{name} is deprecated: {deprecation}"
-
     def check_deprecated(
         self, typ: CallableType | Overloaded | TypeInfo, context: Context
     ) -> None:

mypy/semanal.py

@@ -249,6 +249,7 @@
 from mypy.types import (
     ASSERT_TYPE_NAMES,
     DATACLASS_TRANSFORM_NAMES,
+    DEPRECATED_TYPE_NAMES,
     FINAL_DECORATOR_NAMES,
     FINAL_TYPE_NAMES,
     IMPORTED_REVEAL_TYPE_NAMES,
@@ -1255,10 +1256,51 @@ def analyze_overloaded_func_def(self, defn: OverloadedFuncDef) -> None:
             return
 
         # We know this is an overload def. Infer properties and perform some checks.
+        self.process_deprecated_overload(defn)
         self.process_final_in_overload(defn)
         self.process_static_or_class_method_in_overload(defn)
         self.process_overload_impl(defn)
 
+    def process_deprecated_overload(self, defn: OverloadedFuncDef) -> None:
+        if defn.is_property:
+            return
+
+        if isinstance(impl := defn.impl, Decorator) and isinstance(
+            type_ := impl.func.type, CallableType
+        ) and (
+            (deprecated := type_.deprecated) is not None
+        ):
+            if isinstance(defn.type, Overloaded):
+                defn.type.deprecated = deprecated
+            for item in defn.items:
+                if isinstance(item, Decorator) and isinstance(item.func.type, Overloaded):
+                    item.func.type.deprecated = deprecated
+
+        for item in defn.items:
+            deprecation = False
+            if isinstance(item, Decorator):
+                for d in item.decorators:
+                    if deprecation and refers_to_fullname(d, OVERLOAD_NAMES):
+                        self.msg.note("@overload should be placed before @deprecated", d)
+                    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}"
+                            )
+
+    @staticmethod
+    def get_deprecated(expression: Expression) -> str | None:
+        if (
+            isinstance(expression, CallExpr)
+            and refers_to_fullname(expression.callee, DEPRECATED_TYPE_NAMES)
+            and (len(args := expression.args) >= 1)
+            and isinstance(deprecated := args[0], StrExpr)
+        ):
+            return deprecated.value
+        return None
+
     def process_overload_impl(self, defn: OverloadedFuncDef) -> None:
         """Set flags for an overload implementation.
 
@@ -1457,6 +1499,15 @@ def analyze_property_with_multi_part_definition(self, defn: OverloadedFuncDef) -
         for i in reversed(deleted_items):
             del items[i]
 
+        for item in items[1:]:
+            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}"
+                            )
+
     def add_function_to_symbol_table(self, func: FuncDef | OverloadedFuncDef) -> None:
         if self.is_class_scope():
             assert self.type is not None
@@ -1660,6 +1711,11 @@ def visit_decorator(self, dec: Decorator) -> None:
                 d.callee, DATACLASS_TRANSFORM_NAMES
             ):
                 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}"
+                    )
             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.
@@ -2081,6 +2137,8 @@ def analyze_class_decorator_common(
             info.is_final = True
         elif refers_to_fullname(decorator, TYPE_CHECK_ONLY_NAMES):
             info.is_type_check_only = True
+        elif (deprecated := self.get_deprecated(decorator)) is not None:
+            info.deprecated = f"class {defn.fullname} is deprecated: {deprecated}"
 
     def clean_up_bases_and_infer_type_variables(
         self, defn: ClassDef, base_type_exprs: list[Expression], context: Context