implement reporting on type[ClassWithDeprecatedConstructor]()

Author: bzoracler

mypy/checkexpr.py

@@ -1420,7 +1420,11 @@ def is_generic_decorator_overload_call(
         return None
 
     def handle_decorator_overload_call(
-        self, callee_type: CallableType, overloaded: Overloaded, ctx: Context
+        self,
+        callee_type: CallableType,
+        overloaded: Overloaded,
+        ctx: Context,
+        callee_is_overload_item: bool,
     ) -> tuple[Type, Type] | None:
         """Type-check application of a generic callable to an overload.
 
@@ -1432,7 +1436,9 @@ def handle_decorator_overload_call(
         for item in overloaded.items:
             arg = TempNode(typ=item)
             with self.msg.filter_errors() as err:
-                item_result, inferred_arg = self.check_call(callee_type, [arg], [ARG_POS], ctx)
+                item_result, inferred_arg = self.check_call(
+                    callee_type, [arg], [ARG_POS], ctx, is_overload_item=callee_is_overload_item
+                )
             if err.has_new_errors():
                 # This overload doesn't match.
                 continue
@@ -1538,6 +1544,7 @@ def check_call(
         callable_name: str | None = None,
         object_type: Type | None = None,
         original_type: Type | None = None,
+        is_overload_item: bool = False,
     ) -> tuple[Type, Type]:
         """Type check a call.
 
@@ -1558,6 +1565,7 @@ def check_call(
                 or None if unavailable (examples: 'builtins.open', 'typing.Mapping.get')
             object_type: If callable_name refers to a method, the type of the object
                 on which the method is being called
+            is_overload_item: Whether this check is for an individual overload item
         """
         callee = get_proper_type(callee)
 
@@ -1568,7 +1576,7 @@ def check_call(
                     # Special casing for inline application of generic callables to overloads.
                     # Supporting general case would be tricky, but this should cover 95% of cases.
                     overloaded_result = self.handle_decorator_overload_call(
-                        callee, overloaded, context
+                        callee, overloaded, context, is_overload_item
                     )
                     if overloaded_result is not None:
                         return overloaded_result
@@ -1582,6 +1590,7 @@ def check_call(
                 callable_node,
                 callable_name,
                 object_type,
+                is_overload_item,
             )
         elif isinstance(callee, Overloaded):
             return self.check_overload_call(
@@ -1659,33 +1668,26 @@ def check_callable_call(
         callable_node: Expression | None,
         callable_name: str | None,
         object_type: Type | None,
+        is_overload_item: bool = False,
     ) -> tuple[Type, Type]:
         """Type check a call that targets a callable value.
 
         See the docstring of check_call for more information.
         """
+        # Check implicit calls to deprecated class constructors.
+        # Only the non-overload case is handled here. Overloaded constructors are handled
+        # separately during overload resolution.
+        if (not is_overload_item) and callee.is_type_obj():
+            self.chk.warn_deprecated(callee.definition, context)
+
         # Always unpack **kwargs before checking a call.
         callee = callee.with_unpacked_kwargs().with_normalized_var_args()
         if callable_name is None and callee.name:
             callable_name = callee.name
         ret_type = get_proper_type(callee.ret_type)
         if callee.is_type_obj() and isinstance(ret_type, Instance):
             callable_name = ret_type.type.fullname
-        if isinstance(callable_node, RefExpr):
-            # Check implicit calls to deprecated class constructors.
-            # Only the non-overload case is handled here. Overloaded constructors are handled
-            # separately during overload resolution. `callable_node` is `None` for an overload
-            # item so deprecation checks are not duplicated.
-            callable_info: TypeInfo | None = None
-            if isinstance(callable_node.node, TypeInfo):
-                callable_info = callable_node.node
-            elif isinstance(callable_node.node, TypeAlias):
-                alias_target = get_proper_type(callable_node.node.target)
-                if isinstance(alias_target, Instance) and isinstance(alias_target.type, TypeInfo):
-                    callable_info = alias_target.type
-            if callable_info is not None:
-                self.chk.check_deprecated(callee.definition, context)
-
+        if isinstance(callable_node, RefExpr) and (callable_node.fullname in ENUM_BASES):
             if callable_node.fullname in ENUM_BASES:
                 # An Enum() call that failed SemanticAnalyzerPass2.check_enum_call().
                 return callee.ret_type, callee
@@ -2925,6 +2927,7 @@ def infer_overload_return_type(
                         context=context,
                         callable_name=callable_name,
                         object_type=object_type,
+                        is_overload_item=True,
                     )
             is_match = not w.has_new_errors()
             if is_match:

test-data/unit/check-deprecated.test

@@ -416,6 +416,127 @@ B2_explicit_alias
 [builtins fixtures/tuple.pyi]
 
 
+[case testDeprecatedClassConstructorCalledFromTypeType]
+# flags: --enable-error-code=deprecated
+
+from typing_extensions import deprecated
+
+class A:
+    @deprecated("do not use")
+    def __init__(self) -> None: ...
+
+class B1(A): ...
+
+class B2(A):
+    def __init__(self) -> None: ...
+
+def get_class_A() -> type[A]: ...
+def get_class_B1() -> type[B1]: ...
+def get_class_B2() -> type[B2]: ...
+
+A_type_obj: type[A]
+B1_type_obj: type[B1]
+B2_type_obj: type[B2]
+A_type_obj()  # E: function __main__.A.__init__ is deprecated: do not use
+B1_type_obj()  # E: function __main__.A.__init__ is deprecated: do not use
+B2_type_obj()
+get_class_A()()  # E: function __main__.A.__init__ is deprecated: do not use
+get_class_B1()()  # E: function __main__.A.__init__ is deprecated: do not use
+get_class_B2()()
+
+def call_class_A(cls: type[A]) -> None:
+    cls()  # E: function __main__.A.__init__ is deprecated: do not use
+
+def call_class_B1(cls: type[B1]) -> None:
+    cls()  # E: function __main__.A.__init__ is deprecated: do not use
+
+def call_class_B2(cls: type[B2]) -> None:
+    cls()
+
+[builtins fixtures/tuple.pyi]
+
+
+[case testDeprecatedClassConstructorTypeNarrowing]
+# flags: --enable-error-code=deprecated
+
+from typing import TypeVar
+from typing_extensions import TypeAlias, TypeIs, deprecated
+
+T = TypeVar("T")
+
+class Dummy: ...
+
+class A:
+    @deprecated("do not use")
+    def __init__(self) -> None: ...
+
+class B(A):
+    def __init__(self) -> None: ...
+
+def maybe() -> bool: ...
+
+# `builtins.issubclass()` does not type-narrow properly
+def is_subclass(c1: type, c2: type[T]) -> TypeIs[type[T]]: ...
+
+A_alias: TypeAlias = A
+A_type_obj: type[A]
+B_alias: TypeAlias = B
+B_type_obj: type[B]
+
+maybe_A = A if maybe() else None
+maybe_A_alias = A_alias if maybe() else None
+maybe_A_type_obj = A_type_obj if maybe() else None
+if maybe_A is not None:
+    maybe_A()  # E: function __main__.A.__init__ is deprecated: do not use
+else:
+    maybe_A()  # E: "None" not callable
+if maybe_A_alias is not None:
+    maybe_A_alias()  # E: function __main__.A.__init__ is deprecated: do not use
+else:
+    maybe_A_alias()  # E: "None" not callable
+if maybe_A_type_obj is not None:
+    maybe_A_type_obj()  # E: function __main__.A.__init__ is deprecated: do not use
+else:
+    maybe_A_type_obj()  # E: "None" not callable
+
+A_or_Dummy = A if maybe() else Dummy
+A_type_obj_or_Dummy = A_type_obj if maybe() else Dummy
+if is_subclass(A_or_Dummy, A):
+    A_or_Dummy()  # E: function __main__.A.__init__ is deprecated: do not use
+else:
+    A_or_Dummy()
+if is_subclass(A_or_Dummy, Dummy):
+    A_or_Dummy()
+else:
+    A_or_Dummy()  # E: function __main__.A.__init__ is deprecated: do not use
+if is_subclass(A_type_obj_or_Dummy, A):
+    A_type_obj_or_Dummy()  # E: function __main__.A.__init__ is deprecated: do not use
+else:
+    A_type_obj_or_Dummy()
+if is_subclass(A_type_obj_or_Dummy, Dummy):
+    A_type_obj_or_Dummy()
+else:
+    A_type_obj_or_Dummy()  # E: function __main__.A.__init__ is deprecated: do not use
+
+A_or_B = A if maybe() else B
+A_or_B_alias = A if maybe() else B_alias
+A_or_B_type_obj = A if maybe() else B_type_obj
+if is_subclass(A_or_B, B):
+    A_or_B()
+else:
+    A_or_B()  # E: function __main__.A.__init__ is deprecated: do not use
+if is_subclass(A_or_B_alias, B):
+    A_or_B_alias()
+else:
+    A_or_B_alias()  # E: function __main__.A.__init__ is deprecated: do not use
+if is_subclass(A_or_B_type_obj, B):
+    A_or_B_type_obj()
+else:
+    A_or_B_type_obj()  # E: function __main__.A.__init__ is deprecated: do not use
+
+[builtins fixtures/tuple.pyi]
+
+
 [case testDeprecatedSpecialMethods]
 # flags: --enable-error-code=deprecated