test-data/unit/check-deprecated.test

-- Type checker test cases for reporting deprecations.


[case testDeprecatedDisabled]

from typing_extensions import deprecated

@deprecated("use f2 instead")
def f() -> None: ...

f()

[builtins fixtures/tuple.pyi]


[case testDeprecatedAsNoteWithErrorCode]
# flags: --enable-error-code=deprecated --show-error-codes --report-deprecated-as-note

from typing_extensions import deprecated

@deprecated("use f2 instead")
def f() -> None: ...

f() # type: ignore[deprecated]
f() # N: function __main__.f is deprecated: use f2 instead  [deprecated]

[builtins fixtures/tuple.pyi]


[case testDeprecatedAsErrorWithErrorCode]
# flags: --enable-error-code=deprecated --show-error-codes

from typing_extensions import deprecated

@deprecated("use f2 instead")
def f() -> None: ...

f() # type: ignore[deprecated]
f() # E: function __main__.f is deprecated: use f2 instead  [deprecated]

[builtins fixtures/tuple.pyi]


[case testDeprecatedFunction]
# flags: --enable-error-code=deprecated

from typing_extensions import deprecated

@deprecated("use f2 instead")
def f() -> None: ...

f  # E: function __main__.f is deprecated: use f2 instead  # type: ignore[deprecated]
f(1)  # E: function __main__.f is deprecated: use f2 instead \
      # E: Too many arguments for "f"
f[1]  # E: function __main__.f is deprecated: use f2 instead \
      # E: Value of type "Callable[[], None]" is not indexable
g = f  # E: function __main__.f is deprecated: use f2 instead
g()
t = (f, f, g)  # E: function __main__.f is deprecated: use f2 instead

[builtins fixtures/tuple.pyi]


[case testDeprecatedFunctionDifferentModule]
# flags: --enable-error-code=deprecated

import m
import p.s
import m as n
import p.s as ps
from m import f  # E: function m.f is deprecated: use f2 instead
from p.s import g  # E: function p.s.g is deprecated: use g2 instead
from k import *

m.f()  # E: function m.f is deprecated: use f2 instead
p.s.g()  # E: function p.s.g is deprecated: use g2 instead
n.f()  # E: function m.f is deprecated: use f2 instead
ps.g()  # E: function p.s.g is deprecated: use g2 instead
f()
g()
h()  # E: function k.h is deprecated: use h2 instead

[file m.py]
from typing_extensions import deprecated

@deprecated("use f2 instead")
def f() -> None: ...

[file p/s.py]
from typing_extensions import deprecated

@deprecated("use g2 instead")
def g() -> None: ...

[file k.py]
from typing_extensions import deprecated

@deprecated("use h2 instead")
def h() -> None: ...

[builtins fixtures/tuple.pyi]


[case testDeprecatedClass]
# flags: --enable-error-code=deprecated

from typing import Callable, List, Optional, Tuple, Union
from typing_extensions import deprecated, TypeAlias, TypeVar

@deprecated("use C2 instead")
class C: ...

c: C  # E: class __main__.C is deprecated: use C2 instead
C()  # E: class __main__.C is deprecated: use C2 instead
C.missing()  # E: class __main__.C is deprecated: use C2 instead \
             # E: "type[C]" has no attribute "missing"
C.__init__(c)  # E: class __main__.C is deprecated: use C2 instead
C(1)  # E: class __main__.C is deprecated: use C2 instead \
      # E: Too many arguments for "C"

D = C  # E: class __main__.C is deprecated: use C2 instead
D()
t = (C, C, D)  # E: class __main__.C is deprecated: use C2 instead

u1: Union[C, int] = 1  # E: class __main__.C is deprecated: use C2 instead
u1 = 1
u2 = 1  # type: Union[C, int]  # E: class __main__.C is deprecated: use C2 instead
u2 = 1

c1 = c2 = C()  # E: class __main__.C is deprecated: use C2 instead
i, c3 = 1, C()  # E: class __main__.C is deprecated: use C2 instead

