aliases_explicit.py

← Back to index

True Positive

False Positive

False Negative

Optional (detected)

Warning or Info

TP: 19

FP: 1

FN: 2

Optional: 0 / 0

1"""

2Tests explicit type aliases defined with `TypeAlias`.

3"""

5# Specification: https://typing.readthedocs.io/en/latest/spec/aliases.html#typealias

7from typing import Any, Callable, Concatenate, Literal, ParamSpec, TypeVar, Union, assert_type

8from typing import TypeAlias as TA

10S = TypeVar("S")

11T = TypeVar("T")

12P = ParamSpec("P")

13R = TypeVar("R")

15GoodTypeAlias1: TA = Union[int, str]

16GoodTypeAlias2: TA = int | None

17GoodTypeAlias3: TA = list[GoodTypeAlias2]

18GoodTypeAlias4: TA = list[T]

19GoodTypeAlias5: TA = tuple[T, ...] | list[T]

20GoodTypeAlias6: TA = tuple[int, int, S, T]

21GoodTypeAlias7: TA = Callable[..., int]

22GoodTypeAlias8: TA = Callable[[int, T], T]

23GoodTypeAlias9: TA = Callable[Concatenate[int, P], R]

24GoodTypeAlias10: TA = Any

25GoodTypeAlias11: TA = GoodTypeAlias1 | GoodTypeAlias2 | list[GoodTypeAlias4[int]]

26GoodTypeAlias12: TA = Callable[P, None]

27GoodTypeAlias13: TA = "int | str"

28GoodTypeAlias14: TA = list["int | str"]

29GoodTypeAlias15: TA = Literal[3, 4, 5, None]

32def good_type_aliases(

33 p1: GoodTypeAlias1,

34 p2: GoodTypeAlias2,

35 p3: GoodTypeAlias3,

36 p4: GoodTypeAlias4[int],

37 p5: GoodTypeAlias5[str],

38 p6: GoodTypeAlias6[int, str],

39 p7: GoodTypeAlias7,

40 p8: GoodTypeAlias8[str],

41 p9: GoodTypeAlias9[[str, str], None],

42 p10: GoodTypeAlias10,

43 p11: GoodTypeAlias11,

44 p12: GoodTypeAlias12,

45 p13: GoodTypeAlias13,

46 p14: GoodTypeAlias14,

47 p15: GoodTypeAlias15,

48):

49 assert_type(p1, int | str)

50 assert_type(p2, int | None)

51 assert_type(p3, list[int | None])

52 assert_type(p4, list[int])

53 assert_type(p5, tuple[str, ...] | list[str])

54 assert_type(p6, tuple[int, int, int, str])

55 assert_type(p7, Callable[..., int])

56 assert_type(p8, Callable[[int, str], str])

57 assert_type(p9, Callable[[int, str, str], None])

58 assert_type(p10, Any)

59 assert_type(p11, int | str | None | list[list[int]])

60 assert_type(p12, Callable[..., None])

61 assert_type(p13, int | str)

62 assert_type(p14, list[int | str])

63 assert_type(p15, Literal[3, 4, 5, None])

66def good_type_aliases_used_badly(

67 p1: GoodTypeAlias2[int], # E: type alias is not generic

68 p2: GoodTypeAlias3[int], # E: type alias is already specialized

69 p3: GoodTypeAlias4[int, int], # E: too many type arguments

70 p4: GoodTypeAlias8[int, int], # E: too many type arguments

71 p5: GoodTypeAlias9[int, int], # E: bad type argument for ParamSpec

72):

73 pass

76var1 = 3

78# The following should not be allowed as type aliases.

79BadTypeAlias1: TA = eval("".join(map(chr, [105, 110, 116]))) # E

80BadTypeAlias2: TA = [int, str] # E

81BadTypeAlias3: TA = ((int, str),) # E

82BadTypeAlias4: TA = [int for i in range(1)] # E

83BadTypeAlias5: TA = {"a": "b"} # E

84BadTypeAlias6: TA = (lambda: int)() # E

85BadTypeAlias7: TA = [int][0] # E

86BadTypeAlias8: TA = int if 1 < 3 else str # E

87BadTypeAlias9: TA = var1 # E

88BadTypeAlias10: TA = True # E

89BadTypeAlias11: TA = 1 # E

90BadTypeAlias12: TA = list or set # E

91BadTypeAlias13: TA = f"{'int'}" # E

94ListAlias: TA = list

95ListOrSetAlias: TA = list | set

97x1: list[str] = ListAlias() # OK

98assert_type(x1, list[str])

100x2: ListAlias[int] # E: already specialized

101x3 = ListOrSetAlias() # E: cannot instantiate union

102x4: ListOrSetAlias[int] # E: already specialized