test-data/unit/check-deprecated.test

-- Type checker test cases for reporting deprecations.


[case testDeprecatedDisableNotes]
# flags: --disable-error-code=deprecated

from typing_extensions import deprecated

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

f()

[builtins fixtures/tuple.pyi]


[case testDeprecatedAsNoteWithErrorCode]
# flags: --show-error-codes

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: --report-deprecated-as-error --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]

from typing_extensions import deprecated

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

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

[builtins fixtures/tuple.pyi]


[case testDeprecatedFunctionDifferentModule]

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

m.f()  # N: function m.f is deprecated: use f2 instead
p.s.g()  # N: function p.s.g is deprecated: use g2 instead
n.f()  # N: function m.f is deprecated: use f2 instead
ps.g()  # N: function p.s.g is deprecated: use g2 instead
f()
g()
h()  # N: 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]

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

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

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

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

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

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

class E: ...

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

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

[builtins fixtures/tuple.pyi]


[case testDeprecatedClassDifferentModule]

import m
import p.s
import m as n
import p.s as ps
from m import C  # N: class m.C is deprecated: use C2 instead
from p.s import D  # N: class p.s.D is deprecated: use D2 instead
from k import *

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

[file m.py]
from typing_extensions import deprecated

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

from typing_extensions import deprecated

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

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

[builtins fixtures/tuple.pyi]


[case testDeprecatedSpecialMethods]

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

[builtins fixtures/tuple.pyi]


[case testDeprecatedOverloadedSpecialMethods]

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

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  # N: overload def (__main__.A, builtins.int) of function __main__.A.__add__ is deprecated: no A + int
a + "x"
1 + a
"x" + a  # N: overload def (__main__.A, builtins.str) of function __main__.A.__radd__ is deprecated: no str + A
a += 1  # N: function __main__.A.__iadd__ is deprecated: no A += Any
a += "x"  # N: function __main__.A.__iadd__ is deprecated: no A += Any

[builtins fixtures/tuple.pyi]


[case testDeprecatedMethod]

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  # N: function __main__.C.f is deprecated: use g instead
C().f  # N: function __main__.C.f is deprecated: use g instead
C().f()  # N: function __main__.C.f is deprecated: use g instead
C().f(1)  # N: function __main__.C.f is deprecated: use g instead \
          # E: Too many arguments for "f" of "C"
f = C().f  # N: function __main__.C.f is deprecated: use g instead
f()
t = (C.f, C.f, C.g)  # N: function __main__.C.f is deprecated: use g instead

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

[builtins fixtures/callable.pyi]


[case testDeprecatedClassWithDeprecatedMethod]

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()  # N: class __main__.C is deprecated: use D instead \
         # N: function __main__.C.f is deprecated: use g instead
C().g()  # N: class __main__.C is deprecated: use D instead

[builtins fixtures/callable.pyi]


[case testDeprecatedProperty]

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  # N: function __main__.C.f is deprecated: use f2 instead
C().f  # N: function __main__.C.f is deprecated: use f2 instead
C().f()  # N: function __main__.C.f is deprecated: use f2 instead \
         # E: "int" not callable
C().f = 1  # N: 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  # N: function __main__.C.g is deprecated: use g2 instead
C().g = "x"  # N: 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 testDeprecatedOverloadedFunction]

from typing import Union
from typing_extensions import deprecated, overload

@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  # N: function __main__.f is deprecated: use f2 instead
f(1)  # N: function __main__.f is deprecated: use f2 instead
f("x")  # N: function __main__.f is deprecated: use f2 instead
f(1.0)  # N: 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)  # N: overload def (x: builtins.int) -> builtins.int of function __main__.g is deprecated: work with str instead
g("x")
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")  # N: overload def (x: builtins.str) -> builtins.str of function __main__.h is deprecated: work with int instead
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

[builtins fixtures/tuple.pyi]