class E: ...

x1: Optional[C]  # E: class __main__.C is deprecated: use C2 instead
x2: Union[D, C, E]  # E: class __main__.C is deprecated: use C2 instead
x3: Union[D, Optional[C], E]  # E: class __main__.C is deprecated: use C2 instead
x4: Tuple[D, C, E]  # E: class __main__.C is deprecated: use C2 instead
x5: Tuple[Tuple[D, C], E]  # E: class __main__.C is deprecated: use C2 instead
x6: List[C]  # E: class __main__.C is deprecated: use C2 instead
x7: List[List[C]]  # E: class __main__.C is deprecated: use C2 instead
x8: List[Optional[Tuple[Union[List[C], int]]]]  # E: class __main__.C is deprecated: use C2 instead
x9: Callable[[int], C]  # E: class __main__.C is deprecated: use C2 instead
x10: Callable[[int, C, int], int]  # E: class __main__.C is deprecated: use C2 instead

T = TypeVar("T")
A1: TypeAlias = Optional[C]  # E: class __main__.C is deprecated: use C2 instead
x11: A1
A2: TypeAlias = List[Union[A2, C]]  # E: class __main__.C is deprecated: use C2 instead
x12: A2
A3: TypeAlias = List[Optional[T]]
x13: A3[C]  # E: class __main__.C is deprecated: use C2 instead

[builtins fixtures/tuple.pyi]


[case testDeprecatedBaseClass]
# flags: --enable-error-code=deprecated

from typing_extensions import deprecated

@deprecated("use C2 instead")
class C: ...

class D(C): ...  # E: class __main__.C is deprecated: use C2 instead
class E(D): ...
class F(D, C): ...  # E: class __main__.C is deprecated: use C2 instead

[builtins fixtures/tuple.pyi]


[case testDeprecatedClassInTypeVar]
# flags: --enable-error-code=deprecated

from typing import Generic, TypeVar
from typing_extensions import deprecated

class B: ...
@deprecated("use C2 instead")
class C: ...

T = TypeVar("T", bound=C)  # E: class __main__.C is deprecated: use C2 instead
def f(x: T) -> T: ...
class D(Generic[T]): ...

V = TypeVar("V", B, C)  # E: class __main__.C is deprecated: use C2 instead
def g(x: V) -> V: ...
class E(Generic[V]): ...

[builtins fixtures/tuple.pyi]


[case testDeprecatedClassInCast]
# flags: --enable-error-code=deprecated

from typing import cast, Generic
from typing_extensions import deprecated

class B: ...
@deprecated("use C2 instead")
class C: ...

c = C()  # E: class __main__.C is deprecated: use C2 instead
b = cast(B, c)

[builtins fixtures/tuple.pyi]


[case testDeprecatedInstanceInFunctionDefinition]
# flags: --enable-error-code=deprecated

from typing import Generic, List, Optional, TypeVar
from typing_extensions import deprecated

@deprecated("use C2 instead")
class C: ...

def f1(c: C) -> None:  # E: class __main__.C is deprecated: use C2 instead
    def g1() -> None: ...

def f2(c: List[Optional[C]]) -> None:  # E: class __main__.C is deprecated: use C2 instead
    def g2() -> None: ...

def f3() -> C:  # E: class __main__.C is deprecated: use C2 instead
    def g3() -> None: ...
    return C()  # E: class __main__.C is deprecated: use C2 instead

def f4() -> List[Optional[C]]:  # E: class __main__.C is deprecated: use C2 instead
    def g4() -> None: ...
    return []

def f5() -> None:
    def g5(c: C) -> None: ...  # E: class __main__.C is deprecated: use C2 instead

def f6() -> None:
    def g6() -> C: ...  # E: class __main__.C is deprecated: use C2 instead


