1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
[case testAnnotated0]
from typing_extensions import Annotated
x: Annotated[int, ...]
reveal_type(x) # N: Revealed type is "builtins.int"
[builtins fixtures/tuple.pyi]
[case testAnnotated1]
from typing import Union
from typing_extensions import Annotated
x: Annotated[Union[int, str], ...]
reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
[builtins fixtures/tuple.pyi]
[case testAnnotated2]
from typing_extensions import Annotated
x: Annotated[int, THESE, ARE, IGNORED, FOR, NOW]
reveal_type(x) # N: Revealed type is "builtins.int"
[builtins fixtures/tuple.pyi]
[case testAnnotated3]
from typing_extensions import Annotated
x: Annotated[int, -+~12.3, "som"[e], more(anno+a+ions, that=[are]), (b"ignored",), 4, N.O.W, ...]
reveal_type(x) # N: Revealed type is "builtins.int"
[builtins fixtures/tuple.pyi]
[case testAnnotatedBadType]
from typing_extensions import Annotated
x: Annotated[XXX, ...] # E: Name "XXX" is not defined
reveal_type(x) # N: Revealed type is "Any"
[builtins fixtures/tuple.pyi]
[case testAnnotatedBadNoArgs]
from typing_extensions import Annotated
x: Annotated # E: Annotated[...] must have exactly one type argument and at least one annotation
reveal_type(x) # N: Revealed type is "Any"
[builtins fixtures/tuple.pyi]
[case testAnnotatedBadOneArg]
from typing_extensions import Annotated
x: Annotated[int] # E: Annotated[...] must have exactly one type argument and at least one annotation
reveal_type(x) # N: Revealed type is "Any"
[builtins fixtures/tuple.pyi]
[case testAnnotatedNested0]
from typing_extensions import Annotated
x: Annotated[Annotated[int, ...], ...]
reveal_type(x) # N: Revealed type is "builtins.int"
[builtins fixtures/tuple.pyi]
[case testAnnotatedNested1]
from typing import Union
from typing_extensions import Annotated
x: Annotated[Annotated[Union[int, str], ...], ...]
reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
[builtins fixtures/tuple.pyi]
[case testAnnotatedNestedBadType]
from typing_extensions import Annotated
x: Annotated[Annotated[XXX, ...], ...] # E: Name "XXX" is not defined
reveal_type(x) # N: Revealed type is "Any"
[builtins fixtures/tuple.pyi]
[case testAnnotatedNestedBadNoArgs]
from typing_extensions import Annotated
x: Annotated[Annotated, ...] # E: Annotated[...] must have exactly one type argument and at least one annotation
reveal_type(x) # N: Revealed type is "Any"
[builtins fixtures/tuple.pyi]
[case testAnnotatedNestedBadOneArg]
from typing_extensions import Annotated
x: Annotated[Annotated[int], ...] # E: Annotated[...] must have exactly one type argument and at least one annotation
reveal_type(x) # N: Revealed type is "Any"
[builtins fixtures/tuple.pyi]
[case testAnnotatedNoImport]
x: Annotated[int, ...] # E: Name "Annotated" is not defined
reveal_type(x) # N: Revealed type is "Any"
[case testAnnotatedDifferentName]
from typing_extensions import Annotated as An
x: An[int, ...]
reveal_type(x) # N: Revealed type is "builtins.int"
[builtins fixtures/tuple.pyi]
[case testAnnotatedAliasSimple]
from typing import Tuple
from typing_extensions import Annotated
Alias = Annotated[Tuple[int, ...], ...]
x: Alias
reveal_type(x) # N: Revealed type is "builtins.tuple[builtins.int, ...]"
[builtins fixtures/tuple.pyi]
[case testAnnotatedAliasTypeVar]
from typing import TypeVar
from typing_extensions import Annotated
T = TypeVar('T')
Alias = Annotated[T, ...]
x: Alias[int]
reveal_type(x) # N: Revealed type is "builtins.int"
[builtins fixtures/tuple.pyi]
[case testAnnotatedAliasGenericTuple]
from typing import TypeVar, Tuple
from typing_extensions import Annotated
T = TypeVar('T')
Alias = Annotated[Tuple[T, T], ...]
x: Alias[int]
reveal_type(x) # N: Revealed type is "tuple[builtins.int, builtins.int]"
[builtins fixtures/tuple.pyi]
[case testAnnotatedAliasGenericUnion]
from typing import TypeVar, Union
from typing_extensions import Annotated
T = TypeVar('T')
Alias = Annotated[Union[T, str], ...]
x: Alias[int]
reveal_type(x) # N: Revealed type is "Union[builtins.int, builtins.str]"
[builtins fixtures/tuple.pyi]
[case testAnnotatedSecondParamNonType]
from typing_extensions import Annotated
class Meta:
...
x = Annotated[int, Meta()]
reveal_type(x) # N: Revealed type is "def () -> builtins.int"
[builtins fixtures/tuple.pyi]
[case testAnnotatedStringLiteralInFunc]
from typing import TypeVar
from typing_extensions import Annotated
def f1(a: Annotated[str, "metadata"]):
pass
reveal_type(f1) # N: Revealed type is "def (a: builtins.str) -> Any"
def f2(a: Annotated["str", "metadata"]):
pass
reveal_type(f2) # N: Revealed type is "def (a: builtins.str) -> Any"
def f3(a: Annotated["notdefined", "metadata"]): # E: Name "notdefined" is not defined
pass
T = TypeVar('T')
def f4(a: Annotated[T, "metadata"]):
pass
reveal_type(f4) # N: Revealed type is "def [T] (a: T`-1) -> Any"
[builtins fixtures/tuple.pyi]
[case testSliceAnnotated]
from typing_extensions import Annotated
a: Annotated[int, 1:2]
reveal_type(a) # N: Revealed type is "builtins.int"
[builtins fixtures/tuple.pyi]
|
