| [case testHello] |
| print("hello") |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(print) |
| Args( |
| StrExpr(hello))))) |
| |
| [case testMemberExpr] |
| foo_bar.xyz2 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| MemberExpr:1( |
| NameExpr(foo_bar) |
| xyz2))) |
| |
| [case testTupleExpr] |
| ("a", "b") |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| TupleExpr:1( |
| StrExpr(a) |
| StrExpr(b)))) |
| |
| [case testOpExpr] |
| ("x" + "y") * "z" |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| OpExpr:1( |
| * |
| OpExpr:1( |
| + |
| StrExpr(x) |
| StrExpr(y)) |
| StrExpr(z)))) |
| |
| [case testIntExpr] |
| (0, 1, 2, 203, 5345, 50123, 1234567890, 9982374892739487239847897928374897298374, 0x1950A86A20F9469CFC6C) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| TupleExpr:1( |
| IntExpr(0) |
| IntExpr(1) |
| IntExpr(2) |
| IntExpr(203) |
| IntExpr(5345) |
| IntExpr(50123) |
| IntExpr(1234567890) |
| IntExpr(9982374892739487239847897928374897298374) |
| IntExpr(119547037146038801333356)))) |
| |
| [case testAssignmentStmt] |
| x = 1 |
| a, b = c = 6 |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| IntExpr(1)) |
| AssignmentStmt:2( |
| Lvalues( |
| TupleExpr:2( |
| NameExpr(a) |
| NameExpr(b)) |
| NameExpr(c)) |
| IntExpr(6))) |
| |
| [case testOperatorAssignment] |
| x += 1 |
| y -= 2 |
| z *= 3 |
| [out] |
| MypyFile:1( |
| OperatorAssignmentStmt:1( |
| + |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:2( |
| - |
| NameExpr(y) |
| IntExpr(2)) |
| OperatorAssignmentStmt:3( |
| * |
| NameExpr(z) |
| IntExpr(3))) |
| |
| [case testIfStmt] |
| if x: |
| y |
| if a: |
| b |
| else: |
| c |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| NameExpr(x)) |
| Then( |
| ExpressionStmt:2( |
| NameExpr(y)))) |
| IfStmt:3( |
| If( |
| NameExpr(a)) |
| Then( |
| ExpressionStmt:4( |
| NameExpr(b))) |
| Else( |
| ExpressionStmt:6( |
| NameExpr(c))))) |
| |
| [case testIfStmtElif] |
| if a: |
| b |
| elif c: |
| d |
| else: |
| e |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| NameExpr(a)) |
| Then( |
| ExpressionStmt:2( |
| NameExpr(b))) |
| Else( |
| IfStmt:3( |
| If( |
| NameExpr(c)) |
| Then( |
| ExpressionStmt:4( |
| NameExpr(d))) |
| Else( |
| ExpressionStmt:6( |
| NameExpr(e))))))) |
| |
| [case testIfStmtMultipleElif] |
| if 1: |
| 2 |
| elif 3: |
| 4 |
| elif 5: |
| 6 |
| else: |
| 7 |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| IntExpr(1)) |
| Then( |
| ExpressionStmt:2( |
| IntExpr(2))) |
| Else( |
| IfStmt:3( |
| If( |
| IntExpr(3)) |
| Then( |
| ExpressionStmt:4( |
| IntExpr(4))) |
| Else( |
| IfStmt:5( |
| If( |
| IntExpr(5)) |
| Then( |
| ExpressionStmt:6( |
| IntExpr(6))) |
| Else( |
| ExpressionStmt:8( |
| IntExpr(7))))))))) |
| |
| [case testIfStmtElifNoElse] |
| if a: |
| b |
| elif c: |
| d |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| NameExpr(a)) |
| Then( |
| ExpressionStmt:2( |
| NameExpr(b))) |
| Else( |
| IfStmt:3( |
| If( |
| NameExpr(c)) |
| Then( |
| ExpressionStmt:4( |
| NameExpr(d))))))) |
| |
| [case testWhileStmt] |
| while a: |
| b |
| while c: |
| d |
| else: |
| e |
| [out] |
| MypyFile:1( |
| WhileStmt:1( |
| NameExpr(a) |
| Block:2( |
| ExpressionStmt:2( |
| NameExpr(b)))) |
| WhileStmt:3( |
| NameExpr(c) |
| Block:4( |
| ExpressionStmt:4( |
| NameExpr(d))) |
| Else( |
| ExpressionStmt:6( |
| NameExpr(e))))) |
| |
| [case testIndexExpr] |
| a[b] |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| IndexExpr:1( |
| NameExpr(a) |
| NameExpr(b)))) |
| |
| [case testListAndSetExpr] |
| a = [] |
| b = [1, 2] |
| c = {3} |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| ListExpr:1()) |
| AssignmentStmt:2( |
| NameExpr(b) |
| ListExpr:2( |
| IntExpr(1) |
| IntExpr(2))) |
| AssignmentStmt:3( |
| NameExpr(c) |
| SetExpr:3( |
| IntExpr(3)))) |
| |
| [case testBoolOpAnd] |
| a and b |
| a and b and c |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| OpExpr:1( |
| and |
| NameExpr(a) |
| NameExpr(b))) |
| ExpressionStmt:2( |
| OpExpr:2( |
| and |
| OpExpr:2( |
| and |
| NameExpr(a) |
| NameExpr(b)) |
| NameExpr(c)))) |
| |
| [case testBoolOpOr] |
| x or y |
| 1 or 2 or 3 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| OpExpr:1( |
| or |
| NameExpr(x) |
| NameExpr(y))) |
| ExpressionStmt:2( |
| OpExpr:2( |
| or |
| OpExpr:2( |
| or |
| IntExpr(1) |
| IntExpr(2)) |
| IntExpr(3)))) |
| |
| [case testComparisonSimple] |
| a < b |
| x == y |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| ComparisonExpr:1( |
| < |
| NameExpr(a) |
| NameExpr(b))) |
| ExpressionStmt:2( |
| ComparisonExpr:2( |
| == |
| NameExpr(x) |
| NameExpr(y)))) |
| |
| [case testComparisonChained] |
| a < b < c |
| x == y != z |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| ComparisonExpr:1( |
| < |
| < |
| NameExpr(a) |
| NameExpr(b) |
| NameExpr(c))) |
| ExpressionStmt:2( |
| ComparisonExpr:2( |
| == |
| != |
| NameExpr(x) |
| NameExpr(y) |
| NameExpr(z)))) |
| |
| [case testComparisonIsNotIn] |
| a is b |
| x is not y |
| z in w |
| q not in r |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| ComparisonExpr:1( |
| is |
| NameExpr(a) |
| NameExpr(b))) |
| ExpressionStmt:2( |
| ComparisonExpr:2( |
| is not |
| NameExpr(x) |
| NameExpr(y))) |
| ExpressionStmt:3( |
| ComparisonExpr:3( |
| in |
| NameExpr(z) |
| NameExpr(w))) |
| ExpressionStmt:4( |
| ComparisonExpr:4( |
| not in |
| NameExpr(q) |
| NameExpr(r)))) |
| |
| [case testLiterals] |
| (None, True, False, ...) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| TupleExpr:1( |
| NameExpr(None) |
| NameExpr(True) |
| NameExpr(False) |
| Ellipsis))) |
| |
| [case testSimpleFunction] |
| def foo(): |
| x = 1 |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| foo |
| Block:2( |
| AssignmentStmt:2( |
| NameExpr(x) |
| IntExpr(1))))) |
| |
| [case testFunctionWithArgs] |
| def add(x, y): |
| return x + y |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| add |
| Args( |
| Var(x) |
| Var(y)) |
| Block:2( |
| ReturnStmt:2( |
| OpExpr:2( |
| + |
| NameExpr(x) |
| NameExpr(y)))))) |
| |
| [case testFunctionWithVarArgs] |
| def foo(*args): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| foo |
| VarArg( |
| Var(args)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testFunctionWithKwargs] |
| def bar(**kwargs): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| bar |
| DictVarArg( |
| Var(kwargs)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testFunctionWithKwOnly] |
| def baz(x, *, y): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| baz |
| MaxPos(1) |
| Args( |
| Var(x) |
| Var(y)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testFunctionWithAllArgKinds] |
| def complex_fn(a, b, *args, c, **kwargs): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| complex_fn |
| MaxPos(2) |
| Args( |
| Var(a) |
| Var(b) |
| Var(c)) |
| VarArg( |
| Var(args)) |
| DictVarArg( |
| Var(kwargs)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testAsyncFunction] |
| async def async_foo(): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| async_foo |
| Async |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testFunctionWithDefaultArg] |
| def greet(name="World"): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| greet |
| Args( |
| default( |
| Var(name) |
| StrExpr(World))) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testFunctionWithMultipleDefaults] |
| def add(x=1, y=2): |
| return x |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| add |
| Args( |
| default( |
| Var(x) |
| IntExpr(1)) |
| default( |
| Var(y) |
| IntExpr(2))) |
| Block:2( |
| ReturnStmt:2( |
| NameExpr(x))))) |
| |
| [case testFunctionMixedDefaultsAndRegular] |
| def func(a, b=5, c=10): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| func |
| Args( |
| Var(a) |
| default( |
| Var(b) |
| IntExpr(5)) |
| default( |
| Var(c) |
| IntExpr(10))) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testFunctionWithKwOnlyDefault] |
| def func(*, x=42): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| func |
| MaxPos(0) |
| Args( |
| default( |
| Var(x) |
| IntExpr(42))) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testCallWithKeywordArgs] |
| foo(x=1, y=2) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(foo) |
| Args() |
| KwArgs( |
| x |
| IntExpr(1)) |
| KwArgs( |
| y |
| IntExpr(2))))) |
| |
| [case testCallMixedPositionalAndKeyword] |
| bar(1, 2, x=3, y=4) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(bar) |
| Args( |
| IntExpr(1) |
| IntExpr(2)) |
| KwArgs( |
| x |
| IntExpr(3)) |
| KwArgs( |
| y |
| IntExpr(4))))) |
| |
| [case testCallWithStarArgs] |
| f(1, *x, 2) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(f) |
| Args( |
| IntExpr(1) |
| NameExpr(x) |
| IntExpr(2)) |
| VarArg))) |
| |
| [case testCallWithDictStarArgs] |
| f(**x) |
| f(1, **y) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(f) |
| Args() |
| DictVarArg( |
| NameExpr(x)))) |
| ExpressionStmt:2( |
| CallExpr:2( |
| NameExpr(f) |
| Args( |
| IntExpr(1)) |
| DictVarArg( |
| NameExpr(y))))) |
| |
| [case testCallWithAllArgTypes] |
| f(1, *x, a=2, **y) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(f) |
| Args( |
| IntExpr(1) |
| NameExpr(x)) |
| VarArg |
| KwArgs( |
| a |
| IntExpr(2)) |
| DictVarArg( |
| NameExpr(y))))) |
| |
| [case testSimpleClass] |
| class A: |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| PassStmt:2())) |
| |
| [case testClassWithMethod] |
| class Foo: |
| def bar(self): |
| return 1 |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| Foo |
| FuncDef:2( |
| bar |
| Args( |
| Var(self)) |
| Block:3( |
| ReturnStmt:3( |
| IntExpr(1)))))) |
| |
| [case testClassWithSingleBase] |
| class A(B): |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| BaseTypeExpr( |
| NameExpr(B)) |
| PassStmt:2())) |
| |
| [case testClassWithMultipleBases] |
| class Child(Base1, Base2): |
| x = 1 |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| Child |
| BaseTypeExpr( |
| NameExpr(Base1) |
| NameExpr(Base2)) |
| AssignmentStmt:2( |
| NameExpr(x) |
| IntExpr(1)))) |
| |
| [case testFloatLiteral] |
| x = 3.14 |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| FloatExpr(3.14))) |
| |
| [case testUnaryExpressions] |
| -x |
| +y |
| ~z |
| not w |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| UnaryExpr:1( |
| - |
| NameExpr(x))) |
| ExpressionStmt:2( |
| UnaryExpr:2( |
| + |
| NameExpr(y))) |
| ExpressionStmt:3( |
| UnaryExpr:3( |
| ~ |
| NameExpr(z))) |
| ExpressionStmt:4( |
| UnaryExpr:4( |
| not |
| NameExpr(w)))) |
| |
| [case testDictionaryExpression] |
| {} |
| {1:x} |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| DictExpr:1()) |
| ExpressionStmt:2( |
| DictExpr:2( |
| IntExpr(1) |
| NameExpr(x)))) |
| |
| [case testComplexLiteral] |
| 1j |
| 2.5j |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| ComplexExpr(1j)) |
| ExpressionStmt:2( |
| ComplexExpr(2.5j))) |
| |
| [case testSlices] |
| x[1:2] |
| x[:1] |
| x[1:] |
| x[:] |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| IndexExpr:1( |
| NameExpr(x) |
| SliceExpr:1( |
| IntExpr(1) |
| IntExpr(2)))) |
| ExpressionStmt:2( |
| IndexExpr:2( |
| NameExpr(x) |
| SliceExpr:2( |
| <empty> |
| IntExpr(1)))) |
| ExpressionStmt:3( |
| IndexExpr:3( |
| NameExpr(x) |
| SliceExpr:3( |
| IntExpr(1) |
| <empty>))) |
| ExpressionStmt:4( |
| IndexExpr:4( |
| NameExpr(x) |
| SliceExpr:4( |
| <empty> |
| <empty>)))) |
| |
| [case testSliceWithStride] |
| x[1:2:3] |
| x[1::2] |
| x[:1:2] |
| x[::2] |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| IndexExpr:1( |
| NameExpr(x) |
| SliceExpr:1( |
| IntExpr(1) |
| IntExpr(2) |
| IntExpr(3)))) |
| ExpressionStmt:2( |
| IndexExpr:2( |
| NameExpr(x) |
| SliceExpr:2( |
| IntExpr(1) |
| <empty> |
| IntExpr(2)))) |
| ExpressionStmt:3( |
| IndexExpr:3( |
| NameExpr(x) |
| SliceExpr:3( |
| <empty> |
| IntExpr(1) |
| IntExpr(2)))) |
| ExpressionStmt:4( |
| IndexExpr:4( |
| NameExpr(x) |
| SliceExpr:4( |
| <empty> |
| <empty> |
| IntExpr(2))))) |
| |
| [case testFunctionSignature] |
| def f() -> int: |
| pass |
| def g() -> None: |
| pass |
| def h(x: foo.bar, y, z: x.y.z): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| def () -> int? |
| Block:2( |
| PassStmt:2())) |
| FuncDef:3( |
| g |
| def () -> None? |
| Block:4( |
| PassStmt:4())) |
| FuncDef:5( |
| h |
| Args( |
| Var(x) |
| Var(y) |
| Var(z)) |
| def (x: foo.bar?, y: Any, z: x.y.z?) -> Any |
| Block:6( |
| PassStmt:6()))) |
| |
| [case testFunctionSignature2] |
| def f(x: a[b]) -> c.d[e.f.g[h], i]: |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| def (x: a?[b?]) -> c.d?[e.f.g?[h?], i?] |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testUnionTypes] |
| def f(x: int | str) -> bool | None: |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| def (x: int? | str?) -> bool? | None? |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testAnnotatedAssignment] |
| x: int |
| y: str = "hello" |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| TempNode:1( |
| Any) |
| int?) |
| AssignmentStmt:2( |
| NameExpr(y) |
| StrExpr(hello) |
| str?)) |
| |
| [case testImportStatements] |
| import x |
| import a, b |
| import y as z |
| [out] |
| MypyFile:1( |
| Import:1(x) |
| Import:2(a, b) |
| Import:3(y : z)) |
| |
| [case testImportFromStatements] |
| from os import path |
| from sys import argv, exit |
| from typing import List as L |
| from . import foo |
| from .. import bar |
| from .pkg import baz |
| [out] |
| MypyFile:1( |
| ImportFrom:1(os, [path]) |
| ImportFrom:2(sys, [argv, exit]) |
| ImportFrom:3(typing, [List : L]) |
| ImportFrom:4(., [foo]) |
| ImportFrom:5(.., [bar]) |
| ImportFrom:6(.pkg, [baz])) |
| |
| [case testImportAllStatements] |
| from os import * |
| from . import * |
| from .. import * |
| from .pkg import * |
| [out] |
| MypyFile:1( |
| ImportAll:1(os) |
| ImportAll:2(.) |
| ImportAll:3(..) |
| ImportAll:4(.pkg)) |
| |
| [case testRaiseStatements] |
| raise |
| raise ValueError |
| raise ValueError("error message") |
| raise KeyError from e |
| [out] |
| MypyFile:1( |
| RaiseStmt:1() |
| RaiseStmt:2( |
| NameExpr(ValueError)) |
| RaiseStmt:3( |
| CallExpr:3( |
| NameExpr(ValueError) |
| Args( |
| StrExpr(error message)))) |
| RaiseStmt:4( |
| NameExpr(KeyError) |
| NameExpr(e))) |
| |
| [case testAssertStatements] |
| assert x |
| assert x == y |
| assert condition, "error message" |
| [out] |
| MypyFile:1( |
| AssertStmt:1( |
| NameExpr(x)) |
| AssertStmt:2( |
| ComparisonExpr:2( |
| == |
| NameExpr(x) |
| NameExpr(y))) |
| AssertStmt:3( |
| NameExpr(condition) |
| StrExpr(error message))) |
| |
| [case testForStatements] |
| for x in items: |
| pass |
| for i, j in pairs: |
| x = 1 |
| for y in range(10): |
| break |
| else: |
| continue |
| [out] |
| MypyFile:1( |
| ForStmt:1( |
| NameExpr(x) |
| NameExpr(items) |
| Block:2( |
| PassStmt:2())) |
| ForStmt:3( |
| TupleExpr:3( |
| NameExpr(i) |
| NameExpr(j)) |
| NameExpr(pairs) |
| Block:4( |
| AssignmentStmt:4( |
| NameExpr(x) |
| IntExpr(1)))) |
| ForStmt:5( |
| NameExpr(y) |
| CallExpr:5( |
| NameExpr(range) |
| Args( |
| IntExpr(10))) |
| Block:6( |
| BreakStmt:6()) |
| Else( |
| ContinueStmt:8()))) |
| |
| [case testWithStatements] |
| with f: |
| pass |
| with open("file") as f: |
| x = 1 |
| with a as x, b as y: |
| break |
| [out] |
| MypyFile:1( |
| WithStmt:1( |
| Expr( |
| NameExpr(f)) |
| Block:2( |
| PassStmt:2())) |
| WithStmt:3( |
| Expr( |
| CallExpr:3( |
| NameExpr(open) |
| Args( |
| StrExpr(file)))) |
| Target( |
| NameExpr(f)) |
| Block:4( |
| AssignmentStmt:4( |
| NameExpr(x) |
| IntExpr(1)))) |
| WithStmt:5( |
| Expr( |
| NameExpr(a)) |
| Target( |
| NameExpr(x)) |
| Expr( |
| NameExpr(b)) |
| Target( |
| NameExpr(y)) |
| Block:6( |
| BreakStmt:6()))) |
| |
| [case testBreakAndContinue] |
| while True: |
| break |
| while x: |
| continue |
| while y: |
| if z: |
| break |
| else: |
| continue |
| [out] |
| MypyFile:1( |
| WhileStmt:1( |
| NameExpr(True) |
| Block:2( |
| BreakStmt:2())) |
| WhileStmt:3( |
| NameExpr(x) |
| Block:4( |
| ContinueStmt:4())) |
| WhileStmt:5( |
| NameExpr(y) |
| Block:6( |
| IfStmt:6( |
| If( |
| NameExpr(z)) |
| Then( |
| BreakStmt:7()) |
| Else( |
| ContinueStmt:9()))))) |
| |
| [case testGeneratorExpressions] |
| (x for x in items) |
| (x * 2 for x in range(10) if x > 5) |
| (x + y for x in range(3) for y in range(2)) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| GeneratorExpr:1( |
| NameExpr(x) |
| NameExpr(x) |
| NameExpr(items))) |
| ExpressionStmt:2( |
| GeneratorExpr:2( |
| OpExpr:2( |
| * |
| NameExpr(x) |
| IntExpr(2)) |
| NameExpr(x) |
| CallExpr:2( |
| NameExpr(range) |
| Args( |
| IntExpr(10))) |
| ComparisonExpr:2( |
| > |
| NameExpr(x) |
| IntExpr(5)))) |
| ExpressionStmt:3( |
| GeneratorExpr:3( |
| OpExpr:3( |
| + |
| NameExpr(x) |
| NameExpr(y)) |
| NameExpr(x) |
| NameExpr(y) |
| CallExpr:3( |
| NameExpr(range) |
| Args( |
| IntExpr(3))) |
| CallExpr:3( |
| NameExpr(range) |
| Args( |
| IntExpr(2)))))) |
| |
| [case testYieldExpressions] |
| def gen(): |
| yield |
| yield 1 |
| yield from items |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| gen |
| Block:2( |
| ExpressionStmt:2( |
| YieldExpr:2()) |
| ExpressionStmt:3( |
| YieldExpr:3( |
| IntExpr(1))) |
| ExpressionStmt:4( |
| YieldFromExpr:4( |
| NameExpr(items)))))) |
| |
| [case testListAndSetComprehensions] |
| a = [x for x in items] |
| b = [x * 2 for x in range(10) if x > 5] |
| c = {y for y in data} |
| d = {z + 1 for z in nums if z < 100} |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| ListComprehension:1( |
| GeneratorExpr:1( |
| NameExpr(x) |
| NameExpr(x) |
| NameExpr(items)))) |
| AssignmentStmt:2( |
| NameExpr(b) |
| ListComprehension:2( |
| GeneratorExpr:2( |
| OpExpr:2( |
| * |
| NameExpr(x) |
| IntExpr(2)) |
| NameExpr(x) |
| CallExpr:2( |
| NameExpr(range) |
| Args( |
| IntExpr(10))) |
| ComparisonExpr:2( |
| > |
| NameExpr(x) |
| IntExpr(5))))) |
| AssignmentStmt:3( |
| NameExpr(c) |
| SetComprehension:3( |
| GeneratorExpr:3( |
| NameExpr(y) |
| NameExpr(y) |
| NameExpr(data)))) |
| AssignmentStmt:4( |
| NameExpr(d) |
| SetComprehension:4( |
| GeneratorExpr:4( |
| OpExpr:4( |
| + |
| NameExpr(z) |
| IntExpr(1)) |
| NameExpr(z) |
| NameExpr(nums) |
| ComparisonExpr:4( |
| < |
| NameExpr(z) |
| IntExpr(100)))))) |
| |
| [case testDictComprehensions] |
| a = {k: v for k, v in items} |
| b = {x: x * 2 for x in range(10) if x > 5} |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| DictionaryComprehension:1( |
| NameExpr(k) |
| NameExpr(v) |
| TupleExpr:1( |
| NameExpr(k) |
| NameExpr(v)) |
| NameExpr(items))) |
| AssignmentStmt:2( |
| NameExpr(b) |
| DictionaryComprehension:2( |
| NameExpr(x) |
| OpExpr:2( |
| * |
| NameExpr(x) |
| IntExpr(2)) |
| NameExpr(x) |
| CallExpr:2( |
| NameExpr(range) |
| Args( |
| IntExpr(10))) |
| ComparisonExpr:2( |
| > |
| NameExpr(x) |
| IntExpr(5))))) |
| |
| [case testDecoratedFuncDef] |
| @dec |
| def foo(): |
| pass |
| class C: |
| @dec() |
| @staticmethod |
| def foo(): |
| pass |
| [out] |
| MypyFile:1( |
| Decorator:1( |
| Var(foo) |
| NameExpr(dec) |
| FuncDef:2( |
| foo |
| Block:3( |
| PassStmt:3()))) |
| ClassDef:4( |
| C |
| Decorator:5( |
| Var(foo) |
| CallExpr:5( |
| NameExpr(dec) |
| Args()) |
| NameExpr(staticmethod) |
| FuncDef:7( |
| foo |
| Block:8( |
| PassStmt:8()))))) |
| [case testTryFinally] |
| try: |
| x |
| finally: |
| y |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| NameExpr(x))) |
| Finally( |
| ExpressionStmt:4( |
| NameExpr(y))))) |
| |
| [case testTryExcept] |
| try: |
| x |
| except Exception: |
| y |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| NameExpr(x))) |
| NameExpr(Exception) |
| Block:4( |
| ExpressionStmt:4( |
| NameExpr(y))))) |
| |
| [case testTryExceptWithVar] |
| try: |
| x |
| except Exception as e: |
| y |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| NameExpr(x))) |
| NameExpr(Exception) |
| NameExpr(e) |
| Block:4( |
| ExpressionStmt:4( |
| NameExpr(y))))) |
| |
| [case testTryExceptElse] |
| try: |
| x |
| except Exception: |
| y |
| else: |
| z |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| NameExpr(x))) |
| NameExpr(Exception) |
| Block:4( |
| ExpressionStmt:4( |
| NameExpr(y))) |
| Else( |
| ExpressionStmt:6( |
| NameExpr(z))))) |
| |
| [case testTryMultipleExcept] |
| try: |
| x |
| except ValueError: |
| y |
| except KeyError as e: |
| z |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| NameExpr(x))) |
| NameExpr(ValueError) |
| Block:4( |
| ExpressionStmt:4( |
| NameExpr(y))) |
| NameExpr(KeyError) |
| NameExpr(e) |
| Block:6( |
| ExpressionStmt:6( |
| NameExpr(z))))) |
| |
| [case testTryExceptStar] |
| try: |
| x |
| except* ValueError: |
| y |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| NameExpr(x))) |
| * |
| NameExpr(ValueError) |
| Block:4( |
| ExpressionStmt:4( |
| NameExpr(y))))) |
| |
| [case testTryExceptStarWithVar] |
| try: |
| x |
| except* Exception as e: |
| y |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| NameExpr(x))) |
| * |
| NameExpr(Exception) |
| NameExpr(e) |
| Block:4( |
| ExpressionStmt:4( |
| NameExpr(y))))) |
| |
| [case testTryMultipleExceptStar] |
| try: |
| x |
| except* ValueError: |
| y |
| except* KeyError as e: |
| z |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| NameExpr(x))) |
| * |
| NameExpr(ValueError) |
| Block:4( |
| ExpressionStmt:4( |
| NameExpr(y))) |
| NameExpr(KeyError) |
| NameExpr(e) |
| Block:6( |
| ExpressionStmt:6( |
| NameExpr(z))))) |
| |
| [case testTryExceptStarElseFinally] |
| try: |
| x |
| except* ValueError: |
| y |
| else: |
| z |
| finally: |
| w |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| NameExpr(x))) |
| * |
| NameExpr(ValueError) |
| Block:4( |
| ExpressionStmt:4( |
| NameExpr(y))) |
| Else( |
| ExpressionStmt:6( |
| NameExpr(z))) |
| Finally( |
| ExpressionStmt:8( |
| NameExpr(w))))) |
| |
| [case testConditionalExprSimple] |
| x if y else z |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| ConditionalExpr:1( |
| Condition( |
| NameExpr(y)) |
| NameExpr(x) |
| NameExpr(z)))) |
| |
| [case testFunctionWithCallableType] |
| def f(x: Callable[[int, str], None]) -> None: |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| def (x: Callable?[<TypeList int?, str?>, None?]) -> None? |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testFunctionWithEmptyCallableType] |
| def g(callback: Callable[[], bool]) -> int: |
| return 1 |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| g |
| Args( |
| Var(callback)) |
| def (callback: Callable?[<TypeList >, bool?]) -> int? |
| Block:2( |
| ReturnStmt:2( |
| IntExpr(1))))) |
| |
| [case testFunctionWithComplexCallableType] |
| def h(f: Callable[[List[int], Dict[str, int]], Tuple[int, str]]) -> None: |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| h |
| Args( |
| Var(f)) |
| def (f: Callable?[<TypeList List?[int?], Dict?[str?, int?]>, Tuple?[int?, str?]]) -> None? |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testFunctionWithEllipsisCallableType] |
| def f(callback: Callable[..., int]) -> None: |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(callback)) |
| def (callback: Callable?[..., int?]) -> None? |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testCallableWithArgConstructor] |
| from typing import Callable |
| from mypy_extensions import Arg |
| def f(x: Callable[[Arg(int, 'x'), Arg(str, 'y')], bool]) -> None: |
| pass |
| [out] |
| MypyFile:1( |
| ImportFrom:1(typing, [Callable]) |
| ImportFrom:2(mypy_extensions, [Arg]) |
| FuncDef:3( |
| f |
| Args( |
| Var(x)) |
| def (x: Callable?[<TypeList Arg(int?, x), Arg(str?, y)>, bool?]) -> None? |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testCallableWithArgConstructorKeywordSyntax] |
| from typing import Callable |
| from mypy_extensions import Arg |
| def f(callback: Callable[[Arg(type=int, name='value')], str]) -> None: |
| pass |
| [out] |
| MypyFile:1( |
| ImportFrom:1(typing, [Callable]) |
| ImportFrom:2(mypy_extensions, [Arg]) |
| FuncDef:3( |
| f |
| Args( |
| Var(callback)) |
| def (callback: Callable?[<TypeList Arg(int?, value)>, str?]) -> None? |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testCallableWithArgNoName] |
| from typing import Callable |
| from mypy_extensions import Arg |
| def f(x: Callable[[Arg(int)], bool]) -> None: |
| pass |
| [out] |
| MypyFile:1( |
| ImportFrom:1(typing, [Callable]) |
| ImportFrom:2(mypy_extensions, [Arg]) |
| FuncDef:3( |
| f |
| Args( |
| Var(x)) |
| def (x: Callable?[<TypeList Arg(int?)>, bool?]) -> None? |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testLiteralTypes] |
| x: Literal[True, False] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| TempNode:1( |
| Any) |
| Literal?[True, False])) |
| |
| [case testLiteralIntTypes] |
| x: Literal[1] |
| y: Literal[1, 2, 3] |
| z: Literal[-1] |
| w: Literal[-1, 0, 1] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| TempNode:1( |
| Any) |
| Literal?[1]) |
| AssignmentStmt:2( |
| NameExpr(y) |
| TempNode:2( |
| Any) |
| Literal?[1, 2, 3]) |
| AssignmentStmt:3( |
| NameExpr(z) |
| TempNode:3( |
| Any) |
| Literal?[-1]) |
| AssignmentStmt:4( |
| NameExpr(w) |
| TempNode:4( |
| Any) |
| Literal?[-1, 0, 1])) |
| |
| [case testDelStmt] |
| del x |
| del x[0], y[1] |
| del a.b |
| [out] |
| MypyFile:1( |
| DelStmt:1( |
| NameExpr(x)) |
| DelStmt:2( |
| TupleExpr:2( |
| IndexExpr:2( |
| NameExpr(x) |
| IntExpr(0)) |
| IndexExpr:2( |
| NameExpr(y) |
| IntExpr(1)))) |
| DelStmt:3( |
| MemberExpr:3( |
| NameExpr(a) |
| b))) |
| |
| [case testFString] |
| f"foo {x}" |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| MemberExpr:1( |
| StrExpr() |
| join) |
| Args( |
| ListExpr:1( |
| StrExpr(foo ) |
| CallExpr:1( |
| MemberExpr:1( |
| StrExpr({:{}}) |
| format) |
| Args( |
| NameExpr(x) |
| StrExpr()))))))) |
| |
| [case testFStringWithConversion] |
| x = 'mypy' |
| F'Hello {x!r}' |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| StrExpr(mypy)) |
| ExpressionStmt:2( |
| CallExpr:2( |
| MemberExpr:2( |
| StrExpr() |
| join) |
| Args( |
| ListExpr:2( |
| StrExpr(Hello ) |
| CallExpr:2( |
| MemberExpr:2( |
| StrExpr({!r:{}}) |
| format) |
| Args( |
| NameExpr(x) |
| StrExpr()))))))) |
| |
| [case testFStringTrivial] |
| f"foo" |
| f"{x}" |
| f"foo" "bar" |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StrExpr(foo)) |
| ExpressionStmt:2( |
| CallExpr:2( |
| MemberExpr:2( |
| StrExpr({:{}}) |
| format) |
| Args( |
| NameExpr(x) |
| StrExpr()))) |
| ExpressionStmt:3( |
| StrExpr(foobar))) |
| |
| [case testFStringWithOnlyFormatSpecifier] |
| x = 'mypy' |
| f'Hello {x:<30}' |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| StrExpr(mypy)) |
| ExpressionStmt:2( |
| CallExpr:2( |
| MemberExpr:2( |
| StrExpr() |
| join) |
| Args( |
| ListExpr:2( |
| StrExpr(Hello ) |
| CallExpr:2( |
| MemberExpr:2( |
| StrExpr({:{}}) |
| format) |
| Args( |
| NameExpr(x) |
| StrExpr(<30)))))))) |
| |
| [case testFStringWithFormatSpecifierExpression] |
| x = 'mypy' |
| y = 30 |
| f'Hello {x!s:<{y+y}}' |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| StrExpr(mypy)) |
| AssignmentStmt:2( |
| NameExpr(y) |
| IntExpr(30)) |
| ExpressionStmt:3( |
| CallExpr:3( |
| MemberExpr:3( |
| StrExpr() |
| join) |
| Args( |
| ListExpr:3( |
| StrExpr(Hello ) |
| CallExpr:3( |
| MemberExpr:3( |
| StrExpr({!s:{}}) |
| format) |
| Args( |
| NameExpr(x) |
| CallExpr:3( |
| MemberExpr:3( |
| StrExpr() |
| join) |
| Args( |
| ListExpr:3( |
| StrExpr(<) |
| CallExpr:3( |
| MemberExpr:3( |
| StrExpr({:{}}) |
| format) |
| Args( |
| OpExpr:3( |
| + |
| NameExpr(y) |
| NameExpr(y)) |
| StrExpr())))))))))))) |
| |
| [case testSimpleLambda] |
| lambda: 1 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| LambdaExpr:1( |
| Block:1( |
| ReturnStmt:1( |
| IntExpr(1)))))) |
| |
| [case testLambdaWithOneArg] |
| lambda x: y + 1 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| LambdaExpr:1( |
| Args( |
| Var(x)) |
| Block:1( |
| ReturnStmt:1( |
| OpExpr:1( |
| + |
| NameExpr(y) |
| IntExpr(1))))))) |
| |
| [case testLambdaWithMultipleArgs] |
| lambda x, y: x + y |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| LambdaExpr:1( |
| Args( |
| Var(x) |
| Var(y)) |
| Block:1( |
| ReturnStmt:1( |
| OpExpr:1( |
| + |
| NameExpr(x) |
| NameExpr(y))))))) |
| |
| [case testLambdaWithDefault] |
| lambda x=2: x |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| LambdaExpr:1( |
| Args( |
| default( |
| Var(x) |
| IntExpr(2))) |
| Block:1( |
| ReturnStmt:1( |
| NameExpr(x)))))) |
| |
| [case testLambdaInCall] |
| map(lambda x: x * 2, items) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(map) |
| Args( |
| LambdaExpr:1( |
| Args( |
| Var(x)) |
| Block:1( |
| ReturnStmt:1( |
| OpExpr:1( |
| * |
| NameExpr(x) |
| IntExpr(2))))) |
| NameExpr(items))))) |
| |
| [case testNamedExprSimple] |
| if (x := 1): |
| pass |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| AssignmentExpr:1( |
| NameExpr(x) |
| IntExpr(1))) |
| Then( |
| PassStmt:2()))) |
| |
| [case testStarExpression] |
| *a |
| *a, b |
| a, *b |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StarExpr:1( |
| NameExpr(a))) |
| ExpressionStmt:2( |
| TupleExpr:2( |
| StarExpr:2( |
| NameExpr(a)) |
| NameExpr(b))) |
| ExpressionStmt:3( |
| TupleExpr:3( |
| NameExpr(a) |
| StarExpr:3( |
| NameExpr(b))))) |
| |
| [case testBytesLiteral] |
| b"foo" |
| b"foobar" |
| b"x\\n\\'" |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| BytesExpr(foo)) |
| ExpressionStmt:2( |
| BytesExpr(foobar)) |
| ExpressionStmt:3( |
| BytesExpr(x\\n\\\'))) |
| |
| [case testBytesLiteralWithEscapes] |
| b'\r\n\t\x2f\xbe' |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| BytesExpr(\r\n\t/\xbe))) |
| |
| [case testBytesLiteralOctalEscapes] |
| b'\1\476' |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| BytesExpr(\x01>))) |
| [case testGlobalAndNonlocal] |
| x = 1 |
| y = 2 |
| def outer(): |
| global x |
| def inner(): |
| nonlocal y |
| global z |
| y = 3 |
| z = 4 |
| x = 5 |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| IntExpr(1)) |
| AssignmentStmt:2( |
| NameExpr(y) |
| IntExpr(2)) |
| FuncDef:3( |
| outer |
| Block:4( |
| GlobalDecl:4( |
| x) |
| FuncDef:5( |
| inner |
| Block:6( |
| NonlocalDecl:6( |
| y) |
| GlobalDecl:7( |
| z) |
| AssignmentStmt:8( |
| NameExpr(y) |
| IntExpr(3)) |
| AssignmentStmt:9( |
| NameExpr(z) |
| IntExpr(4)))) |
| AssignmentStmt:10( |
| NameExpr(x) |
| IntExpr(5))))) |
| [case testAwaitExpression] |
| async def foo(): |
| x = await bar() |
| return await baz(x) |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| foo |
| Async |
| Block:2( |
| AssignmentStmt:2( |
| NameExpr(x) |
| AwaitExpr:2( |
| CallExpr:2( |
| NameExpr(bar) |
| Args()))) |
| ReturnStmt:3( |
| AwaitExpr:3( |
| CallExpr:3( |
| NameExpr(baz) |
| Args( |
| NameExpr(x)))))))) |
| |
| [case testFunctionOverload] |
| @overload |
| def f() -> x: pass |
| @overload |
| def f() -> y: pass |
| [out] |
| MypyFile:1( |
| OverloadedFuncDef:1( |
| Decorator:1( |
| Var(f) |
| NameExpr(overload) |
| FuncDef:2( |
| f |
| def () -> x? |
| Block:2( |
| PassStmt:2()))) |
| Decorator:3( |
| Var(f) |
| NameExpr(overload) |
| FuncDef:4( |
| f |
| def () -> y? |
| Block:4( |
| PassStmt:4()))))) |
| |
| [case testFunctionOverloadWithImplementation] |
| @overload |
| def f(a: x) -> x: ... |
| @overload |
| def f(a: y) -> y: ... |
| def f(a): pass |
| [out] |
| MypyFile:1( |
| OverloadedFuncDef:1( |
| Decorator:1( |
| Var(f) |
| NameExpr(overload) |
| FuncDef:2( |
| f |
| Args( |
| Var(a)) |
| def (a: x?) -> x? |
| Block:2( |
| ExpressionStmt:2( |
| Ellipsis)))) |
| Decorator:3( |
| Var(f) |
| NameExpr(overload) |
| FuncDef:4( |
| f |
| Args( |
| Var(a)) |
| def (a: y?) -> y? |
| Block:4( |
| ExpressionStmt:4( |
| Ellipsis)))) |
| FuncDef:5( |
| f |
| Args( |
| Var(a)) |
| Block:5( |
| PassStmt:5())))) |
| |
| [case testTypeIgnores] |
| x = 1 # type: ignore |
| y = ( |
| 2 # type: ignore # Comment |
| ) |
| y = 1 # foo: ignore |
| z = 1 #type: ignore[x] |
| zz = 1 #type: ignore [ foo, arg-type ] |
| [out] |
| ignore: 1 |
| ignore: 3 |
| ignore: 6 [x] |
| ignore: 7 [foo, arg-type] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| IntExpr(1)) |
| AssignmentStmt:2( |
| NameExpr(y) |
| IntExpr(2)) |
| AssignmentStmt:5( |
| NameExpr(y) |
| IntExpr(1)) |
| AssignmentStmt:6( |
| NameExpr(z) |
| IntExpr(1)) |
| AssignmentStmt:7( |
| NameExpr(zz) |
| IntExpr(1))) |
| |
| [case testMetaclass] |
| class Foo(metaclass=Bar): pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| Foo |
| Metaclass(NameExpr(Bar)) |
| PassStmt:1())) |
| |
| [case testClassWithKeywordArgs] |
| class Foo(_root=None, total=False): pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| Foo |
| Keywords(_root=NameExpr(None), total=NameExpr(False)) |
| PassStmt:1())) |
| |
| [case testClassDecorator] |
| @foo |
| class X: pass |
| @foo(bar) |
| @x.y |
| class Z: pass |
| [out] |
| MypyFile:1( |
| ClassDef:2( |
| X |
| Decorators( |
| NameExpr(foo)) |
| PassStmt:2()) |
| ClassDef:5( |
| Z |
| Decorators( |
| CallExpr:3( |
| NameExpr(foo) |
| Args( |
| NameExpr(bar))) |
| MemberExpr:4( |
| NameExpr(x) |
| y)) |
| PassStmt:5())) |
| |
| [case testUnpackTypeInSignature] |
| def f(*args: *Ts) -> None: |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| def (*args: *Ts?) -> None? |
| VarArg( |
| Var(args)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testUnpackTypeInTuple] |
| x: tuple[int, *Ts, str] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| TempNode:1( |
| Any) |
| tuple?[int?, *Ts?, str?])) |
| |
| |
| [case testLiteralStringType] |
| from typing import Literal |
| x: Literal["hello"] |
| [out] |
| MypyFile:1( |
| ImportFrom:1(typing, [Literal]) |
| AssignmentStmt:2( |
| NameExpr(x) |
| TempNode:2( |
| Any) |
| Literal?[hello?])) |
| |
| [case testLiteralStringWithEscapes] |
| from typing import Literal |
| x: Literal["hello\nworld"] |
| [out] |
| MypyFile:1( |
| ImportFrom:1(typing, [Literal]) |
| AssignmentStmt:2( |
| NameExpr(x) |
| TempNode:2( |
| Any) |
| Literal?['hello\nworld'])) |
| |
| [case testForwardReference] |
| x: "int" |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| TempNode:1( |
| Any) |
| int?)) |
| |
| [case testForwardReferenceWithUnion] |
| x: "int | str" |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| TempNode:1( |
| Any) |
| int? | str?)) |
| |
| [case testForwardReferenceWithComplexType] |
| x: "list[int]" |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| TempNode:1( |
| Any) |
| list?[int?])) |
| |
| [case testMultipleLiteralStrings] |
| from typing import Literal |
| x: Literal["a", "b", "c"] |
| [out] |
| MypyFile:1( |
| ImportFrom:1(typing, [Literal]) |
| AssignmentStmt:2( |
| NameExpr(x) |
| TempNode:2( |
| Any) |
| Literal?[a?, b?, c?])) |
| |
| [case testLiteralBytesType] |
| from typing import Literal |
| x: Literal[b"foo"] |
| y: Literal[b"hello\nworld", b"\x00\xff"] |
| [out] |
| MypyFile:1( |
| ImportFrom:1(typing, [Literal]) |
| AssignmentStmt:2( |
| NameExpr(x) |
| TempNode:2( |
| Any) |
| Literal?[b'foo']) |
| AssignmentStmt:3( |
| NameExpr(y) |
| TempNode:3( |
| Any) |
| Literal?[b'hello\nworld', b'\x00\xff'])) |
| |
| [case testStripFunctionBodiesIfIgnoringErrors] |
| # mypy: ignore-errors=True |
| def f(self): |
| self.x = 1 # Cannot define an attribute |
| return 1 |
| [out] |
| MypyFile:1( |
| FuncDef:2( |
| f |
| Args( |
| Var(self)) |
| Block:3())) |
| |
| [case testStripMethodBodiesIfIgnoringErrors] |
| # mypy: ignore-errors=True |
| class C: |
| def f(self): |
| x = self.x |
| for x in y: |
| pass |
| with a as y: |
| pass |
| while self.foo(): |
| self.bah() |
| a[self.x] = 1 |
| [out] |
| MypyFile:1( |
| ClassDef:2( |
| C |
| FuncDef:3( |
| f |
| Args( |
| Var(self)) |
| Block:4()))) |
| |
| [case testDoNotStripModuleTopLevelOrClassBody] |
| # mypy: ignore-errors=True |
| f() |
| class C: |
| x = 5 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:2( |
| CallExpr:2( |
| NameExpr(f) |
| Args())) |
| ClassDef:3( |
| C |
| AssignmentStmt:4( |
| NameExpr(x) |
| IntExpr(5)))) |
| |
| [case testDoNotStripMethodThatAssignsToAttribute] |
| # mypy: ignore-errors=True |
| class C: |
| def m1(self): |
| self.x = 0 |
| def m2(self): |
| a, self.y = 0 |
| [out] |
| MypyFile:1( |
| ClassDef:2( |
| C |
| FuncDef:3( |
| m1 |
| Args( |
| Var(self)) |
| Block:4( |
| AssignmentStmt:4( |
| MemberExpr:4( |
| NameExpr(self) |
| x) |
| IntExpr(0)))) |
| FuncDef:5( |
| m2 |
| Args( |
| Var(self)) |
| Block:6( |
| AssignmentStmt:6( |
| TupleExpr:6( |
| NameExpr(a) |
| MemberExpr:6( |
| NameExpr(self) |
| y)) |
| IntExpr(0)))))) |
| |
| [case testDoNotStripMethodThatAssignsToAttributeWithinStatement] |
| # mypy: ignore-errors=True |
| class C: |
| def m1(self): |
| for x in y: |
| self.x = 0 |
| def m2(self): |
| with x: |
| self.y = 0 |
| def m3(self): |
| if x: |
| self.y = 0 |
| else: |
| x = 4 |
| [out] |
| MypyFile:1( |
| ClassDef:2( |
| C |
| FuncDef:3( |
| m1 |
| Args( |
| Var(self)) |
| Block:4( |
| ForStmt:4( |
| NameExpr(x) |
| NameExpr(y) |
| Block:5( |
| AssignmentStmt:5( |
| MemberExpr:5( |
| NameExpr(self) |
| x) |
| IntExpr(0)))))) |
| FuncDef:6( |
| m2 |
| Args( |
| Var(self)) |
| Block:7( |
| WithStmt:7( |
| Expr( |
| NameExpr(x)) |
| Block:8( |
| AssignmentStmt:8( |
| MemberExpr:8( |
| NameExpr(self) |
| y) |
| IntExpr(0)))))) |
| FuncDef:9( |
| m3 |
| Args( |
| Var(self)) |
| Block:10( |
| IfStmt:10( |
| If( |
| NameExpr(x)) |
| Then( |
| AssignmentStmt:11( |
| MemberExpr:11( |
| NameExpr(self) |
| y) |
| IntExpr(0))) |
| Else( |
| AssignmentStmt:13( |
| NameExpr(x) |
| IntExpr(4)))))))) |
| |
| [case testDoNotStripMethodThatDefinesAttributeWithoutAssignment] |
| # mypy: ignore-errors=True |
| class C: |
| def m1(self): |
| with y as self.x: |
| pass |
| def m2(self): |
| for self.y in x: |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:2( |
| C |
| FuncDef:3( |
| m1 |
| Args( |
| Var(self)) |
| Block:4( |
| WithStmt:4( |
| Expr( |
| NameExpr(y)) |
| Target( |
| MemberExpr:4( |
| NameExpr(self) |
| x)) |
| Block:5( |
| PassStmt:5())))) |
| FuncDef:6( |
| m2 |
| Args( |
| Var(self)) |
| Block:7( |
| ForStmt:7( |
| MemberExpr:7( |
| NameExpr(self) |
| y) |
| NameExpr(x) |
| Block:8( |
| PassStmt:8())))))) |
| |
| [case testStripDecoratedFunctionOrMethod] |
| # mypy: ignore-errors=True |
| @deco |
| def f(): |
| x = 0 |
| |
| class C: |
| @deco |
| def m1(self): |
| x = 0 |
| |
| @deco |
| def m2(self): |
| self.x = 0 |
| [out] |
| MypyFile:1( |
| Decorator:2( |
| Var(f) |
| NameExpr(deco) |
| FuncDef:3( |
| f |
| Block:4())) |
| ClassDef:6( |
| C |
| Decorator:7( |
| Var(m1) |
| NameExpr(deco) |
| FuncDef:8( |
| m1 |
| Args( |
| Var(self)) |
| Block:9())) |
| Decorator:11( |
| Var(m2) |
| NameExpr(deco) |
| FuncDef:12( |
| m2 |
| Args( |
| Var(self)) |
| Block:13( |
| AssignmentStmt:13( |
| MemberExpr:13( |
| NameExpr(self) |
| x) |
| IntExpr(0))))))) |
| |
| [case testStripOverloadedMethod] |
| # mypy: ignore-errors=True |
| class C: |
| @overload |
| def m1(self, x: int) -> None: ... |
| @overload |
| def m1(self, x: str) -> None: ... |
| def m1(self, x): |
| x = 0 |
| |
| @overload |
| def m2(self, x: int) -> None: ... |
| @overload |
| def m2(self, x: str) -> None: ... |
| def m2(self, x): |
| self.x = 0 |
| [out] |
| MypyFile:1( |
| ClassDef:2( |
| C |
| OverloadedFuncDef:3( |
| Decorator:3( |
| Var(m1) |
| NameExpr(overload) |
| FuncDef:4( |
| m1 |
| Args( |
| Var(self) |
| Var(x)) |
| def (self: Any, x: int?) -> None? |
| Block:4( |
| ExpressionStmt:4( |
| Ellipsis)))) |
| Decorator:5( |
| Var(m1) |
| NameExpr(overload) |
| FuncDef:6( |
| m1 |
| Args( |
| Var(self) |
| Var(x)) |
| def (self: Any, x: str?) -> None? |
| Block:6( |
| ExpressionStmt:6( |
| Ellipsis)))) |
| FuncDef:7( |
| m1 |
| Args( |
| Var(self) |
| Var(x)) |
| Block:8())) |
| OverloadedFuncDef:10( |
| Decorator:10( |
| Var(m2) |
| NameExpr(overload) |
| FuncDef:11( |
| m2 |
| Args( |
| Var(self) |
| Var(x)) |
| def (self: Any, x: int?) -> None? |
| Block:11( |
| ExpressionStmt:11( |
| Ellipsis)))) |
| Decorator:12( |
| Var(m2) |
| NameExpr(overload) |
| FuncDef:13( |
| m2 |
| Args( |
| Var(self) |
| Var(x)) |
| def (self: Any, x: str?) -> None? |
| Block:13( |
| ExpressionStmt:13( |
| Ellipsis)))) |
| FuncDef:14( |
| m2 |
| Args( |
| Var(self) |
| Var(x)) |
| Block:15( |
| AssignmentStmt:15( |
| MemberExpr:15( |
| NameExpr(self) |
| x) |
| IntExpr(0))))))) |
| |
| [case testStripMethodInNestedClass] |
| # mypy: ignore-errors=True |
| class C: |
| class D: |
| def m1(self): |
| self.x = 1 |
| def m2(self): |
| return self.x |
| [out] |
| MypyFile:1( |
| ClassDef:2( |
| C |
| ClassDef:3( |
| D |
| FuncDef:4( |
| m1 |
| Args( |
| Var(self)) |
| Block:5( |
| AssignmentStmt:5( |
| MemberExpr:5( |
| NameExpr(self) |
| x) |
| IntExpr(1)))) |
| FuncDef:6( |
| m2 |
| Args( |
| Var(self)) |
| Block:7())))) |
| |
| [case testSuperExpr] |
| super().x |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| SuperExpr:1( |
| x |
| CallExpr:1( |
| NameExpr(super) |
| Args())))) |
| |
| [case testTypeCommentSimple] |
| x = [] # type: list[int] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| ListExpr:1() |
| list?[int?])) |
| |
| [case testTypeCommentMultiple] |
| x = [] # type: list[int] |
| y = {} # type: dict[str, int] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| ListExpr:1() |
| list?[int?]) |
| AssignmentStmt:2( |
| NameExpr(y) |
| DictExpr:2() |
| dict?[str?, int?])) |
| |
| [case testTypeCommentWithTrailingComment] |
| x = [] # type: list[str] # This is a comment |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| ListExpr:1() |
| list?[str?])) |
| |
| [case testTypeCommentUnion] |
| x = None # type: str | None |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| NameExpr(None) |
| str? | None?)) |
| |
| [case testNestedListAssignment] |
| a1, [b1, c1] = a2, [b2, c2] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| TupleExpr:1( |
| NameExpr(a1) |
| TupleExpr:1( |
| NameExpr(b1) |
| NameExpr(c1))) |
| TupleExpr:1( |
| NameExpr(a2) |
| ListExpr:1( |
| NameExpr(b2) |
| NameExpr(c2))))) |
| |
| [case testSyntaxError1] |
| x = [1 2] |
| y = 2 |
| [out] |
| 1:8: error: Expected `,`, found int |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| ListExpr:1( |
| IntExpr(1) |
| IntExpr(2))) |
| AssignmentStmt:2( |
| NameExpr(y) |
| IntExpr(2))) |
| |
| [case testSyntaxError2] |
| f(a.) |
| [out] |
| 1:5: error: Expected an identifier |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(f) |
| Args( |
| MemberExpr:1( |
| NameExpr(a) |
| ))))) |
| |
| [case testSyntaxError3] |
| f(a[]) |
| [out] |
| 1:5: error: Expected index or slice expression |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(f) |
| Args( |
| IndexExpr:1( |
| NameExpr(a) |
| NameExpr()))))) |
| |
| [case testSyntaxError4] |
| from m import |
| 1 |
| [out] |
| 1:14: error: Expected one or more symbol names after import |
| MypyFile:1( |
| ImportFrom:1(m, []) |
| ExpressionStmt:2( |
| IntExpr(1))) |
| |
| [case testSyntaxError5] |
| from m |
| 1 |
| [out] |
| 1:7: error: Expected `import`, found newline |
| MypyFile:1( |
| ImportFrom:1(m, []) |
| ExpressionStmt:2( |
| IntExpr(1))) |
| |
| [case testSyntaxError6] |
| from m |
| 1 |
| [out] |
| 1:7: error: Expected `import`, found newline |
| MypyFile:1( |
| ImportFrom:1(m, []) |
| ExpressionStmt:2( |
| IntExpr(1))) |
| |
| [case testSyntaxError7] |
| def f(): |
| g( |
| h() |
| |
| def g(): ... |
| [out] |
| 3:8: error: Expected `)`, found newline |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| ExpressionStmt:2( |
| CallExpr:2( |
| NameExpr(g) |
| Args( |
| CallExpr:3( |
| NameExpr(h) |
| Args())))))) |
| FuncDef:5( |
| g |
| Block:5( |
| ExpressionStmt:5( |
| Ellipsis)))) |
| |
| [case testSyntaxError8] |
| def f( |
| x, |
| y |
| |
| def g(): ... |
| [out] |
| 3:6: error: Expected `)`, found newline |
| 5:1: error: Expected an indented block after function definition |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x) |
| Var(y)) |
| Block:1()) |
| FuncDef:5( |
| g |
| Block:5( |
| ExpressionStmt:5( |
| Ellipsis)))) |
| |
| [case testSyntaxError9] |
| class A |
| |
| def f(): pass |
| [out] |
| 1:8: error: Expected `:`, found newline |
| 3:1: error: Expected an indented block after `class` definition |
| MypyFile:1( |
| ClassDef:1( |
| A) |
| FuncDef:3( |
| f |
| Block:3( |
| PassStmt:3()))) |
| |
| [case testArgConstructorTooManyArgs] |
| from typing import Callable |
| from mypy_extensions import Arg |
| def f(x: Callable[[Arg(int, 'x', 'extra')], bool]) -> None: |
| pass |
| [out] |
| 3:19: error: Too many arguments for argument constructor |
| MypyFile:1( |
| ImportFrom:1(typing, [Callable]) |
| ImportFrom:2(mypy_extensions, [Arg]) |
| FuncDef:3( |
| f |
| Args( |
| Var(x)) |
| def (x: Callable?[<TypeList Arg(int?, x)>, bool?]) -> None? |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testArgConstructorMultipleValuesForName] |
| from typing import Callable |
| from mypy_extensions import Arg |
| def f(x: Callable[[Arg(int, 'x', name='y')], bool]) -> None: |
| pass |
| [out] |
| 3:19: error: "Arg" gets multiple values for keyword argument "name" |
| MypyFile:1( |
| ImportFrom:1(typing, [Callable]) |
| ImportFrom:2(mypy_extensions, [Arg]) |
| FuncDef:3( |
| f |
| Args( |
| Var(x)) |
| def (x: Callable?[<TypeList Arg(int?, y)>, bool?]) -> None? |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testArgConstructorMultipleValuesForType] |
| from typing import Callable |
| from mypy_extensions import Arg |
| def f(x: Callable[[Arg(int, type=str)], bool]) -> None: |
| pass |
| [out] |
| 3:19: error: "Arg" gets multiple values for keyword argument "type" |
| MypyFile:1( |
| ImportFrom:1(typing, [Callable]) |
| ImportFrom:2(mypy_extensions, [Arg]) |
| FuncDef:3( |
| f |
| Args( |
| Var(x)) |
| def (x: Callable?[<TypeList Arg(str?)>, bool?]) -> None? |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testArgConstructorUnexpectedArg] |
| from typing import Callable |
| from mypy_extensions import Arg |
| def f(x: Callable[[Arg(int, foo='bar')], bool]) -> None: |
| pass |
| [out] |
| 3:19: error: Unexpected argument "foo" for argument constructor |
| MypyFile:1( |
| ImportFrom:1(typing, [Callable]) |
| ImportFrom:2(mypy_extensions, [Arg]) |
| FuncDef:3( |
| f |
| Args( |
| Var(x)) |
| def (x: Callable?[<TypeList Arg(int?)>, bool?]) -> None? |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testArgConstructorMultipleErrors] |
| from typing import Callable |
| from mypy_extensions import Arg |
| def f(x: Callable[[Arg(int, 'x', 'extra', foo='bar', name='y')], bool]) -> None: |
| pass |
| [out] |
| 3:19: error: Too many arguments for argument constructor |
| 3:19: error: Unexpected argument "foo" for argument constructor |
| 3:19: error: "Arg" gets multiple values for keyword argument "name" |
| MypyFile:1( |
| ImportFrom:1(typing, [Callable]) |
| ImportFrom:2(mypy_extensions, [Arg]) |
| FuncDef:3( |
| f |
| Args( |
| Var(x)) |
| def (x: Callable?[<TypeList Arg(int?, y)>, bool?]) -> None? |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testArgConstructorValidSyntax] |
| from typing import Callable |
| from mypy_extensions import Arg, DefaultArg, VarArg, KwArg |
| def f(x: Callable[[Arg(int, 'x'), DefaultArg(str, 'y'), VarArg(bool), KwArg(float)], None]) -> None: |
| pass |
| [out] |
| MypyFile:1( |
| ImportFrom:1(typing, [Callable]) |
| ImportFrom:2(mypy_extensions, [Arg, DefaultArg, VarArg, KwArg]) |
| FuncDef:3( |
| f |
| Args( |
| Var(x)) |
| def (x: Callable?[<TypeList Arg(int?, x), DefaultArg(str?, y), VarArg(bool?), KwArg(float?)>, None?]) -> None? |
| Block:4( |
| PassStmt:4()))) |
| [case testInvalidTypeFloatLiteral] |
| x: 3.14 |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypeComplexLiteral] |
| y: 1j |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(y) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypeBinaryOperatorAdd] |
| z: int + str |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(z) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypeBinaryOperatorMul] |
| a: int * str |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypeUnaryOperatorNot] |
| b: not int |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(b) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypeUnaryOperatorInvert] |
| c: ~int |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(c) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypeSetExpression] |
| f: {1, 2, 3} |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(f) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypeListComprehension] |
| g: [x for x in range(10)] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(g) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypeLambda] |
| h: lambda x: x |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(h) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypeIfExpression] |
| i: int if True else str |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(i) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypeComparisonExpression] |
| j: int < str |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(j) |
| TempNode:1( |
| Any) |
| None)) |
| |
| [case testInvalidTypePositiveUnaryOp] |
| k: +5 |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(k) |
| TempNode:1( |
| Any) |
| 5)) |
| |
| [case testConditionalOverload1] |
| @overload |
| def foo(x: int): ... |
| if sys.version_info[0] > 2: |
| @overload |
| def foo(x: str): ... |
| def foo(x): pass |
| [out] |
| MypyFile:1( |
| IfStmt:3( |
| If( |
| ComparisonExpr:3( |
| > |
| IndexExpr:3( |
| MemberExpr:3( |
| NameExpr(sys) |
| version_info) |
| IntExpr(0)) |
| IntExpr(2))) |
| Then() |
| Else()) |
| OverloadedFuncDef:1( |
| Decorator:1( |
| Var(foo) |
| NameExpr(overload) |
| FuncDef:2( |
| foo |
| Args( |
| Var(x)) |
| def (x: int?) -> Any |
| Block:2( |
| ExpressionStmt:2( |
| Ellipsis)))) |
| Decorator:4( |
| Var(foo) |
| NameExpr(overload) |
| FuncDef:5( |
| foo |
| Args( |
| Var(x)) |
| def (x: str?) -> Any |
| Block:5( |
| ExpressionStmt:5( |
| Ellipsis)))) |
| FuncDef:6( |
| foo |
| Args( |
| Var(x)) |
| Block:6( |
| PassStmt:6())))) |
| |
| [case testConditionalOverload2] |
| @overload |
| def foo(x: int): ... |
| if sys.platform == "foo": |
| @overload |
| def foo(x: str): ... |
| def foo(x): pass |
| [out] |
| MypyFile:1( |
| IfStmt:3( |
| If( |
| ComparisonExpr:3( |
| == |
| MemberExpr:3( |
| NameExpr(sys) |
| platform) |
| StrExpr(foo))) |
| Then()) |
| OverloadedFuncDef:1( |
| Decorator:1( |
| Var(foo) |
| NameExpr(overload) |
| FuncDef:2( |
| foo |
| Args( |
| Var(x)) |
| def (x: int?) -> Any |
| Block:2( |
| ExpressionStmt:2( |
| Ellipsis)))) |
| FuncDef:6( |
| foo |
| Args( |
| Var(x)) |
| Block:6( |
| PassStmt:6())))) |
| |
| [case testConditionalOverload3] |
| if sys.version_info[0] > 2: |
| @overload |
| def foo(x: str): ... |
| @overload |
| def foo(x: int): ... |
| def foo(x): pass |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| ComparisonExpr:1( |
| > |
| IndexExpr:1( |
| MemberExpr:1( |
| NameExpr(sys) |
| version_info) |
| IntExpr(0)) |
| IntExpr(2))) |
| Then() |
| Else()) |
| OverloadedFuncDef:2( |
| Decorator:2( |
| Var(foo) |
| NameExpr(overload) |
| FuncDef:3( |
| foo |
| Args( |
| Var(x)) |
| def (x: str?) -> Any |
| Block:3( |
| ExpressionStmt:3( |
| Ellipsis)))) |
| Decorator:4( |
| Var(foo) |
| NameExpr(overload) |
| FuncDef:5( |
| foo |
| Args( |
| Var(x)) |
| def (x: int?) -> Any |
| Block:5( |
| ExpressionStmt:5( |
| Ellipsis)))) |
| FuncDef:6( |
| foo |
| Args( |
| Var(x)) |
| Block:6( |
| PassStmt:6())))) |
| |
| [case testMatchStmt] |
| match x: |
| case foo(y): |
| pass |
| case _: |
| pass |
| [out] |
| MypyFile:1( |
| MatchStmt:1( |
| NameExpr(x) |
| Pattern( |
| ClassPattern:2( |
| NameExpr(foo) |
| Positionals( |
| AsPattern:2( |
| NameExpr(y))))) |
| Body( |
| PassStmt:3()) |
| Pattern( |
| AsPattern:4()) |
| Body( |
| PassStmt:5()))) |
| |
| [case testMatchLiteralPatterns] |
| match x: |
| case 1: |
| pass |
| case "hello": |
| pass |
| case True: |
| pass |
| case None: |
| pass |
| [out] |
| MypyFile:1( |
| MatchStmt:1( |
| NameExpr(x) |
| Pattern( |
| ValuePattern:2( |
| IntExpr(1))) |
| Body( |
| PassStmt:3()) |
| Pattern( |
| ValuePattern:4( |
| StrExpr(hello))) |
| Body( |
| PassStmt:5()) |
| Pattern( |
| SingletonPattern:6( |
| True)) |
| Body( |
| PassStmt:7()) |
| Pattern( |
| SingletonPattern:8()) |
| Body( |
| PassStmt:9()))) |
| |
| [case testMatchOrPattern] |
| match x: |
| case 1 | 2 | 3: |
| pass |
| [out] |
| MypyFile:1( |
| MatchStmt:1( |
| NameExpr(x) |
| Pattern( |
| OrPattern:2( |
| ValuePattern:2( |
| IntExpr(1)) |
| ValuePattern:2( |
| IntExpr(2)) |
| ValuePattern:2( |
| IntExpr(3)))) |
| Body( |
| PassStmt:3()))) |
| |
| [case testMatchSequencePattern] |
| match x: |
| case [a, *rest, b]: |
| pass |
| [out] |
| MypyFile:1( |
| MatchStmt:1( |
| NameExpr(x) |
| Pattern( |
| SequencePattern:2( |
| AsPattern:2( |
| NameExpr(a)) |
| StarredPattern:2( |
| NameExpr(rest)) |
| AsPattern:2( |
| NameExpr(b)))) |
| Body( |
| PassStmt:3()))) |
| |
| [case testMatchMappingPattern] |
| match x: |
| case {"key": value, "x": y}: |
| pass |
| [out] |
| MypyFile:1( |
| MatchStmt:1( |
| NameExpr(x) |
| Pattern( |
| MappingPattern:2( |
| Key( |
| StrExpr(key)) |
| Value( |
| AsPattern:2( |
| NameExpr(value))) |
| Key( |
| StrExpr(x)) |
| Value( |
| AsPattern:2( |
| NameExpr(y))))) |
| Body( |
| PassStmt:3()))) |
| |
| [case testMatchGuard] |
| match x: |
| case y if y > 0: |
| pass |
| [out] |
| MypyFile:1( |
| MatchStmt:1( |
| NameExpr(x) |
| Pattern( |
| AsPattern:2( |
| NameExpr(y))) |
| Guard( |
| ComparisonExpr:2( |
| > |
| NameExpr(y) |
| IntExpr(0))) |
| Body( |
| PassStmt:3()))) |
| |
| [case testPEP695TypeAlias] |
| # comment |
| type A[T] = C[T] |
| [out] |
| MypyFile:1( |
| TypeAliasStmt:2( |
| NameExpr(A) |
| TypeParam( |
| T) |
| LambdaExpr:2( |
| Block:-1( |
| ReturnStmt:2( |
| IndexExpr:2( |
| NameExpr(C) |
| NameExpr(T))))))) |
| |
| [case testPEP695GenericFunction] |
| # comment |
| |
| def f[T](): pass |
| def g[T: str](): pass |
| def h[T: (int, str)](): pass |
| [out] |
| MypyFile:1( |
| FuncDef:3( |
| f |
| TypeParam( |
| T) |
| Block:3( |
| PassStmt:3())) |
| FuncDef:4( |
| g |
| TypeParam( |
| T |
| str?) |
| Block:4( |
| PassStmt:4())) |
| FuncDef:5( |
| h |
| TypeParam( |
| T |
| Values( |
| int? |
| str?)) |
| Block:5( |
| PassStmt:5()))) |
| |
| [case testPEP695ParamSpec] |
| # comment |
| |
| def f[**P](): pass |
| class C[T: int, **P]: pass |
| [out] |
| MypyFile:1( |
| FuncDef:3( |
| f |
| TypeParam( |
| **P) |
| Block:3( |
| PassStmt:3())) |
| ClassDef:4( |
| C |
| TypeParam( |
| T |
| int?) |
| TypeParam( |
| **P) |
| PassStmt:4())) |
| |
| [case testPEP695TypeVarTuple] |
| # comment |
| |
| def f[*Ts](): pass |
| class C[T: int, *Ts]: pass |
| [out] |
| MypyFile:1( |
| FuncDef:3( |
| f |
| TypeParam( |
| *Ts) |
| Block:3( |
| PassStmt:3())) |
| ClassDef:4( |
| C |
| TypeParam( |
| T |
| int?) |
| TypeParam( |
| *Ts) |
| PassStmt:4())) |