@deprecated("use D2 instead")
class D:

    def f1(self, c: C) -> None:  # E: class __main__.C is deprecated: use C2 instead
        def g1() -> None: ...

    def f2(self, c: List[Optional[C]]) -> None:  # E: class __main__.C is deprecated: use C2 instead
        def g2() -> None: ...

    def f3(self) -> None:
        def g3(c: C) -> None: ...  # E: class __main__.C is deprecated: use C2 instead

    def f4(self) -> None:
        def g4() -> C: ...  # E: class __main__.C is deprecated: use C2 instead

T = TypeVar("T")

@deprecated("use E2 instead")
class E(Generic[T]):

    def f1(self: E[C]) -> None: ...  # E: class __main__.C is deprecated: use C2 instead
    def f2(self, e: E[C]) -> None: ...  # E: class __main__.C is deprecated: use C2 instead
    def f3(self) -> E[C]: ...  # E: class __main__.C is deprecated: use C2 instead

[builtins fixtures/tuple.pyi]


[case testDeprecatedClassDifferentModule]
# flags: --enable-error-code=deprecated

import m
import p.s
import m as n
import p.s as ps
from m import B, C  # E: class m.B is deprecated: use B2 instead \
                    # E: class m.C is deprecated: use C2 instead
from p.s import D  # E: class p.s.D is deprecated: use D2 instead
from k import *

m.C()  # E: class m.C is deprecated: use C2 instead
p.s.D()  # E: class p.s.D is deprecated: use D2 instead
n.C()  # E: class m.C is deprecated: use C2 instead
ps.D()  # E: class p.s.D is deprecated: use D2 instead
C()
D()
E()  # E: class k.E is deprecated: use E2 instead

x1: m.A  # E: class m.A is deprecated: use A2 instead
x2: m.A = m.A()  # E: class m.A is deprecated: use A2 instead
y1: B
y2: B = B()

[file m.py]
from typing_extensions import deprecated

@deprecated("use A2 instead")
class A: ...

@deprecated("use B2 instead")
class B: ...

@deprecated("use C2 instead")
class C: ...

[file p/s.py]
from typing_extensions import deprecated

@deprecated("use D2 instead")
class D: ...

[file k.py]
from typing_extensions import deprecated

@deprecated("use E2 instead")
class E: ...

[builtins fixtures/tuple.pyi]


[case testDeprecatedClassInitMethod]
# flags: --enable-error-code=deprecated

from typing_extensions import deprecated

@deprecated("use C2 instead")
class C:
    def __init__(self) -> None: ...

c: C  # E: class __main__.C is deprecated: use C2 instead
C()  # E: class __main__.C is deprecated: use C2 instead
C.__init__(c)  # E: class __main__.C is deprecated: use C2 instead

[builtins fixtures/tuple.pyi]


[case testDeprecatedSpecialMethods]
# flags: --enable-error-code=deprecated

from typing import Iterator
from typing_extensions import deprecated

class A:
    @deprecated("no A + int")
    def __add__(self, v: int) -> None: ...

    @deprecated("no int + A")
    def __radd__(self, v: int) -> None: ...

    @deprecated("no A = A + int")
    def __iadd__(self, v: int) -> A: ...

    @deprecated("no iteration")
    def __iter__(self) -> Iterator[int]: ...

    @deprecated("no in")
    def __contains__(self, v: int) -> int: ...

    @deprecated("no integer")
    def __int__(self) -> int: ...

    @deprecated("no inversion")
    def __invert__(self) -> A: ...

class B:
    @deprecated("still no in")
    def __contains__(self, v: int) -> int: ...

a = A()
b = B()
a + 1  # E: function __main__.A.__add__ is deprecated: no A + int
1 + a  # E: function __main__.A.__radd__ is deprecated: no int + A
a += 1  # E: function __main__.A.__iadd__ is deprecated: no A = A + int
for i in a:  # E: function __main__.A.__iter__ is deprecated: no iteration
    reveal_type(i)  # N: Revealed type is "builtins.int"
1 in a  # E: function __main__.A.__contains__ is deprecated: no in
1 in b  # E: function __main__.B.__contains__ is deprecated: still no in
~a  # E: function __main__.A.__invert__ is deprecated: no inversion

