| -- Test cases for parser. Each test case consists of two sections. |
| -- The first section contains [case NAME] followed by the input code, while |
| -- the second section contains [out] followed by the output from the parser. |
| -- |
| -- Lines starting with "--" in this file will be ignored, except for lines |
| -- starting with "----" that are not ignored. The first two dashes of these |
| -- lines are interpreted as escapes and removed. |
| |
| [case testEmptyFile] |
| [out] |
| MypyFile:1() |
| |
| [case testExpressionStatement] |
| 1 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| IntExpr(1))) |
| |
| [case testAssignment] |
| x = 1 |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| IntExpr(1))) |
| |
| [case testExpressionBasics] |
| x = f(1, None) |
| 123 * (2 + x) |
| "hello".lower() |
| -1.23 |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| CallExpr:1( |
| NameExpr(f) |
| Args( |
| IntExpr(1) |
| NameExpr(None)))) |
| ExpressionStmt:2( |
| OpExpr:2( |
| * |
| IntExpr(123) |
| OpExpr:2( |
| + |
| IntExpr(2) |
| NameExpr(x)))) |
| ExpressionStmt:3( |
| CallExpr:3( |
| MemberExpr:3( |
| StrExpr(hello) |
| lower) |
| Args())) |
| ExpressionStmt:4( |
| UnaryExpr:4( |
| - |
| FloatExpr(1.23)))) |
| |
| [case testSingleQuotedStr] |
| '' |
| 'foo' |
| 'foo\ |
| bar' |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StrExpr()) |
| ExpressionStmt:2( |
| StrExpr(foo)) |
| ExpressionStmt:3( |
| StrExpr(foobar))) |
| |
| [case testDoubleQuotedStr] |
| "" |
| "foo" |
| "foo\ |
| bar" |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StrExpr()) |
| ExpressionStmt:2( |
| StrExpr(foo)) |
| ExpressionStmt:3( |
| StrExpr(foobar))) |
| |
| [case testRawStr] |
| r'x\n\'' |
| r"x\n\"" |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StrExpr(x\n\')) |
| ExpressionStmt:2( |
| StrExpr(x\n\"))) |
| |
| [case testBytes] |
| b'foo' |
| b"foo\ |
| bar" |
| br'x\n\'' |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| BytesExpr(foo)) |
| ExpressionStmt:2( |
| BytesExpr(foobar)) |
| ExpressionStmt:3( |
| BytesExpr(x\\n\\'))) |
| |
| [case testEscapesInStrings] |
| '\r\n\t\x2f\u123f' |
| b'\r\n\t\x2f\u123f' |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StrExpr(\u000d\u000a\u0009/\u123f)) |
| ExpressionStmt:2( |
| BytesExpr(\r\n\t/\\\u123f))) |
| -- Note \\u in the b'...' case (\u sequence not translated) |
| |
| [case testEscapedQuote] |
| '\'' |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StrExpr('))) |
| |
| [case testOctalEscapes] |
| '\0\1\177\1234' |
| b'\1\476' |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StrExpr(\u0000\u0001\u007fS4)) |
| ExpressionStmt:2( |
| BytesExpr(\x01>))) |
| |
| [case testUnicodeLiteralInPython3] |
| u'foo' |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StrExpr(foo))) |
| |
| [case testArrays] |
| a = [] |
| a = [1, 2] |
| a[[1]] = a[2] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| ListExpr:1()) |
| AssignmentStmt:2( |
| NameExpr(a) |
| ListExpr:2( |
| IntExpr(1) |
| IntExpr(2))) |
| AssignmentStmt:3( |
| IndexExpr:3( |
| NameExpr(a) |
| ListExpr:3( |
| IntExpr(1))) |
| IndexExpr:3( |
| NameExpr(a) |
| IntExpr(2)))) |
| |
| [case testTuples] |
| () |
| (1,) |
| (1, foo) |
| a, b = 1, (2, 3) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| TupleExpr:1()) |
| ExpressionStmt:2( |
| TupleExpr:2( |
| IntExpr(1))) |
| ExpressionStmt:3( |
| TupleExpr:3( |
| IntExpr(1) |
| NameExpr(foo))) |
| AssignmentStmt:4( |
| TupleExpr:4( |
| NameExpr(a) |
| NameExpr(b)) |
| TupleExpr:4( |
| IntExpr(1) |
| TupleExpr:4( |
| IntExpr(2) |
| IntExpr(3))))) |
| |
| [case testSimpleFunction] |
| def main(): |
| 1 |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| main |
| Block:2( |
| ExpressionStmt:2( |
| IntExpr(1))))) |
| |
| [case testPass] |
| def f(): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testIf] |
| if 1: |
| 2 |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| IntExpr(1)) |
| Then( |
| ExpressionStmt:2( |
| IntExpr(2))))) |
| |
| [case testIfElse] |
| if 1: |
| 2 |
| else: |
| 3 |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| IntExpr(1)) |
| Then( |
| ExpressionStmt:2( |
| IntExpr(2))) |
| Else( |
| ExpressionStmt:4( |
| IntExpr(3))))) |
| |
| [case testIfElif] |
| 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 testWhile] |
| while 1: |
| pass |
| [out] |
| MypyFile:1( |
| WhileStmt:1( |
| IntExpr(1) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testReturn] |
| def f(): |
| return 1 |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| ReturnStmt:2( |
| IntExpr(1))))) |
| |
| |
| [case testReturnWithoutValue] |
| def f(): |
| return |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| ReturnStmt:2()))) |
| |
| [case testBreak] |
| while 1: |
| break |
| [out] |
| MypyFile:1( |
| WhileStmt:1( |
| IntExpr(1) |
| Block:2( |
| BreakStmt:2()))) |
| |
| [case testLargeBlock] |
| if 1: |
| x = 1 |
| while 2: |
| pass |
| y = 2 |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| IntExpr(1)) |
| Then( |
| AssignmentStmt:2( |
| NameExpr(x) |
| IntExpr(1)) |
| WhileStmt:3( |
| IntExpr(2) |
| Block:4( |
| PassStmt:4())) |
| AssignmentStmt:5( |
| NameExpr(y) |
| IntExpr(2))))) |
| |
| [case testSimpleClass] |
| class A: |
| def f(self): |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| FuncDef:2( |
| f |
| Args( |
| Var(self)) |
| Block:3( |
| PassStmt:3())))) |
| |
| [case testGlobalVarWithType] |
| x = 0 # type: int |
| y = False # type: bool |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| IntExpr(0) |
| int?) |
| AssignmentStmt:2( |
| NameExpr(y) |
| NameExpr(False) |
| bool?)) |
| |
| [case testLocalVarWithType] |
| def f(): |
| x = 0 # type: int |
| y = False # type: bool |
| a = None # type: Any |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| AssignmentStmt:2( |
| NameExpr(x) |
| IntExpr(0) |
| int?) |
| AssignmentStmt:3( |
| NameExpr(y) |
| NameExpr(False) |
| bool?) |
| AssignmentStmt:4( |
| NameExpr(a) |
| NameExpr(None) |
| Any?)))) |
| |
| [case testFunctionDefWithType] |
| def f(y: str) -> int: |
| return |
| class A: |
| def f(self, a: int, b: Any) -> x: |
| pass |
| def g(self) -> Any: |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(y)) |
| def (y: str?) -> int? |
| Block:2( |
| ReturnStmt:2())) |
| ClassDef:3( |
| A |
| FuncDef:4( |
| f |
| Args( |
| Var(self) |
| Var(a) |
| Var(b)) |
| def (self: Any, a: int?, b: Any?) -> x? |
| Block:5( |
| PassStmt:5())) |
| FuncDef:6( |
| g |
| Args( |
| Var(self)) |
| def (self: Any) -> Any? |
| Block:7( |
| PassStmt:7())))) |
| |
| [case testFuncWithNoneReturn] |
| def f() -> None: |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| def () -> None? |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testVarDefWithGenericType] |
| x = None # type: List[str] |
| y = None # type: Dict[int, Any] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| NameExpr(None) |
| List?[str?]) |
| AssignmentStmt:2( |
| NameExpr(y) |
| NameExpr(None) |
| Dict?[int?, Any?])) |
| |
| [case testSignatureWithGenericTypes] |
| def f(y: t[Any, x]) -> a[b[c], d]: |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(y)) |
| def (y: t?[Any?, x?]) -> a?[b?[c?], d?] |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testParsingExpressionsWithLessAndGreaterThan] |
| # The operators < > can sometimes be confused with generic types. |
| x = a < b > c |
| f(x < b, y > c) |
| a < b > 1 |
| x < b, y > 2 |
| (a < b > c) |
| [out] |
| MypyFile:1( |
| AssignmentStmt:2( |
| NameExpr(x) |
| ComparisonExpr:2( |
| < |
| > |
| NameExpr(a) |
| NameExpr(b) |
| NameExpr(c))) |
| ExpressionStmt:3( |
| CallExpr:3( |
| NameExpr(f) |
| Args( |
| ComparisonExpr:3( |
| < |
| NameExpr(x) |
| NameExpr(b)) |
| ComparisonExpr:3( |
| > |
| NameExpr(y) |
| NameExpr(c))))) |
| ExpressionStmt:4( |
| ComparisonExpr:4( |
| < |
| > |
| NameExpr(a) |
| NameExpr(b) |
| IntExpr(1))) |
| ExpressionStmt:5( |
| TupleExpr:5( |
| ComparisonExpr:5( |
| < |
| NameExpr(x) |
| NameExpr(b)) |
| ComparisonExpr:5( |
| > |
| NameExpr(y) |
| IntExpr(2)))) |
| ExpressionStmt:6( |
| ComparisonExpr:6( |
| < |
| > |
| NameExpr(a) |
| NameExpr(b) |
| NameExpr(c)))) |
| |
| [case testLineContinuation] |
| if (1 + |
| 2): |
| pass |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| OpExpr:1( |
| + |
| IntExpr(1) |
| IntExpr(2))) |
| Then( |
| PassStmt:3()))) |
| |
| [case testMultipleVarDef] |
| x, y = z # type: int, a[c] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| TupleExpr:1( |
| NameExpr(x) |
| NameExpr(y)) |
| NameExpr(z) |
| Tuple[int?, a?[c?]])) |
| |
| [case testMultipleVarDef2] |
| (xx, z, i) = 1 # type: (a[c], Any, int) |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| TupleExpr:1( |
| NameExpr(xx) |
| NameExpr(z) |
| NameExpr(i)) |
| IntExpr(1) |
| Tuple[a?[c?], Any?, int?])) |
| |
| [case testMultipleVarDef3] |
| (xx, (z, i)) = 1 # type: (a[c], (Any, int)) |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| TupleExpr:1( |
| NameExpr(xx) |
| TupleExpr:1( |
| NameExpr(z) |
| NameExpr(i))) |
| IntExpr(1) |
| Tuple[a?[c?], Tuple[Any?, int?]])) |
| |
| [case testAnnotateAssignmentViaSelf] |
| class A: |
| def __init__(self): |
| self.x = 1 # type: int |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| FuncDef:2( |
| __init__ |
| Args( |
| Var(self)) |
| Block:3( |
| AssignmentStmt:3( |
| MemberExpr:3( |
| NameExpr(self) |
| x) |
| IntExpr(1) |
| int?))))) |
| |
| [case testCommentAfterTypeComment] |
| x = 0 # type: int # bar! |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| IntExpr(0) |
| int?)) |
| |
| [case testMultilineAssignmentAndAnnotations] |
| (x, |
| y) = (1, |
| 2) # type: foo, bar |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| TupleExpr:1( |
| NameExpr(x) |
| NameExpr(y)) |
| TupleExpr:2( |
| IntExpr(1) |
| IntExpr(2)) |
| Tuple[foo?, bar?])) |
| |
| [case testWhitespaceAndCommentAnnotation] |
| x = 1#type:int |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| IntExpr(1) |
| int?)) |
| |
| [case testWhitespaceAndCommentAnnotation2] |
| x = 1# type: int |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| IntExpr(1) |
| int?)) |
| |
| [case testWhitespaceAndCommentAnnotation3] |
| x = 1# type : int # not recognized! |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| IntExpr(1))) |
| |
| [case testInvalidAnnotation] |
| x=1 ##type: int |
| y=1 #.type: int |
| z=1 # Type: int |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| IntExpr(1)) |
| AssignmentStmt:2( |
| NameExpr(y) |
| IntExpr(1)) |
| AssignmentStmt:3( |
| NameExpr(z) |
| IntExpr(1))) |
| |
| [case testEmptyClass] |
| class C: |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| C |
| PassStmt:2())) |
| |
| [case testOperatorPrecedence] |
| a | b ^ c |
| a & b << c |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| OpExpr:1( |
| | |
| NameExpr(a) |
| OpExpr:1( |
| ^ |
| NameExpr(b) |
| NameExpr(c)))) |
| ExpressionStmt:2( |
| OpExpr:2( |
| & |
| NameExpr(a) |
| OpExpr:2( |
| << |
| NameExpr(b) |
| NameExpr(c))))) |
| |
| [case testOperatorAssociativity] |
| 1 - 2 + 3 |
| 1 << 2 << 3 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| OpExpr:1( |
| + |
| OpExpr:1( |
| - |
| IntExpr(1) |
| IntExpr(2)) |
| IntExpr(3))) |
| ExpressionStmt:2( |
| OpExpr:2( |
| << |
| OpExpr:2( |
| << |
| IntExpr(1) |
| IntExpr(2)) |
| IntExpr(3)))) |
| |
| [case testUnaryOperators] |
| -2 * +3 * ~3 * 2 |
| ~3**2 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| OpExpr:1( |
| * |
| OpExpr:1( |
| * |
| OpExpr:1( |
| * |
| UnaryExpr:1( |
| - |
| IntExpr(2)) |
| UnaryExpr:1( |
| + |
| IntExpr(3))) |
| UnaryExpr:1( |
| ~ |
| IntExpr(3))) |
| IntExpr(2))) |
| ExpressionStmt:2( |
| UnaryExpr:2( |
| ~ |
| OpExpr:2( |
| ** |
| IntExpr(3) |
| IntExpr(2))))) |
| |
| [case testSingleLineBodies] |
| if 1: pass |
| while 1: pass |
| def f(): pass |
| def g() -> int: return 1 |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| IntExpr(1)) |
| Then( |
| PassStmt:1())) |
| WhileStmt:2( |
| IntExpr(1) |
| Block:2( |
| PassStmt:2())) |
| FuncDef:3( |
| f |
| Block:3( |
| PassStmt:3())) |
| FuncDef:4( |
| g |
| def () -> int? |
| Block:4( |
| ReturnStmt:4( |
| IntExpr(1))))) |
| |
| [case testForStatement] |
| for x in y: |
| pass |
| for x, (y, w) in z: |
| 1 |
| for [x, (y, w)] in z: |
| 1 |
| [out] |
| MypyFile:1( |
| ForStmt:1( |
| NameExpr(x) |
| NameExpr(y) |
| Block:2( |
| PassStmt:2())) |
| ForStmt:3( |
| TupleExpr:3( |
| NameExpr(x) |
| TupleExpr:3( |
| NameExpr(y) |
| NameExpr(w))) |
| NameExpr(z) |
| Block:4( |
| ExpressionStmt:4( |
| IntExpr(1)))) |
| ForStmt:5( |
| TupleExpr:5( |
| NameExpr(x) |
| TupleExpr:5( |
| NameExpr(y) |
| NameExpr(w))) |
| NameExpr(z) |
| Block:6( |
| ExpressionStmt:6( |
| IntExpr(1))))) |
| |
| [case testGlobalDecl] |
| global x |
| def f(): |
| global x, y |
| [out] |
| MypyFile:1( |
| GlobalDecl:1( |
| x) |
| FuncDef:2( |
| f |
| Block:3( |
| GlobalDecl:3( |
| x |
| y)))) |
| |
| [case testNonlocalDecl] |
| def f(): |
| def g(): |
| nonlocal x, y |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| FuncDef:2( |
| g |
| Block:3( |
| NonlocalDecl:3( |
| x |
| y)))))) |
| |
| [case testRaiseStatement] |
| raise foo |
| [out] |
| MypyFile:1( |
| RaiseStmt:1( |
| NameExpr(foo))) |
| |
| [case testRaiseWithoutArg] |
| try: |
| pass |
| except: |
| raise |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| PassStmt:2()) |
| Block:4( |
| RaiseStmt:4()))) |
| |
| [case testRaiseFrom] |
| raise e from x |
| [out] |
| MypyFile:1( |
| RaiseStmt:1( |
| NameExpr(e) |
| NameExpr(x))) |
| |
| [case testBaseclasses] |
| class A(B): |
| pass |
| class A(B[T], C[Any, d[x]]): |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| BaseTypeExpr( |
| NameExpr(B)) |
| PassStmt:2()) |
| ClassDef:3( |
| A |
| BaseTypeExpr( |
| IndexExpr:3( |
| NameExpr(B) |
| NameExpr(T)) |
| IndexExpr:3( |
| NameExpr(C) |
| TupleExpr:3( |
| NameExpr(Any) |
| IndexExpr:3( |
| NameExpr(d) |
| NameExpr(x))))) |
| PassStmt:4())) |
| |
| [case testIsNot] |
| x is not y |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| ComparisonExpr:1( |
| is not |
| NameExpr(x) |
| NameExpr(y)))) |
| |
| [case testNotIn] |
| x not in y |
| not x not in y |
| x not in y | z |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| ComparisonExpr:1( |
| not in |
| NameExpr(x) |
| NameExpr(y))) |
| ExpressionStmt:2( |
| UnaryExpr:2( |
| not |
| ComparisonExpr:2( |
| not in |
| NameExpr(x) |
| NameExpr(y)))) |
| ExpressionStmt:3( |
| ComparisonExpr:3( |
| not in |
| NameExpr(x) |
| OpExpr:3( |
| | |
| NameExpr(y) |
| NameExpr(z))))) |
| |
| [case testNotAsBinaryOp] |
| x not y |
| [out] |
| main:1: error: invalid syntax |
| [out version==3.10.0] |
| main:1: error: invalid syntax. Perhaps you forgot a comma? |
| |
| [case testNotIs] |
| x not is y # E: invalid syntax |
| [out] |
| |
| [case testBinaryNegAsBinaryOp] |
| 1 ~ 2 |
| [out] |
| main:1: error: invalid syntax |
| [out version==3.10.0] |
| main:1: error: invalid syntax. Perhaps you forgot a comma? |
| |
| [case testSliceInList39] |
| # flags: --python-version 3.9 |
| x = [1, 2][1:2] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:2( |
| NameExpr(x) |
| IndexExpr:2( |
| ListExpr:2( |
| IntExpr(1) |
| IntExpr(2)) |
| SliceExpr:2( |
| IntExpr(1) |
| IntExpr(2))))) |
| |
| [case testDictionaryExpression] |
| {} |
| {1:x} |
| {1:x, 2 or 1:2 and 3} |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| DictExpr:1()) |
| ExpressionStmt:2( |
| DictExpr:2( |
| IntExpr(1) |
| NameExpr(x))) |
| ExpressionStmt:3( |
| DictExpr:3( |
| IntExpr(1) |
| NameExpr(x) |
| OpExpr:3( |
| or |
| IntExpr(2) |
| IntExpr(1)) |
| OpExpr:3( |
| and |
| IntExpr(2) |
| IntExpr(3))))) |
| |
| [case testImport] |
| import x |
| import y.z.foo, __foo__.bar |
| [out] |
| MypyFile:1( |
| Import:1(x) |
| Import:2(y.z.foo, __foo__.bar)) |
| |
| [case testVariableTypeWithQualifiedName] |
| x = None # type: x.y |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| NameExpr(None) |
| x.y?)) |
| |
| [case testTypeInSignatureWithQualifiedName] |
| def f() -> x.y[a.b.c]: pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| def () -> x.y?[a.b.c?] |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testImportFrom] |
| from m import x |
| from m.n import x, y, z |
| [out] |
| MypyFile:1( |
| ImportFrom:1(m, [x]) |
| ImportFrom:2(m.n, [x, y, z])) |
| |
| [case testImportFromAs] |
| from m import x as y |
| from x import y, z as a, c as c |
| [out] |
| MypyFile:1( |
| ImportFrom:1(m, [x : y]) |
| ImportFrom:2(x, [y, z : a, c : c])) |
| |
| [case testImportStar] |
| from x import * |
| [out] |
| MypyFile:1( |
| ImportAll:1(x)) |
| |
| [case testImportsInDifferentPlaces] |
| 1 |
| import x |
| def f(): |
| from x import y |
| from z import * |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| IntExpr(1)) |
| Import:2(x) |
| FuncDef:3( |
| f |
| Block:4( |
| ImportFrom:4(x, [y]) |
| ImportAll:5(z)))) |
| |
| [case testImportWithExtraComma] |
| from x import (y, z,) |
| [out] |
| MypyFile:1( |
| ImportFrom:1(x, [y, z])) |
| |
| [case testDefaultArgs] |
| def f(x=1): |
| pass |
| def g(x, y=1+2, z=(1, 2)): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| default( |
| Var(x) |
| IntExpr(1))) |
| Block:2( |
| PassStmt:2())) |
| FuncDef:3( |
| g |
| Args( |
| Var(x) |
| default( |
| Var(y) |
| OpExpr:3( |
| + |
| IntExpr(1) |
| IntExpr(2))) |
| default( |
| Var(z) |
| TupleExpr:3( |
| IntExpr(1) |
| IntExpr(2)))) |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testTryFinally] |
| try: |
| 1 |
| finally: |
| 2 |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| IntExpr(1))) |
| Finally( |
| ExpressionStmt:4( |
| IntExpr(2))))) |
| |
| [case testTry] |
| try: |
| 1 |
| except x: |
| 2 |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| IntExpr(1))) |
| NameExpr(x) |
| Block:4( |
| ExpressionStmt:4( |
| IntExpr(2))))) |
| |
| [case testComplexTry] |
| try: |
| 1 |
| except x as y: |
| 2 |
| except x.y: |
| 3 |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| IntExpr(1))) |
| NameExpr(x) |
| NameExpr(y) |
| Block:4( |
| ExpressionStmt:4( |
| IntExpr(2))) |
| MemberExpr:5( |
| NameExpr(x) |
| y) |
| Block:6( |
| ExpressionStmt:6( |
| IntExpr(3))))) |
| |
| [case testGeneratorExpression] |
| (x for y in z) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| GeneratorExpr:1( |
| NameExpr(x) |
| NameExpr(y) |
| NameExpr(z)))) |
| |
| [case testGeneratorExpressionNested] |
| (x for y, (p, q) in z) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| GeneratorExpr:1( |
| NameExpr(x) |
| TupleExpr:1( |
| NameExpr(y) |
| TupleExpr:1( |
| NameExpr(p) |
| NameExpr(q))) |
| NameExpr(z)))) |
| |
| [case testListComprehension] |
| x=[x for y in z] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| ListComprehension:1( |
| GeneratorExpr:1( |
| NameExpr(x) |
| NameExpr(y) |
| NameExpr(z))))) |
| |
| [case testComplexListComprehension] |
| x=[(x, y) for y, z in (1, 2)] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| ListComprehension:1( |
| GeneratorExpr:1( |
| TupleExpr:1( |
| NameExpr(x) |
| NameExpr(y)) |
| TupleExpr:1( |
| NameExpr(y) |
| NameExpr(z)) |
| TupleExpr:1( |
| IntExpr(1) |
| IntExpr(2)))))) |
| |
| [case testListComprehension2] |
| ([x + 1 for x in a]) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| ListComprehension:1( |
| GeneratorExpr:1( |
| OpExpr:1( |
| + |
| NameExpr(x) |
| IntExpr(1)) |
| NameExpr(x) |
| NameExpr(a))))) |
| |
| [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] |
| x[1: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)))) |
| ExpressionStmt:5( |
| IndexExpr:5( |
| NameExpr(x) |
| SliceExpr:5( |
| IntExpr(1) |
| IntExpr(2))))) |
| |
| [case testYield] |
| def f(): |
| yield x + 1 |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| ExpressionStmt:2( |
| YieldExpr:2( |
| OpExpr:2( |
| + |
| NameExpr(x) |
| IntExpr(1))))))) |
| |
| [case testYieldFrom] |
| def f(): |
| yield from h() |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| ExpressionStmt:2( |
| YieldFromExpr:2( |
| CallExpr:2( |
| NameExpr(h) |
| Args())))))) |
| |
| [case testYieldFromAssignment] |
| def f(): |
| a = yield from h() |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| AssignmentStmt:2( |
| NameExpr(a) |
| YieldFromExpr:2( |
| CallExpr:2( |
| NameExpr(h) |
| Args())))))) |
| |
| [case testDel] |
| del x |
| del x[0], y[1] |
| [out] |
| MypyFile:1( |
| DelStmt:1( |
| NameExpr(x)) |
| DelStmt:2( |
| TupleExpr:2( |
| IndexExpr:2( |
| NameExpr(x) |
| IntExpr(0)) |
| IndexExpr:2( |
| NameExpr(y) |
| IntExpr(1))))) |
| |
| [case testExtraCommas] |
| 1, 2, |
| +[1, 2,] |
| f(1,) |
| {1:2,} |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| TupleExpr:1( |
| IntExpr(1) |
| IntExpr(2))) |
| ExpressionStmt:2( |
| UnaryExpr:2( |
| + |
| ListExpr:2( |
| IntExpr(1) |
| IntExpr(2)))) |
| ExpressionStmt:3( |
| CallExpr:3( |
| NameExpr(f) |
| Args( |
| IntExpr(1)))) |
| ExpressionStmt:4( |
| DictExpr:4( |
| IntExpr(1) |
| IntExpr(2)))) |
| |
| [case testExtraCommaInFunc] |
| def f(x,): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testLambda] |
| lambda: 1 |
| lambda x: y + 1 |
| lambda x, y: 1 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| LambdaExpr:1( |
| Block:1( |
| ReturnStmt:1( |
| IntExpr(1))))) |
| ExpressionStmt:2( |
| LambdaExpr:2( |
| Args( |
| Var(x)) |
| Block:2( |
| ReturnStmt:2( |
| OpExpr:2( |
| + |
| NameExpr(y) |
| IntExpr(1)))))) |
| ExpressionStmt:3( |
| LambdaExpr:3( |
| Args( |
| Var(x) |
| Var(y)) |
| Block:3( |
| ReturnStmt:3( |
| IntExpr(1)))))) |
| |
| [case testComplexLambda] |
| lambda x=2: x |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| LambdaExpr:1( |
| Args( |
| default( |
| Var(x) |
| IntExpr(2))) |
| Block:1( |
| ReturnStmt:1( |
| NameExpr(x)))))) |
| |
| [case testLambdaPrecedence] |
| lambda x: 1, 2 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| TupleExpr:1( |
| LambdaExpr:1( |
| Args( |
| Var(x)) |
| Block:1( |
| ReturnStmt:1( |
| IntExpr(1)))) |
| IntExpr(2)))) |
| |
| [case testForIndicesInParens] |
| for (i, j) in x: |
| pass |
| [out] |
| MypyFile:1( |
| ForStmt:1( |
| TupleExpr:1( |
| NameExpr(i) |
| NameExpr(j)) |
| NameExpr(x) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testForAndTrailingCommaAfterIndexVar] |
| for i, in x: |
| pass |
| [out] |
| MypyFile:1( |
| ForStmt:1( |
| TupleExpr:1( |
| NameExpr(i)) |
| NameExpr(x) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testListComprehensionAndTrailingCommaAfterIndexVar] |
| x = [a for b, in c] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| ListComprehension:1( |
| GeneratorExpr:1( |
| NameExpr(a) |
| TupleExpr:1( |
| NameExpr(b)) |
| NameExpr(c))))) |
| |
| [case testForAndTrailingCommaAfterIndexVars] |
| for i, j, in x: |
| pass |
| [out] |
| MypyFile:1( |
| ForStmt:1( |
| TupleExpr:1( |
| NameExpr(i) |
| NameExpr(j)) |
| NameExpr(x) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testGeneratorWithCondition] |
| (x for y in z if 0) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| GeneratorExpr:1( |
| NameExpr(x) |
| NameExpr(y) |
| NameExpr(z) |
| IntExpr(0)))) |
| |
| [case testListComprehensionWithCondition] |
| raise [x for y in z if 0] |
| [out] |
| MypyFile:1( |
| RaiseStmt:1( |
| ListComprehension:1( |
| GeneratorExpr:1( |
| NameExpr(x) |
| NameExpr(y) |
| NameExpr(z) |
| IntExpr(0))))) |
| |
| [case testListComprehensionWithConditions] |
| raise [x for y in z if 0 if 1] |
| [out] |
| MypyFile:1( |
| RaiseStmt:1( |
| ListComprehension:1( |
| GeneratorExpr:1( |
| NameExpr(x) |
| NameExpr(y) |
| NameExpr(z) |
| IntExpr(0) |
| IntExpr(1))))) |
| |
| [case testListComprehensionWithCrazyConditions] |
| raise [x for y in z if (1 if 2 else 3) if 1] |
| [out] |
| MypyFile:1( |
| RaiseStmt:1( |
| ListComprehension:1( |
| GeneratorExpr:1( |
| NameExpr(x) |
| NameExpr(y) |
| NameExpr(z) |
| ConditionalExpr:1( |
| Condition( |
| IntExpr(2)) |
| IntExpr(1) |
| IntExpr(3)) |
| IntExpr(1))))) |
| |
| [case testDictionaryComprehension] |
| a = {x: y for x, y in xys} |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| DictionaryComprehension:1( |
| NameExpr(x) |
| NameExpr(y) |
| TupleExpr:1( |
| NameExpr(x) |
| NameExpr(y)) |
| NameExpr(xys)))) |
| |
| [case testDictionaryComprehensionComplex] |
| a = {x: y for x, y in xys for p, q in pqs if c} |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| DictionaryComprehension:1( |
| NameExpr(x) |
| NameExpr(y) |
| TupleExpr:1( |
| NameExpr(x) |
| NameExpr(y)) |
| TupleExpr:1( |
| NameExpr(p) |
| NameExpr(q)) |
| NameExpr(xys) |
| NameExpr(pqs) |
| NameExpr(c)))) |
| |
| [case testSetComprehension] |
| a = {i for i in l} |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| SetComprehension:1( |
| GeneratorExpr:1( |
| NameExpr(i) |
| NameExpr(i) |
| NameExpr(l))))) |
| |
| [case testSetComprehensionComplex] |
| a = {x + p for x in xys for p in pqs if c} |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| SetComprehension:1( |
| GeneratorExpr:1( |
| OpExpr:1( |
| + |
| NameExpr(x) |
| NameExpr(p)) |
| NameExpr(x) |
| NameExpr(p) |
| NameExpr(xys) |
| NameExpr(pqs) |
| NameExpr(c))))) |
| |
| [case testWithStatement] |
| with open('foo') as f: |
| pass |
| [out] |
| MypyFile:1( |
| WithStmt:1( |
| Expr( |
| CallExpr:1( |
| NameExpr(open) |
| Args( |
| StrExpr(foo)))) |
| Target( |
| NameExpr(f)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testWithStatementWithoutTarget] |
| with foo: |
| pass |
| [out] |
| MypyFile:1( |
| WithStmt:1( |
| Expr( |
| NameExpr(foo)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testHexOctBinLiterals] |
| 0xa, 0Xaf, 0o7, 0O12, 0b1, 0B101 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| TupleExpr:1( |
| IntExpr(10) |
| IntExpr(175) |
| IntExpr(7) |
| IntExpr(10) |
| IntExpr(1) |
| IntExpr(5)))) |
| |
| [case testImportFromWithParens] |
| from x import (y) |
| from x import (y, |
| z) |
| [out] |
| MypyFile:1( |
| ImportFrom:1(x, [y]) |
| ImportFrom:2(x, [y, z])) |
| |
| [case testContinueStmt] |
| while 1: |
| continue |
| [out] |
| MypyFile:1( |
| WhileStmt:1( |
| IntExpr(1) |
| Block:2( |
| ContinueStmt:2()))) |
| |
| [case testStrLiteralConcatenate] |
| 'f' 'bar' |
| ('x' |
| 'y' |
| 'z') |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StrExpr(fbar)) |
| ExpressionStmt:2( |
| StrExpr(xyz))) |
| |
| [case testCatchAllExcept] |
| try: |
| 1 |
| except: |
| pass |
| try: |
| 1 |
| except x: |
| pass |
| except: |
| 2 |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| ExpressionStmt:2( |
| IntExpr(1))) |
| Block:4( |
| PassStmt:4())) |
| TryStmt:5( |
| Block:6( |
| ExpressionStmt:6( |
| IntExpr(1))) |
| NameExpr(x) |
| Block:8( |
| PassStmt:8()) |
| Block:10( |
| ExpressionStmt:10( |
| IntExpr(2))))) |
| |
| [case testTryElse] |
| try: |
| pass |
| except x: |
| 1 |
| else: |
| 2 |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| PassStmt:2()) |
| NameExpr(x) |
| Block:4( |
| ExpressionStmt:4( |
| IntExpr(1))) |
| Else( |
| ExpressionStmt:6( |
| IntExpr(2))))) |
| |
| [case testExceptWithMultipleTypes] |
| try: |
| pass |
| except (x, y): |
| pass |
| except (a, b, c) as e: |
| pass |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| PassStmt:2()) |
| TupleExpr:3( |
| NameExpr(x) |
| NameExpr(y)) |
| Block:4( |
| PassStmt:4()) |
| TupleExpr:5( |
| NameExpr(a) |
| NameExpr(b) |
| NameExpr(c)) |
| NameExpr(e) |
| Block:6( |
| PassStmt:6()))) |
| |
| [case testNestedFunctions] |
| def f(): |
| def g(): |
| pass |
| def h() -> int: |
| def g() -> int: |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| FuncDef:2( |
| g |
| Block:3( |
| PassStmt:3())))) |
| FuncDef:4( |
| h |
| def () -> int? |
| Block:5( |
| FuncDef:5( |
| g |
| def () -> int? |
| Block:6( |
| PassStmt:6()))))) |
| |
| [case testStatementsAndDocStringsInClassBody] |
| class A: |
| "doc string" |
| x = y |
| def f(self): |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| ExpressionStmt:2( |
| StrExpr(doc string)) |
| AssignmentStmt:3( |
| NameExpr(x) |
| NameExpr(y)) |
| FuncDef:4( |
| f |
| Args( |
| Var(self)) |
| Block:5( |
| PassStmt:5())))) |
| |
| [case testSingleLineClass] |
| class a: pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| a |
| PassStmt:1())) |
| |
| [case testDecorator] |
| @property |
| def f(): |
| pass |
| [out] |
| MypyFile:1( |
| Decorator:1( |
| Var(f) |
| NameExpr(property) |
| FuncDef:2( |
| f |
| Block:3( |
| PassStmt:3())))) |
| |
| [case testComplexDecorator] |
| @foo(bar, 1) |
| @zar |
| def f() -> int: |
| pass |
| [out] |
| MypyFile:1( |
| Decorator:1( |
| Var(f) |
| CallExpr:1( |
| NameExpr(foo) |
| Args( |
| NameExpr(bar) |
| IntExpr(1))) |
| NameExpr(zar) |
| FuncDef:3( |
| f |
| def () -> int? |
| Block:4( |
| PassStmt:4())))) |
| |
| [case testKeywordArgInCall] |
| f(x=1) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(f) |
| Args() |
| KwArgs( |
| x |
| IntExpr(1))))) |
| |
| [case testComplexKeywordArgs] |
| f(x, y=1 or 2, z=y) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(f) |
| Args( |
| NameExpr(x)) |
| KwArgs( |
| y |
| OpExpr:1( |
| or |
| IntExpr(1) |
| IntExpr(2))) |
| KwArgs( |
| z |
| NameExpr(y))))) |
| |
| [case testChainedAssignment] |
| x = z = 1 |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| Lvalues( |
| NameExpr(x) |
| NameExpr(z)) |
| IntExpr(1))) |
| |
| [case testVarArgs] |
| def f(x, *a): pass |
| f(1, *2) |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| VarArg( |
| Var(a)) |
| Block:1( |
| PassStmt:1())) |
| ExpressionStmt:2( |
| CallExpr:2( |
| NameExpr(f) |
| Args( |
| IntExpr(1) |
| IntExpr(2)) |
| VarArg))) |
| |
| [case testVarArgWithType] |
| def f(x: str, *a: int): pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| def (x: str?, *a: int?) -> Any |
| VarArg( |
| Var(a)) |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testDictVarArgs] |
| def f(x, **a): pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| DictVarArg( |
| Var(a)) |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testBothVarArgs] |
| def f(x, *a, **b): pass |
| def g(*a, **b): pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| VarArg( |
| Var(a)) |
| DictVarArg( |
| Var(b)) |
| Block:1( |
| PassStmt:1())) |
| FuncDef:2( |
| g |
| VarArg( |
| Var(a)) |
| DictVarArg( |
| Var(b)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testDictVarArgsWithType] |
| def f(x: X, **a: A) -> None: pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| def (x: X?, **a: A?) -> None? |
| DictVarArg( |
| Var(a)) |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testCallDictVarArgs] |
| f(**x) |
| f(x, **y) |
| f(*x, **y) |
| f(x, *y, **z) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(f) |
| Args() |
| DictVarArg( |
| NameExpr(x)))) |
| ExpressionStmt:2( |
| CallExpr:2( |
| NameExpr(f) |
| Args( |
| NameExpr(x)) |
| DictVarArg( |
| NameExpr(y)))) |
| ExpressionStmt:3( |
| CallExpr:3( |
| NameExpr(f) |
| Args( |
| NameExpr(x)) |
| VarArg |
| DictVarArg( |
| NameExpr(y)))) |
| ExpressionStmt:4( |
| CallExpr:4( |
| NameExpr(f) |
| Args( |
| NameExpr(x) |
| NameExpr(y)) |
| VarArg |
| DictVarArg( |
| NameExpr(z))))) |
| |
| [case testAssert] |
| assert x == y |
| [out] |
| MypyFile:1( |
| AssertStmt:1( |
| ComparisonExpr:1( |
| == |
| NameExpr(x) |
| NameExpr(y)))) |
| |
| [case testYieldWithoutExpressions] |
| def f(): |
| yield |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| ExpressionStmt:2( |
| YieldExpr:2())))) |
| |
| [case testConditionalExpression] |
| x if y else z |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| ConditionalExpr:1( |
| Condition( |
| NameExpr(y)) |
| NameExpr(x) |
| NameExpr(z)))) |
| |
| [case testConditionalExpressionInListComprehension] |
| a = [x if y else z for a in b] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| ListComprehension:1( |
| GeneratorExpr:1( |
| ConditionalExpr:1( |
| Condition( |
| NameExpr(y)) |
| NameExpr(x) |
| NameExpr(z)) |
| NameExpr(a) |
| NameExpr(b))))) |
| |
| [case testConditionalExpressionInTuple] |
| 1 if 2 else 3, 4 |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| TupleExpr:1( |
| ConditionalExpr:1( |
| Condition( |
| IntExpr(2)) |
| IntExpr(1) |
| IntExpr(3)) |
| IntExpr(4)))) |
| |
| [case testSetLiteral] |
| {x or y} |
| {1, 2} |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| SetExpr:1( |
| OpExpr:1( |
| or |
| NameExpr(x) |
| NameExpr(y)))) |
| ExpressionStmt:2( |
| SetExpr:2( |
| IntExpr(1) |
| IntExpr(2)))) |
| |
| [case testSetLiteralWithExtraComma] |
| {x,} |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| SetExpr:1( |
| NameExpr(x)))) |
| |
| [case testImportAs] |
| import x as y |
| import x, z as y, a.b as c, d as d |
| [out] |
| MypyFile:1( |
| Import:1(x : y) |
| Import:2(x, z : y, a.b : c, d : d)) |
| |
| [case testForAndElse] |
| for x in y: |
| pass |
| else: |
| x |
| [out] |
| MypyFile:1( |
| ForStmt:1( |
| NameExpr(x) |
| NameExpr(y) |
| Block:2( |
| PassStmt:2()) |
| Else( |
| ExpressionStmt:4( |
| NameExpr(x))))) |
| |
| [case testWhileAndElse] |
| while x: |
| pass |
| else: |
| y |
| [out] |
| MypyFile:1( |
| WhileStmt:1( |
| NameExpr(x) |
| Block:2( |
| PassStmt:2()) |
| Else( |
| ExpressionStmt:4( |
| NameExpr(y))))) |
| |
| [case testWithAndMultipleOperands] |
| with x as y, a as b: |
| pass |
| with x(), y(): |
| pass |
| [out] |
| MypyFile:1( |
| WithStmt:1( |
| Expr( |
| NameExpr(x)) |
| Target( |
| NameExpr(y)) |
| Expr( |
| NameExpr(a)) |
| Target( |
| NameExpr(b)) |
| Block:2( |
| PassStmt:2())) |
| WithStmt:3( |
| Expr( |
| CallExpr:3( |
| NameExpr(x) |
| Args())) |
| Expr( |
| CallExpr:3( |
| NameExpr(y) |
| Args())) |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testOperatorAssignment] |
| x += 1 |
| x -= 1 |
| x *= 1 |
| x /= 1 |
| x //= 1 |
| x %= 1 |
| x **= 1 |
| x |= 1 |
| x &= 1 |
| x ^= 1 |
| x >>= 1 |
| x <<= 1 |
| [out] |
| MypyFile:1( |
| OperatorAssignmentStmt:1( |
| + |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:2( |
| - |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:3( |
| * |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:4( |
| / |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:5( |
| // |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:6( |
| % |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:7( |
| ** |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:8( |
| | |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:9( |
| & |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:10( |
| ^ |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:11( |
| >> |
| NameExpr(x) |
| IntExpr(1)) |
| OperatorAssignmentStmt:12( |
| << |
| NameExpr(x) |
| IntExpr(1))) |
| |
| [case testNestedClasses] |
| class A: |
| class B: |
| pass |
| class C: |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| ClassDef:2( |
| B |
| PassStmt:3()) |
| ClassDef:4( |
| C |
| PassStmt:5()))) |
| |
| [case testTryWithExceptAndFinally] |
| try: |
| pass |
| except x: |
| x |
| finally: |
| y |
| [out] |
| MypyFile:1( |
| TryStmt:1( |
| Block:2( |
| PassStmt:2()) |
| NameExpr(x) |
| Block:4( |
| ExpressionStmt:4( |
| NameExpr(x))) |
| Finally( |
| ExpressionStmt:6( |
| NameExpr(y))))) |
| |
| [case testBareAsteriskInFuncDef] |
| def f(x, *, y=1): pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| MaxPos(1) |
| Args( |
| Var(x) |
| default( |
| Var(y) |
| IntExpr(1))) |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testBareAsteriskInFuncDefWithSignature] |
| def f(x: A, *, y: B = 1) -> None: pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| MaxPos(1) |
| Args( |
| Var(x) |
| default( |
| Var(y) |
| IntExpr(1))) |
| def (x: A?, *, y: B? =) -> None? |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testBareAsteriskNamedDefault] |
| def f(*, y: B = 1) -> None: pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| MaxPos(0) |
| Args( |
| default( |
| Var(y) |
| IntExpr(1))) |
| def (*, y: B? =) -> None? |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testBareAsteriskNamedNoDefault] |
| def f(*, y: B) -> None: pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| MaxPos(0) |
| Args( |
| Var(y)) |
| def (*, y: B?) -> None? |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testSuperExpr] |
| super().x |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| SuperExpr:1( |
| x |
| CallExpr:1( |
| NameExpr(super) |
| Args())))) |
| |
| [case testKeywordAndDictArgs] |
| f(x = y, **kwargs) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(f) |
| Args() |
| KwArgs( |
| x |
| NameExpr(y)) |
| DictVarArg( |
| NameExpr(kwargs))))) |
| |
| [case testSimpleFunctionType] |
| f = None # type: Callable[[], None] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(f) |
| NameExpr(None) |
| Callable?[<TypeList >, None?])) |
| |
| [case testFunctionTypeWithArgument] |
| f = None # type: Callable[[str], int] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(f) |
| NameExpr(None) |
| Callable?[<TypeList str?>, int?])) |
| |
| [case testFunctionTypeWithTwoArguments] |
| f = None # type: Callable[[a[b], x.y], List[int]] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(f) |
| NameExpr(None) |
| Callable?[<TypeList a?[b?], x.y?>, List?[int?]])) |
| |
| [case testFunctionTypeWithExtraComma] |
| def f(x: Callable[[str,], int]): pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| def (x: Callable?[<TypeList str?>, int?]) -> Any |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testSimpleStringLiteralType] |
| def f() -> 'A': pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| def () -> A? |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testGenericStringLiteralType] |
| def f() -> 'A[B, C]': pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| def () -> A?[B?, C?] |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testPartialStringLiteralType] |
| def f() -> A['B', C]: pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| def () -> A?[B?, C?] |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testWhitespaceInStringLiteralType] |
| def f() -> ' A [ X ] ': pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| def () -> A?[X?] |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testEscapeInStringLiteralType] |
| def f() -> '\x41': pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| def () -> A? |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testMetaclass] |
| class Foo(metaclass=Bar): pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| Foo |
| Metaclass(NameExpr(Bar)) |
| PassStmt:1())) |
| |
| [case testQualifiedMetaclass] |
| class Foo(metaclass=foo.Bar): pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| Foo |
| Metaclass(MemberExpr:1( |
| NameExpr(foo) |
| Bar)) |
| PassStmt:1())) |
| |
| [case testBaseAndMetaclass] |
| class Foo(foo.bar[x], metaclass=Bar): pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| Foo |
| Metaclass(NameExpr(Bar)) |
| BaseTypeExpr( |
| IndexExpr:1( |
| MemberExpr:1( |
| NameExpr(foo) |
| bar) |
| NameExpr(x))) |
| PassStmt:1())) |
| |
| [case testClassKeywordArgs] |
| class Foo(_root=None): pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| Foo |
| PassStmt:1())) |
| |
| [case testClassKeywordArgsBeforeMeta] |
| class Foo(_root=None, metaclass=Bar): pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| Foo |
| Metaclass(NameExpr(Bar)) |
| PassStmt:1())) |
| |
| [case testClassKeywordArgsAfterMeta] |
| class Foo(metaclass=Bar, _root=None): pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| Foo |
| Metaclass(NameExpr(Bar)) |
| PassStmt:1())) |
| |
| [case testNamesThatAreNoLongerKeywords] |
| any = interface |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(any) |
| NameExpr(interface))) |
| |
| [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 testFunctionOverloadAndOtherStatements] |
| x |
| @overload |
| def f() -> x: pass |
| @overload |
| def f() -> y: pass |
| x |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| NameExpr(x)) |
| OverloadedFuncDef:2( |
| Decorator:2( |
| Var(f) |
| NameExpr(overload) |
| FuncDef:3( |
| f |
| def () -> x? |
| Block:3( |
| PassStmt:3()))) |
| Decorator:4( |
| Var(f) |
| NameExpr(overload) |
| FuncDef:5( |
| f |
| def () -> y? |
| Block:5( |
| PassStmt:5())))) |
| ExpressionStmt:6( |
| NameExpr(x))) |
| |
| [case testFunctionOverloadWithThreeVariants] |
| @overload |
| def f() -> x: pass |
| @overload |
| def f() -> y: 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()))) |
| Decorator:5( |
| Var(f) |
| NameExpr(overload) |
| FuncDef:6( |
| f |
| Args( |
| Var(y)) |
| Block:6( |
| PassStmt:6()))))) |
| |
| [case testDecoratorsThatAreNotOverloads] |
| @foo |
| def f() -> x: pass |
| @foo |
| def g() -> y: pass |
| [out] |
| MypyFile:1( |
| Decorator:1( |
| Var(f) |
| NameExpr(foo) |
| FuncDef:2( |
| f |
| def () -> x? |
| Block:2( |
| PassStmt:2()))) |
| Decorator:3( |
| Var(g) |
| NameExpr(foo) |
| FuncDef:4( |
| g |
| def () -> y? |
| Block:4( |
| PassStmt:4())))) |
| |
| [case testFunctionOverloadWithinFunction] |
| def f(): |
| @overload |
| def g(): pass |
| @overload |
| def g() -> x: pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| OverloadedFuncDef:2( |
| Decorator:2( |
| Var(g) |
| NameExpr(overload) |
| FuncDef:3( |
| g |
| Block:3( |
| PassStmt:3()))) |
| Decorator:4( |
| Var(g) |
| NameExpr(overload) |
| FuncDef:5( |
| g |
| def () -> x? |
| Block:5( |
| PassStmt:5()))))))) |
| |
| [case testCommentFunctionAnnotation] |
| def f(): # type: () -> A |
| pass |
| def g(x): # type: (A) -> B |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| def () -> A? |
| Block:2( |
| PassStmt:2())) |
| FuncDef:3( |
| g |
| Args( |
| Var(x)) |
| def (x: A?) -> B? |
| Block:4( |
| PassStmt:4()))) |
| |
| [case testCommentMethodAnnotation] |
| class A: |
| def f(self): # type: () -> A |
| pass |
| def g(xself, x): # type: (A) -> B |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| FuncDef:2( |
| f |
| Args( |
| Var(self)) |
| def (self: Any) -> A? |
| Block:3( |
| PassStmt:3())) |
| FuncDef:4( |
| g |
| Args( |
| Var(xself) |
| Var(x)) |
| def (xself: Any, x: A?) -> B? |
| Block:5( |
| PassStmt:5())))) |
| |
| [case testCommentMethodAnnotationAndNestedFunction] |
| class A: |
| def f(self): # type: () -> A |
| def g(x): # type: (A) -> B |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| FuncDef:2( |
| f |
| Args( |
| Var(self)) |
| def (self: Any) -> A? |
| Block:3( |
| FuncDef:3( |
| g |
| Args( |
| Var(x)) |
| def (x: A?) -> B? |
| Block:4( |
| PassStmt:4())))))) |
| |
| [case testCommentFunctionAnnotationOnSeparateLine] |
| def f(x): |
| # type: (X) -> Y |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| def (x: X?) -> Y? |
| Block:3( |
| PassStmt:3()))) |
| |
| [case testCommentFunctionAnnotationOnSeparateLine2] |
| def f(x): |
| |
| # type: (X) -> Y # bar |
| |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| def (x: X?) -> Y? |
| Block:5( |
| PassStmt:5()))) |
| |
| [case testCommentFunctionAnnotationAndVarArg] |
| def f(x, *y): # type: (X, *Y) -> Z |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| def (x: X?, *y: Y?) -> Z? |
| VarArg( |
| Var(y)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [case testCommentFunctionAnnotationAndAllVarArgs] |
| def f(x, *y, **z): # type: (X, *Y, **Z) -> A |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Args( |
| Var(x)) |
| def (x: X?, *y: Y?, **z: Z?) -> A? |
| VarArg( |
| Var(y)) |
| DictVarArg( |
| Var(z)) |
| Block:2( |
| PassStmt:2()))) |
| |
| [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 testTrailingSemicolon] |
| def x(): |
| pass; |
| |
| def y(): |
| pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| x |
| Block:2( |
| PassStmt:2())) |
| FuncDef:4( |
| y |
| Block:5( |
| PassStmt:5()))) |
| |
| [case testEmptySuperClass] |
| class A(): |
| pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| PassStmt:2())) |
| |
| [case testStarExpression] |
| *a |
| *a, b |
| a, *b |
| a, (*x, y) |
| a, (x, *y) |
| [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)))) |
| ExpressionStmt:4( |
| TupleExpr:4( |
| NameExpr(a) |
| TupleExpr:4( |
| StarExpr:4( |
| NameExpr(x)) |
| NameExpr(y)))) |
| ExpressionStmt:5( |
| TupleExpr:5( |
| NameExpr(a) |
| TupleExpr:5( |
| NameExpr(x) |
| StarExpr:5( |
| NameExpr(y)))))) |
| |
| [case testStarExpressionParenthesis] |
| *(a) |
| *(a,b) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| StarExpr:1( |
| NameExpr(a))) |
| ExpressionStmt:2( |
| StarExpr:2( |
| TupleExpr:2( |
| NameExpr(a) |
| NameExpr(b))))) |
| |
| [case testStarExpressionInFor] |
| for *a in b: |
| pass |
| |
| for a, *b in c: |
| pass |
| |
| for *a, b in c: |
| pass |
| [out] |
| MypyFile:1( |
| ForStmt:1( |
| StarExpr:1( |
| NameExpr(a)) |
| NameExpr(b) |
| Block:2( |
| PassStmt:2())) |
| ForStmt:4( |
| TupleExpr:4( |
| NameExpr(a) |
| StarExpr:4( |
| NameExpr(b))) |
| NameExpr(c) |
| Block:5( |
| PassStmt:5())) |
| ForStmt:7( |
| TupleExpr:7( |
| StarExpr:7( |
| NameExpr(a)) |
| NameExpr(b)) |
| NameExpr(c) |
| Block:8( |
| PassStmt:8()))) |
| |
| [case testStarExprInGeneratorExpr] |
| (x for y, *p in z) |
| (x for *p, y in z) |
| (x for y, *p, q in z) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| GeneratorExpr:1( |
| NameExpr(x) |
| TupleExpr:1( |
| NameExpr(y) |
| StarExpr:1( |
| NameExpr(p))) |
| NameExpr(z))) |
| ExpressionStmt:2( |
| GeneratorExpr:2( |
| NameExpr(x) |
| TupleExpr:2( |
| StarExpr:2( |
| NameExpr(p)) |
| NameExpr(y)) |
| NameExpr(z))) |
| ExpressionStmt:3( |
| GeneratorExpr:3( |
| NameExpr(x) |
| TupleExpr:3( |
| NameExpr(y) |
| StarExpr:3( |
| NameExpr(p)) |
| NameExpr(q)) |
| NameExpr(z)))) |
| |
| [case testParseNamedtupleBaseclass] |
| class A(namedtuple('x', ['y'])): pass |
| [out] |
| MypyFile:1( |
| ClassDef:1( |
| A |
| BaseTypeExpr( |
| CallExpr:1( |
| NameExpr(namedtuple) |
| Args( |
| StrExpr(x) |
| ListExpr:1( |
| StrExpr(y))))) |
| PassStmt:1())) |
| |
| [case testEllipsis] |
| ... |
| a[1,...,2] |
| ....__class__ |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| Ellipsis) |
| ExpressionStmt:2( |
| IndexExpr:2( |
| NameExpr(a) |
| TupleExpr:2( |
| IntExpr(1) |
| Ellipsis |
| IntExpr(2)))) |
| ExpressionStmt:3( |
| MemberExpr:3( |
| Ellipsis |
| __class__))) |
| |
| [case testFunctionWithManyKindsOfArgs] |
| def f(x, *args, y=None, **kw): pass |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| MaxPos(1) |
| Args( |
| Var(x) |
| default( |
| Var(y) |
| NameExpr(None))) |
| VarArg( |
| Var(args)) |
| DictVarArg( |
| Var(kw)) |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testIfWithSemicolons] |
| if 1: a; b |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| IntExpr(1)) |
| Then( |
| ExpressionStmt:1( |
| NameExpr(a)) |
| ExpressionStmt:1( |
| NameExpr(b))))) |
| |
| [case testIfWithSemicolonsNested] |
| while 2: |
| if 1: a; b |
| [out] |
| MypyFile:1( |
| WhileStmt:1( |
| IntExpr(2) |
| Block:2( |
| IfStmt:2( |
| If( |
| IntExpr(1)) |
| Then( |
| ExpressionStmt:2( |
| NameExpr(a)) |
| ExpressionStmt:2( |
| NameExpr(b))))))) |
| |
| [case testIfElseWithSemicolons] |
| if 1: global x; y = 1 |
| else: x = 1; return 3 |
| 4 |
| [out] |
| MypyFile:1( |
| IfStmt:1( |
| If( |
| IntExpr(1)) |
| Then( |
| GlobalDecl:1( |
| x) |
| AssignmentStmt:1( |
| NameExpr(y) |
| IntExpr(1))) |
| Else( |
| AssignmentStmt:2( |
| NameExpr(x) |
| IntExpr(1)) |
| ReturnStmt:2( |
| IntExpr(3)))) |
| ExpressionStmt:3( |
| IntExpr(4))) |
| |
| [case testIfElseWithSemicolonsNested] |
| while 2: |
| if 1: global x; y = 1 |
| else: x = 1; return 3 |
| 4 |
| [out] |
| MypyFile:1( |
| WhileStmt:1( |
| IntExpr(2) |
| Block:2( |
| IfStmt:2( |
| If( |
| IntExpr(1)) |
| Then( |
| GlobalDecl:2( |
| x) |
| AssignmentStmt:2( |
| NameExpr(y) |
| IntExpr(1))) |
| Else( |
| AssignmentStmt:3( |
| NameExpr(x) |
| IntExpr(1)) |
| ReturnStmt:3( |
| IntExpr(3)))))) |
| ExpressionStmt:4( |
| IntExpr(4))) |
| |
| [case testKeywordArgumentAfterStarArgumentInCall] |
| f(x=1, *y) |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| CallExpr:1( |
| NameExpr(f) |
| Args( |
| NameExpr(y)) |
| VarArg |
| KwArgs( |
| x |
| IntExpr(1))))) |
| |
| [case testConditionalExpressionInSetComprehension] |
| { 1 if x else 2 for x in y } |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| SetComprehension:1( |
| GeneratorExpr:1( |
| ConditionalExpr:1( |
| Condition( |
| NameExpr(x)) |
| IntExpr(1) |
| IntExpr(2)) |
| NameExpr(x) |
| NameExpr(y))))) |
| |
| [case testConditionalExpressionInListComprehension2] |
| a = [ 1 if x else 2 for x in y ] |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(a) |
| ListComprehension:1( |
| GeneratorExpr:1( |
| ConditionalExpr:1( |
| Condition( |
| NameExpr(x)) |
| IntExpr(1) |
| IntExpr(2)) |
| NameExpr(x) |
| NameExpr(y))))) |
| |
| [case testComplexWithLvalue] |
| with x as y.z: pass |
| [out] |
| MypyFile:1( |
| WithStmt:1( |
| Expr( |
| NameExpr(x)) |
| Target( |
| MemberExpr:1( |
| NameExpr(y) |
| z)) |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testRelativeImportWithEllipsis] |
| from ... import x |
| [out] |
| MypyFile:1( |
| ImportFrom:1(..., [x])) |
| |
| [case testRelativeImportWithEllipsis2] |
| from .... import x |
| [out] |
| MypyFile:1( |
| ImportFrom:1(...., [x])) |
| |
| [case testParseExtendedSlicing] |
| a[:, :] |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| IndexExpr:1( |
| NameExpr(a) |
| TupleExpr:1( |
| SliceExpr:-1( |
| <empty> |
| <empty>) |
| SliceExpr:-1( |
| <empty> |
| <empty>))))) |
| |
| [case testParseExtendedSlicing2] |
| a[1:2:, :,] |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| IndexExpr:1( |
| NameExpr(a) |
| TupleExpr:1( |
| SliceExpr:-1( |
| IntExpr(1) |
| IntExpr(2)) |
| SliceExpr:-1( |
| <empty> |
| <empty>))))) |
| |
| [case testParseExtendedSlicing3] |
| a[1:2:3, ..., 1] |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| IndexExpr:1( |
| NameExpr(a) |
| TupleExpr:1( |
| SliceExpr:-1( |
| IntExpr(1) |
| IntExpr(2) |
| IntExpr(3)) |
| Ellipsis |
| IntExpr(1))))) |
| |
| [case testParseIfExprInDictExpr] |
| test = { 'spam': 'eggs' if True else 'bacon' } |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(test) |
| DictExpr:1( |
| StrExpr(spam) |
| ConditionalExpr:1( |
| Condition( |
| NameExpr(True)) |
| StrExpr(eggs) |
| StrExpr(bacon))))) |
| |
| [case testIgnoreLine] |
| import x # type: ignore |
| [out] |
| MypyFile:1( |
| Import:1(x) |
| IgnoredLines(1)) |
| |
| [case testIgnore2Lines] |
| x |
| y # type: ignore |
| z # type: ignore |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| NameExpr(x)) |
| ExpressionStmt:2( |
| NameExpr(y)) |
| ExpressionStmt:3( |
| NameExpr(z)) |
| IgnoredLines(2, 3)) |
| |
| [case testCommentedOutIgnoreAnnotation] |
| y ## type: ignore |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| NameExpr(y))) |
| |
| [case testSpaceInIgnoreAnnotations] |
| y # type: ignore # foo |
| y #type:ignore |
| [out] |
| MypyFile:1( |
| ExpressionStmt:1( |
| NameExpr(y)) |
| ExpressionStmt:2( |
| NameExpr(y)) |
| IgnoredLines(1, 2)) |
| |
| [case testIgnoreAnnotationAndMultilineStatement] |
| x = { |
| 1: 2 # type: ignore |
| } |
| y = { # type: ignore |
| 1: 2 |
| } # type: ignore |
| [out] |
| MypyFile:1( |
| AssignmentStmt:1( |
| NameExpr(x) |
| DictExpr:1( |
| IntExpr(1) |
| IntExpr(2))) |
| AssignmentStmt:4( |
| NameExpr(y) |
| DictExpr:4( |
| IntExpr(1) |
| IntExpr(2))) |
| IgnoredLines(2, 4, 6)) |
| |
| [case testIgnoreAnnotationAndMultilineStatement2] |
| from m import ( # type: ignore |
| x, y |
| ) |
| [out] |
| MypyFile:1( |
| ImportFrom:1(m, [x, y]) |
| IgnoredLines(1)) |
| |
| [case testYieldExpression] |
| def f(): |
| x = yield f() |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| AssignmentStmt:2( |
| NameExpr(x) |
| YieldExpr:2( |
| CallExpr:2( |
| NameExpr(f) |
| Args())))))) |
| |
| [case testForWithSingleItemTuple] |
| for x in 1,: pass |
| [out] |
| MypyFile:1( |
| ForStmt:1( |
| NameExpr(x) |
| TupleExpr:1( |
| IntExpr(1)) |
| Block:1( |
| PassStmt:1()))) |
| |
| [case testIsoLatinUnixEncoding] |
| # coding: iso-latin-1-unix |
| [out] |
| MypyFile:1() |
| |
| [case testLatinUnixEncoding] |
| # coding: latin-1-unix |
| [out] |
| MypyFile:1() |
| |
| [case testLatinUnixEncoding2] |
| # coding: iso-latin-1 |
| [out] |
| MypyFile:1() |
| |
| [case testYieldExpressionInParens] |
| def f(): |
| (yield) |
| [out] |
| MypyFile:1( |
| FuncDef:1( |
| f |
| Block:2( |
| ExpressionStmt:2( |
| YieldExpr:2())))) |
| |
| [case testFStringSimple] |
| x = 'mypy' |
| f'Hello {x}' |
| [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()))))))) |
| |
| [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 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 testFStringWithFormatSpecifierAndConversion] |
| x = 'mypy' |
| f'Hello {x!s:<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({!s:{}}) |
| 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 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())))) |
