1[case testListTypeAlias]
2from typing import List
3def f() -> List[int]: pass
4[builtins fixtures/list.pyi]
5[out]
6MypyFile:1(
7  ImportFrom:1(typing, [List])
8  FuncDef:2(
9    f
10    def () -> builtins.list[builtins.int]
11    Block:2(
12      PassStmt:2())))
13
14[case testDictTypeAlias]
15from typing import Dict
16def f() -> Dict[int, str]: pass
17[builtins fixtures/dict.pyi]
18[out]
19MypyFile:1(
20  ImportFrom:1(typing, [Dict])
21  FuncDef:2(
22    f
23    def () -> builtins.dict[builtins.int, builtins.str]
24    Block:2(
25      PassStmt:2())))
26
27[case testQualifiedTypeAlias]
28import typing
29def f() -> typing.List[int]: pass
30[builtins fixtures/list.pyi]
31[out]
32MypyFile:1(
33  Import:1(typing)
34  FuncDef:2(
35    f
36    def () -> builtins.list[builtins.int]
37    Block:2(
38      PassStmt:2())))
39
40[case testTypeApplicationWithTypeAlias]
41from typing import List
42List[List[int]]
43[builtins fixtures/list.pyi]
44[out]
45MypyFile:1(
46  ImportFrom:1(typing, [List])
47  ExpressionStmt:2(
48    TypeApplication:2(
49      NameExpr(List [typing.List])
50      Types(
51        builtins.list[builtins.int]))))
52
53[case testTypeApplicationWithQualifiedTypeAlias]
54import typing
55typing.List[typing.List[int]]
56[builtins fixtures/list.pyi]
57[out]
58MypyFile:1(
59  Import:1(typing)
60  ExpressionStmt:2(
61    TypeApplication:2(
62      MemberExpr:2(
63        NameExpr(typing)
64        List [typing.List])
65      Types(
66        builtins.list[builtins.int]))))
67
68[case testSimpleTypeAlias]
69import typing
70class A: pass
71A2 = A
72def f(x: A2) -> A: pass
73[out]
74MypyFile:1(
75  Import:1(typing)
76  ClassDef:2(
77    A
78    PassStmt:2())
79  AssignmentStmt:3(
80    NameExpr(A2* [__main__.A2])
81    NameExpr(A [__main__.A]))
82  FuncDef:4(
83    f
84    Args(
85      Var(x))
86    def (x: __main__.A) -> __main__.A
87    Block:4(
88      PassStmt:4())))
89
90[case testQualifiedSimpleTypeAlias]
91import typing
92import _m
93A2 = _m.A
94x = 1 # type: A2
95[file _m.py]
96import typing
97class A: pass
98[out]
99MypyFile:1(
100  Import:1(typing)
101  Import:2(_m)
102  AssignmentStmt:3(
103    NameExpr(A2* [__main__.A2])
104    MemberExpr:3(
105      NameExpr(_m)
106      A [_m.A]))
107  AssignmentStmt:4(
108    NameExpr(x [__main__.x])
109    IntExpr(1)
110    _m.A))
111
112[case testUnionTypeAlias]
113from typing import Union
114U = Union[int, str]
115def f(x: U) -> None: pass
116[out]
117MypyFile:1(
118  ImportFrom:1(typing, [Union])
119  AssignmentStmt:2(
120    NameExpr(U* [__main__.U])
121    TypeAliasExpr(Union[builtins.int, builtins.str]))
122  FuncDef:3(
123    f
124    Args(
125      Var(x))
126    def (x: Union[builtins.int, builtins.str])
127    Block:3(
128      PassStmt:3())))
129
130[case testUnionTypeAlias2]
131from typing import Union
132class A: pass
133U = Union[int, A]
134def f(x: U) -> None: pass
135[out]
136MypyFile:1(
137  ImportFrom:1(typing, [Union])
138  ClassDef:2(
139    A
140    PassStmt:2())
141  AssignmentStmt:3(
142    NameExpr(U* [__main__.U])
143    TypeAliasExpr(Union[builtins.int, __main__.A]))
144  FuncDef:4(
145    f
146    Args(
147      Var(x))
148    def (x: Union[builtins.int, __main__.A])
149    Block:4(
150      PassStmt:4())))
151
152[case testUnionTypeAliasWithQualifiedUnion]
153import typing
154U = typing.Union[int, str]
155def f(x: U) -> None: pass
156[out]
157MypyFile:1(
158  Import:1(typing)
159  AssignmentStmt:2(
160    NameExpr(U* [__main__.U])
161    TypeAliasExpr(Union[builtins.int, builtins.str]))
162  FuncDef:3(
163    f
164    Args(
165      Var(x))
166    def (x: Union[builtins.int, builtins.str])
167    Block:3(
168      PassStmt:3())))
169
170[case testTupleTypeAlias]
171from typing import Tuple
172T = Tuple[int, str]
173def f(x: T) -> None: pass
174[builtins fixtures/tuple.pyi]
175[out]
176MypyFile:1(
177  ImportFrom:1(typing, [Tuple])
178  AssignmentStmt:2(
179    NameExpr(T* [__main__.T])
180    TypeAliasExpr(Tuple[builtins.int, builtins.str]))
181  FuncDef:3(
182    f
183    Args(
184      Var(x))
185    def (x: Tuple[builtins.int, builtins.str])
186    Block:3(
187      PassStmt:3())))
188
189[case testCallableTypeAlias]
190from typing import Callable
191C = Callable[[int], None]
192def f(x: C) -> None: pass
193[out]
194MypyFile:1(
195  ImportFrom:1(typing, [Callable])
196  AssignmentStmt:2(
197    NameExpr(C* [__main__.C])
198    TypeAliasExpr(def (builtins.int)))
199  FuncDef:3(
200    f
201    Args(
202      Var(x))
203    def (x: def (builtins.int))
204    Block:3(
205      PassStmt:3())))
206
207[case testGenericTypeAlias]
208from typing import Generic, TypeVar
209T = TypeVar('T')
210class G(Generic[T]): pass
211A = G[int]
212def f(x: A) -> None: pass
213[out]
214MypyFile:1(
215  ImportFrom:1(typing, [Generic, TypeVar])
216  AssignmentStmt:2(
217    NameExpr(T* [__main__.T])
218    TypeVarExpr:2())
219  ClassDef:3(
220    G
221    TypeVars(
222      T)
223    PassStmt:3())
224  AssignmentStmt:4(
225    NameExpr(A* [__main__.A])
226    TypeAliasExpr(__main__.G[builtins.int]))
227  FuncDef:5(
228    f
229    Args(
230      Var(x))
231    def (x: __main__.G[builtins.int])
232    Block:5(
233      PassStmt:5())))
234
235[case testGenericTypeAlias2]
236from typing import List
237A = List[int]
238def f(x: A) -> None: pass
239[builtins fixtures/list.pyi]
240[out]
241MypyFile:1(
242  ImportFrom:1(typing, [List])
243  AssignmentStmt:2(
244    NameExpr(A* [__main__.A])
245    TypeAliasExpr(builtins.list[builtins.int]))
246  FuncDef:3(
247    f
248    Args(
249      Var(x))
250    def (x: builtins.list[builtins.int])
251    Block:3(
252      PassStmt:3())))
253
254[case testImportUnionTypeAlias]
255import typing
256from _m import U
257def f(x: U) -> None: pass
258[file _m.py]
259from typing import Union
260class A: pass
261U = Union[int, A]
262[out]
263MypyFile:1(
264  Import:1(typing)
265  ImportFrom:2(_m, [U])
266  FuncDef:3(
267    f
268    Args(
269      Var(x))
270    def (x: Union[builtins.int, _m.A])
271    Block:3(
272      PassStmt:3())))
273
274[case testImportUnionTypeAlias2]
275import typing
276import _m
277def f(x: _m.U) -> None: pass
278[file _m.py]
279from typing import Union
280class A: pass
281U = Union[int, A]
282[out]
283MypyFile:1(
284  Import:1(typing)
285  Import:2(_m)
286  FuncDef:3(
287    f
288    Args(
289      Var(x))
290    def (x: Union[builtins.int, _m.A])
291    Block:3(
292      PassStmt:3())))
293
294[case testImportSimpleTypeAlias]
295import typing
296from _m import A
297def f(x: A) -> None: pass
298[file _m.py]
299import typing
300A = int
301[out]
302MypyFile:1(
303  Import:1(typing)
304  ImportFrom:2(_m, [A])
305  FuncDef:3(
306    f
307    Args(
308      Var(x))
309    def (x: builtins.int)
310    Block:3(
311      PassStmt:3())))
312
313[case testImportSimpleTypeAlias2]
314import typing
315import _m
316def f(x: _m.A) -> None: pass
317[file _m.py]
318import typing
319A = int
320[out]
321MypyFile:1(
322  Import:1(typing)
323  Import:2(_m)
324  FuncDef:3(
325    f
326    Args(
327      Var(x))
328    def (x: builtins.int)
329    Block:3(
330      PassStmt:3())))
331
332[case testAnyTypeAlias]
333from typing import Any
334A = Any
335a = 1 # type: A
336[out]
337MypyFile:1(
338  ImportFrom:1(typing, [Any])
339  AssignmentStmt:2(
340    NameExpr(A* [__main__.A])
341    NameExpr(Any [typing.Any]))
342  AssignmentStmt:3(
343    NameExpr(a [__main__.a])
344    IntExpr(1)
345    Any))
346
347[case testAnyTypeAlias2]
348import typing
349A = typing.Any
350a = 1 # type: A
351[out]
352MypyFile:1(
353  Import:1(typing)
354  AssignmentStmt:2(
355    NameExpr(A* [__main__.A])
356    MemberExpr:2(
357      NameExpr(typing)
358      Any [typing.Any]))
359  AssignmentStmt:3(
360    NameExpr(a [__main__.a])
361    IntExpr(1)
362    Any))
363
364[case testTypeAliasAlias]
365from typing import Union
366U = Union[int, str]
367U2 = U
368x = 1 # type: U2
369[out]
370MypyFile:1(
371  ImportFrom:1(typing, [Union])
372  AssignmentStmt:2(
373    NameExpr(U* [__main__.U])
374    TypeAliasExpr(Union[builtins.int, builtins.str]))
375  AssignmentStmt:3(
376    NameExpr(U2* [__main__.U2])
377    NameExpr(U [__main__.U]))
378  AssignmentStmt:4(
379    NameExpr(x [__main__.x])
380    IntExpr(1)
381    Union[builtins.int, builtins.str]))
382
383[case testTypeAliasOfImportedAlias]
384from typing import Union
385from _m import U
386U2 = U
387x = 1 # type: U2
388[file _m.py]
389from typing import Union
390U = Union[int, str]
391[out]
392MypyFile:1(
393  ImportFrom:1(typing, [Union])
394  ImportFrom:2(_m, [U])
395  AssignmentStmt:3(
396    NameExpr(U2* [__main__.U2])
397    NameExpr(U [_m.U]))
398  AssignmentStmt:4(
399    NameExpr(x [__main__.x])
400    IntExpr(1)
401    Union[builtins.int, builtins.str]))
402
403[case testListTypeDoesNotGenerateAlias]
404
405import typing
406A = [int, str]
407a = 1 # type: A  # E: Variable "__main__.A" is not valid as a type \
408                 # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
409
410[case testCantUseStringLiteralAsTypeAlias]
411
412from typing import Union
413A = 'Union[int, str]'
414a = 1 # type: A  # E: Variable "__main__.A" is not valid as a type \
415                 # N: See https://mypy.readthedocs.io/en/stable/common_issues.html#variables-vs-type-aliases
416
417[case testStringLiteralTypeAsAliasComponent]
418from typing import Union
419A = Union['int', str]
420a = 1 # type: A
421[out]
422MypyFile:1(
423  ImportFrom:1(typing, [Union])
424  AssignmentStmt:2(
425    NameExpr(A* [__main__.A])
426    TypeAliasExpr(Union[builtins.int, builtins.str]))
427  AssignmentStmt:3(
428    NameExpr(a [__main__.a])
429    IntExpr(1)
430    Union[builtins.int, builtins.str]))
431
432[case testComplexTypeAlias]
433from typing import Union, Tuple, Any
434A = Union['int', Tuple[int, Any]]
435a = 1 # type: A
436[builtins fixtures/tuple.pyi]
437[out]
438MypyFile:1(
439  ImportFrom:1(typing, [Union, Tuple, Any])
440  AssignmentStmt:2(
441    NameExpr(A* [__main__.A])
442    TypeAliasExpr(Union[builtins.int, Tuple[builtins.int, Any]]))
443  AssignmentStmt:3(
444    NameExpr(a [__main__.a])
445    IntExpr(1)
446    Union[builtins.int, Tuple[builtins.int, Any]]))
447