[builtins fixtures/tuple.pyi]


[case testDeprecatedOverloadedInstanceMethods]
# flags: --enable-error-code=deprecated

from typing import Iterator, Union, overload
from typing_extensions import deprecated

class A:
    @overload
    @deprecated("pass `str` instead")
    def f(self, v: int) -> None: ...
    @overload
    def f(self, v: str) -> None: ...
    def f(self, v: Union[int, str]) -> None: ...

    @overload
    def g(self, v: int) -> None: ...
    @overload
    @deprecated("pass `int` instead")
    def g(self, v: str) -> None: ...
    def g(self, v: Union[int, str]) -> None: ...

    @overload
    def h(self, v: int) -> A: ...
    @overload
    def h(self, v: str) -> A: ...
    @deprecated("use `h2` instead")
    def h(self, v: Union[int, str]) -> A: ...

class B(A): ...

a = A()
a.f(1)  # E: overload def (self: __main__.A, v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
a.f("x")
a.g(1)
a.g("x")  # E: overload def (self: __main__.A, v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
a.h(1)  # E: function __main__.A.h is deprecated: use `h2` instead
a.h("x")  # E: function __main__.A.h is deprecated: use `h2` instead

b = B()
b.f(1)  # E: overload def (self: __main__.A, v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
b.f("x")
b.g(1)
b.g("x")  # E: overload def (self: __main__.A, v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
b.h(1)  # E: function __main__.A.h is deprecated: use `h2` instead
b.h("x")  # E: function __main__.A.h is deprecated: use `h2` instead

[builtins fixtures/tuple.pyi]


[case testDeprecatedOverloadedClassMethods]
# flags: --enable-error-code=deprecated

from typing import Iterator, Union, overload
from typing_extensions import deprecated

class A:
    @overload
    @classmethod
    @deprecated("pass `str` instead")
    def f(cls, v: int) -> None: ...
    @overload
    @classmethod
    def f(cls, v: str) -> None: ...
    @classmethod
    def f(cls, v: Union[int, str]) -> None: ...

    @overload
    @classmethod
    def g(cls, v: int) -> None: ...
    @overload
    @classmethod
    @deprecated("pass `int` instead")
    def g(cls, v: str) -> None: ...
    @classmethod
    def g(cls, v: Union[int, str]) -> None: ...

    @overload
    @classmethod
    def h(cls, v: int) -> A: ...
    @overload
    @classmethod
    def h(cls, v: str) -> A: ...
    @deprecated("use `h2`  instead")
    @classmethod
    def h(cls, v: Union[int, str]) -> A: ...

class B(A): ...

a = A()
a.f(1)  # E: overload def (cls: type[__main__.A], v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
a.f("x")
a.g(1)
a.g("x")  # E: overload def (cls: type[__main__.A], v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
a.h(1)  # E: function __main__.A.h is deprecated: use `h2`  instead
a.h("x")  # E: function __main__.A.h is deprecated: use `h2`  instead

b = B()
b.f(1)  # E: overload def (cls: type[__main__.A], v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
b.f("x")
b.g(1)
b.g("x")  # E: overload def (cls: type[__main__.A], v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
b.h(1)  # E: function __main__.A.h is deprecated: use `h2`  instead
b.h("x")  # E: function __main__.A.h is deprecated: use `h2`  instead

[builtins fixtures/tuple.pyi]


[case testDeprecatedOverloadedStaticMethods]
# flags: --enable-error-code=deprecated

from typing import Iterator, Union, overload
from typing_extensions import deprecated

class A:
    @overload
    @staticmethod
    @deprecated("pass `str` instead")
    def f(v: int) -> None: ...
    @overload
    @staticmethod
    def f(v: str) -> None: ...
    @staticmethod
    def f(v: Union[int, str]) -> None: ...

    @overload
    @staticmethod
    def g(v: int) -> None: ...
    @overload
    @staticmethod
    @deprecated("pass `int` instead")
    def g(v: str) -> None: ...
    @staticmethod
    def g(v: Union[int, str]) -> None: ...

    @overload
    @staticmethod
    def h(v: int) -> A: ...
    @overload
    @staticmethod
    def h(v: str) -> A: ...
    @deprecated("use `h2`  instead")
    @staticmethod
    def h(v: Union[int, str]) -> A: ...

class B(A): ...

a = A()
a.f(1)  # E: overload def (v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
a.f("x")
a.g(1)
a.g("x")  # E: overload def (v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
a.h(1)  # E: function __main__.A.h is deprecated: use `h2`  instead
a.h("x")  # E: function __main__.A.h is deprecated: use `h2`  instead

b = B()
b.f(1)  # E: overload def (v: builtins.int) of function __main__.A.f is deprecated: pass `str` instead
b.f("x")
b.g(1)
b.g("x")  # E: overload def (v: builtins.str) of function __main__.A.g is deprecated: pass `int` instead
b.h(1)  # E: function __main__.A.h is deprecated: use `h2`  instead
b.h("x")  # E: function __main__.A.h is deprecated: use `h2`  instead

[builtins fixtures/classmethod.pyi]


[case testDeprecatedOverloadedSpecialMethods]
# flags: --enable-error-code=deprecated

from typing import Iterator, Union, overload
from typing_extensions import deprecated

class A:
    @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: ...

    @overload
    def __radd__(self, v: int) -> None: ...
    @overload
    @deprecated("no str + A")
    def __radd__(self, v: str) -> None: ...
    def __radd__(self, v: Union[int, str]) -> None: ...

    @overload
    def __iadd__(self, v: int) -> A: ...
    @overload
    def __iadd__(self, v: str) -> A: ...
    @deprecated("no A += Any")
    def __iadd__(self, v: Union[int, str]) -> A: ...

a = A()
a + 1  # E: overload def (__main__.A, builtins.int) of function __main__.A.__add__ is deprecated: no A + int
a + "x"
1 + a
"x" + a  # E: overload def (__main__.A, builtins.str) of function __main__.A.__radd__ is deprecated: no str + A
a += 1  # E: function __main__.A.__iadd__ is deprecated: no A += Any
a += "x"  # E: function __main__.A.__iadd__ is deprecated: no A += Any

[builtins fixtures/tuple.pyi]


[case testDeprecatedMethod]
# flags: --enable-error-code=deprecated

from typing_extensions import deprecated

class C:
    @deprecated("use g instead")
    def f(self) -> None: ...

    def g(self) -> None: ...

    @staticmethod
    @deprecated("use g instead")
    def h() -> None: ...

    @deprecated("use g instead")
    @staticmethod
    def k() -> None: ...

C.f  # E: function __main__.C.f is deprecated: use g instead
C().f  # E: function __main__.C.f is deprecated: use g instead
C().f()  # E: function __main__.C.f is deprecated: use g instead
C().f(1)  # E: function __main__.C.f is deprecated: use g instead \
          # E: Too many arguments for "f" of "C"
f = C().f  # E: function __main__.C.f is deprecated: use g instead
f()
t = (C.f, C.f, C.g)  # E: function __main__.C.f is deprecated: use g instead

C().g()
C().h()  # E: function __main__.C.h is deprecated: use g instead
C().k()  # E: function __main__.C.k is deprecated: use g instead

[builtins fixtures/callable.pyi]


[case testDeprecatedClassWithDeprecatedMethod]
# flags: --enable-error-code=deprecated

from typing_extensions import deprecated

@deprecated("use D instead")
class C:
    @deprecated("use g instead")
    def f(self) -> None: ...
    def g(self) -> None: ...

C().f()  # E: class __main__.C is deprecated: use D instead \
         # E: function __main__.C.f is deprecated: use g instead
C().g()  # E: class __main__.C is deprecated: use D instead

[builtins fixtures/callable.pyi]


[case testDeprecatedProperty]
# flags: --enable-error-code=deprecated

from typing_extensions import deprecated

class C:
    @property
    @deprecated("use f2 instead")
    def f(self) -> int: ...

    @property
    def g(self) -> int: ...
    @g.setter
    @deprecated("use g2 instead")
    def g(self, v: int) -> None: ...


C.f  # E: function __main__.C.f is deprecated: use f2 instead
C().f  # E: function __main__.C.f is deprecated: use f2 instead
C().f()  # E: function __main__.C.f is deprecated: use f2 instead \
         # E: "int" not callable
C().f = 1  # E: function __main__.C.f is deprecated: use f2 instead \
           # E: Property "f" defined in "C" is read-only


C.g
C().g
C().g = 1  # E: function __main__.C.g is deprecated: use g2 instead
C().g = "x"  # E: function __main__.C.g is deprecated: use g2 instead \
             # E: Incompatible types in assignment (expression has type "str", variable has type "int")

[builtins fixtures/property.pyi]


[case testDeprecatedDescriptor]
# flags: --enable-error-code=deprecated

from typing import Any, Generic, Optional, overload, TypeVar, Union
from typing_extensions import deprecated

T = TypeVar("T")

@deprecated("use E1 instead")
class D1:
    def __get__(self, obj: Optional[C], objtype: Any) -> Union[D1, int]: ...

class D2:
    @deprecated("use E2.__get__ instead")
    def __get__(self, obj: Optional[C], objtype: Any) -> Union[D2, int]: ...

    @deprecated("use E2.__set__ instead")
    def __set__(self, obj: C, value: int) -> None: ...

class D3:
    @overload
    @deprecated("use E3.__get__ instead")
    def __get__(self, obj: None, objtype: Any) -> D3: ...
    @overload
    @deprecated("use E3.__get__ instead")
    def __get__(self, obj: C, objtype: Any) -> int: ...
    def __get__(self, obj: Optional[C], objtype: Any) -> Union[D3, int]: ...

    @overload
    def __set__(self, obj: C, value: int) -> None: ...
    @overload
    @deprecated("use E3.__set__ instead")
    def __set__(self, obj: C, value: str) -> None: ...
    def __set__(self, obj: C, value: Union[int, str]) -> None: ...

class D4(Generic[T]):
    @overload
    def __get__(self, obj: None, objtype: Any) -> T: ...
    @overload
    @deprecated("deprecated instance access")
    def __get__(self, obj: C, objtype: Any) -> T: ...
    def __get__(self, obj: Optional[C], objtype: Any) -> T: ...

class C:
    d1 = D1()  # E: class __main__.D1 is deprecated: use E1 instead
    d2 = D2()
    d3 = D3()
    d4 = D4[int]()

c: C
C.d1
c.d1
c.d1 = 1

C.d2  # E: function __main__.D2.__get__ is deprecated: use E2.__get__ instead
c.d2  # E: function __main__.D2.__get__ is deprecated: use E2.__get__ instead
c.d2 = 1  # E: function __main__.D2.__set__ is deprecated: use E2.__set__ instead

C.d3  # E: overload def (self: __main__.D3, obj: None, objtype: Any) -> __main__.D3 of function __main__.D3.__get__ is deprecated: use E3.__get__ instead
c.d3  # E: overload def (self: __main__.D3, obj: __main__.C, objtype: Any) -> builtins.int of function __main__.D3.__get__ is deprecated: use E3.__get__ instead
c.d3 = 1
c.d3 = "x"  # E: overload def (self: __main__.D3, obj: __main__.C, value: builtins.str) of function __main__.D3.__set__ is deprecated: use E3.__set__ instead

C.d4
c.d4  # E: overload def (self: __main__.D4[T`1], obj: __main__.C, objtype: Any) -> T`1 of function __main__.D4.__get__ is deprecated: deprecated instance access
[builtins fixtures/property.pyi]


[case testDeprecatedOverloadedFunction]
# flags: --enable-error-code=deprecated

from typing import Any, overload, Union
from typing_extensions import deprecated

int_or_str: Union[int, str]
any: Any

@overload
def f(x: int) -> int: ...
@overload
def f(x: str) -> str: ...
@deprecated("use f2 instead")
def f(x: Union[int, str]) -> Union[int, str]: ...

f  # E: function __main__.f is deprecated: use f2 instead
f(1)  # E: function __main__.f is deprecated: use f2 instead
f("x")  # E: function __main__.f is deprecated: use f2 instead
f(int_or_str)  # E: function __main__.f is deprecated: use f2 instead
f(any)  # E: function __main__.f is deprecated: use f2 instead
f(1.0)  # E: function __main__.f is deprecated: use f2 instead \
        # E: No overload variant of "f" matches argument type "float" \
        # N: Possible overload variants: \
        # N:     def f(x: int) -> int \
        # N:     def f(x: str) -> str

@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]: ...

g
g(1)  # E: overload def (x: builtins.int) -> builtins.int of function __main__.g is deprecated: work with str instead
g("x")
g(int_or_str)  # E: overload def (x: builtins.int) -> builtins.int of function __main__.g is deprecated: work with str instead
g(any)
g(1.0)  # E: No overload variant of "g" matches argument type "float" \
        # N: Possible overload variants: \
        # N:     def g(x: int) -> int \
        # N:     def g(x: str) -> str

@overload
def h(x: int) -> int: ...
@deprecated("work with int instead")
@overload  # N: @overload should be placed before @deprecated
def h(x: str) -> str: ...
def h(x: Union[int, str]) -> Union[int, str]: ...

h
h(1)
h("x")  # E: overload def (x: builtins.str) -> builtins.str of function __main__.h is deprecated: work with int instead
h(int_or_str)  # E: overload def (x: builtins.str) -> builtins.str of function __main__.h is deprecated: work with int instead
h(any)
h(1.0)  # E: No overload variant of "h" matches argument type "float" \
        # N: Possible overload variants: \
        # N:     def h(x: int) -> int \
        # N:     def h(x: str) -> str

@overload
def i(x: int) -> int: ...
@overload
@deprecated("work with int instead")
def i(x: str) -> str: ...
@overload
def i(x: Any) -> Any: ...
def i(x: Union[int, str]) -> Union[int, str]: ...

i
i(1)
i("x")  # E: overload def (x: builtins.str) -> builtins.str of function __main__.i is deprecated: work with int instead
i(int_or_str)  # E: overload def (x: builtins.str) -> builtins.str of function __main__.i is deprecated: work with int instead
i(any)
i(1.0)

@overload
def j(x: int) -> int: ...
@overload
def j(x: str) -> str: ...
@overload
@deprecated("work with int or str instead")
def j(x: Any) -> Any: ...
def j(x: Union[int, str]) -> Union[int, str]: ...

j
j(1)
j("x")
j(int_or_str)
j(any)
j(1.0)  # E: overload def (x: Any) -> Any of function __main__.j is deprecated: work with int or str instead

@overload
@deprecated("work with str instead")
def k(x: int) -> int: ...
@overload
def k(x: str) -> str: ...
@overload
@deprecated("work with str instead")
def k(x: object) -> Any: ...
def k(x: object) -> Union[int, str]: ...

k
k(1)  # E: overload def (x: builtins.int) -> builtins.int of function __main__.k is deprecated: work with str instead
k("x")
k(int_or_str)  # E: overload def (x: builtins.int) -> builtins.int of function __main__.k is deprecated: work with str instead
k(any)
k(1.0)  # E: overload def (x: builtins.object) -> Any of function __main__.k is deprecated: work with str instead
[builtins fixtures/tuple.pyi]

[case testDeprecatedImportedOverloadedFunction]
# flags: --enable-error-code=deprecated

import m

m.g
m.g(1)  # E: overload def (x: builtins.int) -> builtins.int of function m.g is deprecated: work with str instead
m.g("x")

[file m.py]

from typing import Union, overload
from typing_extensions import deprecated

@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]