Lines Matching refs:ast
1 import ast
272 if "ast" not in node.__module__:
277 if not isinstance(ast_node, ast.AST) or ast_node._fields is None:
279 if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)):
296 x = ast.AST()
306 # "ast.AST constructor takes 0 positional arguments"
307 ast.AST(2)
312 a = ast.AST()
326 ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)
336 tree = ast.parse(snippet)
347 tree = ast.parse(snippet)
359 tree = ast.parse(snippet)
366 tree = ast.Module(body=[
367 ast.Import(names=[ast.alias(name='builtins', lineno=1, col_offset=0)], lineno=1, col_offset=0),
368 ast.Import(names=[ast.alias(name='traceback', lineno=0, col_offset=0)], lineno=0, col_offset=1)
375 slc = ast.parse("x[::]").body[0].value.slice
381 im = ast.parse("from . import y").body[0]
385 mod = ast.parse("from __future__ import division")
386 self.assertIsInstance(mod.body[0], ast.ImportFrom)
391 im = ast.parse("from bar import y").body[0]
401 im = ast.parse("from bar import *").body[0]
410 im = ast.parse("from bar import y as z").body[0]
419 im = ast.parse("import bar as foo").body[0]
429 self.assertTrue(issubclass(ast.For, ast.stmt))
430 self.assertTrue(issubclass(ast.Name, ast.expr))
431 self.assertTrue(issubclass(ast.stmt, ast.AST))
432 self.assertTrue(issubclass(ast.expr, ast.AST))
433 self.assertTrue(issubclass(ast.comprehension, ast.AST))
434 self.assertTrue(issubclass(ast.Gt, ast.AST))
437 for name, item in ast.__dict__.items():
444 if isinstance(x, ast.AST):
448 x = ast.arguments()
456 x = ast.arguments(*range(1, 8))
461 x = ast.Num()
467 x = ast.Num()
476 x = ast.Num(42)
486 x = ast.Num(lineno=2)
489 x = ast.Num(42, lineno=0)
495 self.assertRaises(TypeError, ast.Num, 1, None, 2)
496 self.assertRaises(TypeError, ast.Num, 1, None, 2, lineno=0)
499 self.assertEqual(ast.Constant(1, foo='bar').foo, 'bar')
500 self.assertEqual(ast.Num(1, foo='bar').foo, 'bar')
503 ast.Num(1, n=2)
505 ast.Constant(1, value=2)
507 self.assertEqual(ast.Num(42).n, 42)
508 self.assertEqual(ast.Num(4.25).n, 4.25)
509 self.assertEqual(ast.Num(4.25j).n, 4.25j)
510 self.assertEqual(ast.Str('42').s, '42')
511 self.assertEqual(ast.Bytes(b'42').s, b'42')
512 self.assertIs(ast.NameConstant(True).value, True)
513 self.assertIs(ast.NameConstant(False).value, False)
514 self.assertIs(ast.NameConstant(None).value, None)
516 self.assertEqual(ast.Constant(42).value, 42)
517 self.assertEqual(ast.Constant(4.25).value, 4.25)
518 self.assertEqual(ast.Constant(4.25j).value, 4.25j)
519 self.assertEqual(ast.Constant('42').value, '42')
520 self.assertEqual(ast.Constant(b'42').value, b'42')
521 self.assertIs(ast.Constant(True).value, True)
522 self.assertIs(ast.Constant(False).value, False)
523 self.assertIs(ast.Constant(None).value, None)
524 self.assertIs(ast.Constant(...).value, ...)
527 self.assertEqual(type(ast.Num(42)), ast.Constant)
528 self.assertEqual(type(ast.Num(4.25)), ast.Constant)
529 self.assertEqual(type(ast.Num(4.25j)), ast.Constant)
530 self.assertEqual(type(ast.Str('42')), ast.Constant)
531 self.assertEqual(type(ast.Bytes(b'42')), ast.Constant)
532 self.assertEqual(type(ast.NameConstant(True)), ast.Constant)
533 self.assertEqual(type(ast.NameConstant(False)), ast.Constant)
534 self.assertEqual(type(ast.NameConstant(None)), ast.Constant)
535 self.assertEqual(type(ast.Ellipsis()), ast.Constant)
538 self.assertTrue(isinstance(ast.Num(42), ast.Num))
539 self.assertTrue(isinstance(ast.Num(4.2), ast.Num))
540 self.assertTrue(isinstance(ast.Num(4.2j), ast.Num))
541 self.assertTrue(isinstance(ast.Str('42'), ast.Str))
542 self.assertTrue(isinstance(ast.Bytes(b'42'), ast.Bytes))
543 self.assertTrue(isinstance(ast.NameConstant(True), ast.NameConstant))
544 self.assertTrue(isinstance(ast.NameConstant(False), ast.NameConstant))
545 self.assertTrue(isinstance(ast.NameConstant(None), ast.NameConstant))
546 self.assertTrue(isinstance(ast.Ellipsis(), ast.Ellipsis))
548 self.assertTrue(isinstance(ast.Constant(42), ast.Num))
549 self.assertTrue(isinstance(ast.Constant(4.2), ast.Num))
550 self.assertTrue(isinstance(ast.Constant(4.2j), ast.Num))
551 self.assertTrue(isinstance(ast.Constant('42'), ast.Str))
552 self.assertTrue(isinstance(ast.Constant(b'42'), ast.Bytes))
553 self.assertTrue(isinstance(ast.Constant(True), ast.NameConstant))
554 self.assertTrue(isinstance(ast.Constant(False), ast.NameConstant))
555 self.assertTrue(isinstance(ast.Constant(None), ast.NameConstant))
556 self.assertTrue(isinstance(ast.Constant(...), ast.Ellipsis))
558 self.assertFalse(isinstance(ast.Str('42'), ast.Num))
559 self.assertFalse(isinstance(ast.Num(42), ast.Str))
560 self.assertFalse(isinstance(ast.Str('42'), ast.Bytes))
561 self.assertFalse(isinstance(ast.Num(42), ast.NameConstant))
562 self.assertFalse(isinstance(ast.Num(42), ast.Ellipsis))
563 self.assertFalse(isinstance(ast.NameConstant(True), ast.Num))
564 self.assertFalse(isinstance(ast.NameConstant(False), ast.Num))
566 self.assertFalse(isinstance(ast.Constant('42'), ast.Num))
567 self.assertFalse(isinstance(ast.Constant(42), ast.Str))
568 self.assertFalse(isinstance(ast.Constant('42'), ast.Bytes))
569 self.assertFalse(isinstance(ast.Constant(42), ast.NameConstant))
570 self.assertFalse(isinstance(ast.Constant(42), ast.Ellipsis))
571 self.assertFalse(isinstance(ast.Constant(True), ast.Num))
572 self.assertFalse(isinstance(ast.Constant(False), ast.Num))
574 self.assertFalse(isinstance(ast.Constant(), ast.Num))
575 self.assertFalse(isinstance(ast.Constant(), ast.Str))
576 self.assertFalse(isinstance(ast.Constant(), ast.Bytes))
577 self.assertFalse(isinstance(ast.Constant(), ast.NameConstant))
578 self.assertFalse(isinstance(ast.Constant(), ast.Ellipsis))
581 self.assertTrue(isinstance(ast.Constant(S('42')), ast.Str))
582 self.assertFalse(isinstance(ast.Constant(S('42')), ast.Num))
585 class N(ast.Num):
589 class N2(ast.Num):
597 self.assertTrue(isinstance(n, ast.Num))
599 self.assertFalse(isinstance(ast.Num(42), N))
605 body = [ast.Num(42)]
606 x = ast.Module(body, [])
611 x = ast.BinOp()
618 n1 = ast.Num(1)
619 n3 = ast.Num(3)
620 addop = ast.Add()
621 x = ast.BinOp(n1, addop, n3)
626 x = ast.BinOp(1, 2, 3)
631 x = ast.BinOp(1, 2, 3, lineno=0)
638 self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4)
640 self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4, lineno=0)
643 x = ast.BinOp(left=1, op=2, right=3, lineno=0)
650 x = ast.BinOp(1, 2, 3, foobarbaz=42)
655 x = ast.Sub()
669 for ast in (compile(i, "?", "exec", 0x400) for i in exec_tests):
670 ast2 = mod.loads(mod.dumps(ast, protocol))
671 self.assertEqual(to_tuple(ast2), to_tuple(ast))
675 m = ast.Module([ast.Expr(ast.expr(**pos), **pos)], [])
678 self.assertIn("but got <ast.expr", str(cm.exception))
681 m = ast.Module([ast.Expr(ast.Name(42, ast.Load()))], [])
682 ast.fix_missing_locations(m)
689 e = ast.Expression(body=ast.Constant(invalid_constant))
690 ast.fix_missing_locations(e)
698 empty_yield_from = ast.parse("def f():\n yield from g()")
712 self.assertRaises(TypeError, ast.parse, '\u03D5')
715 tree = ast.parse('4+5+6+7')
726 tree = ast.parse('4+5-\\\n 6-7')
746 tree = ast.parse('@a.b.c\ndef f(): pass')
751 self.assertEqual(ast.withitem.__doc__, "withitem(expr context_expr, expr? optional_vars)")
752 self.assertEqual(ast.GtE.__doc__, "GtE")
753 self.assertEqual(ast.Name.__doc__, "Name(identifier id, expr_context ctx)")
754 self.assertEqual(ast.cmpop.__doc__, "cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn")
755 expressions = [f" | {node.__doc__}" for node in ast.expr.__subclasses__()]
756 expressions[0] = f"expr = {ast.expr.__subclasses__()[0].__doc__}"
757 self.assertCountEqual(ast.expr.__doc__.split("\n"), expressions)
760 ast.parse('def foo(x, /): ...', feature_version=(3, 8))
761 ast.parse('def bar(x=1, /): ...', feature_version=(3, 8))
763 ast.parse('def foo(x, /): ...', feature_version=(3, 7))
765 ast.parse('def bar(x=1, /): ...', feature_version=(3, 7))
767 ast.parse('lambda x, /: ...', feature_version=(3, 8))
768 ast.parse('lambda x=1, /: ...', feature_version=(3, 8))
770 ast.parse('lambda x, /: ...', feature_version=(3, 7))
772 ast.parse('lambda x=1, /: ...', feature_version=(3, 7))
775 ast.parse('with (CtxManager() as example): ...', feature_version=(3, 10))
777 ast.parse('with (CtxManager() as example): ...', feature_version=(3, 9))
779 ast.parse('with (CtxManager() as example): ...', feature_version=(3, 8))
780 ast.parse('with CtxManager() as example: ...', feature_version=(3, 8))
783 ast.parse('f"{x=}"', feature_version=(3, 8))
785 ast.parse('f"{x=}"', feature_version=(3, 7))
788 ast.parse('(x := 0)', feature_version=(3, 8))
790 ast.parse('(x := 0)', feature_version=(3, 7))
797 ast.parse(code)
799 ast.parse(code, feature_version=(3, 10))
803 expr = ast.Expression(ast.Name(constant, ast.Load()))
804 ast.fix_missing_locations(expr)
836 enum._test_simple_enum(_Precedence, ast._Precedence)
846 ast.parse(expect_ok)
853 ast.parse(broken)
863 ast.parse("a\0b")
869 a = ast.parse('foo(1 + 1)')
870 b = compile('foo(1 + 1)', '<unknown>', 'exec', ast.PyCF_ONLY_AST)
871 self.assertEqual(ast.dump(a), ast.dump(b))
878 ast.literal_eval(r"'\U'")
882 node = ast.parse('spam(eggs, "and cheese")')
883 self.assertEqual(ast.dump(node),
888 self.assertEqual(ast.dump(node, annotate_fields=False),
892 self.assertEqual(ast.dump(node, include_attributes=True),
903 node = ast.parse('spam(eggs, "and cheese")')
904 self.assertEqual(ast.dump(node, indent=3), """\
915 self.assertEqual(ast.dump(node, annotate_fields=False, indent='\t'), """\
926 self.assertEqual(ast.dump(node, include_attributes=True, indent=3), """\
964 node = ast.Raise(lineno=3, col_offset=4)
965 self.assertEqual(ast.dump(node),
968 self.assertEqual(ast.dump(node, include_attributes=True),
971 node = ast.Raise(exc=ast.Name(id='e', ctx=ast.Load()), lineno=3, col_offset=4)
972 self.assertEqual(ast.dump(node),
975 self.assertEqual(ast.dump(node, annotate_fields=False),
978 self.assertEqual(ast.dump(node, include_attributes=True),
981 self.assertEqual(ast.dump(node, annotate_fields=False, include_attributes=True),
984 node = ast.Raise(cause=ast.Name(id='e', ctx=ast.Load()))
985 self.assertEqual(ast.dump(node),
988 self.assertEqual(ast.dump(node, annotate_fields=False),
993 src = ast.parse('1 + 1', mode='eval')
994 src.body.right = ast.copy_location(ast.Num(2), src.body.right)
995 self.assertEqual(ast.dump(src, include_attributes=True),
1001 src = ast.Call(col_offset=1, lineno=1, end_lineno=1, end_col_offset=1)
1002 new = ast.copy_location(src, ast.Call(col_offset=None, lineno=None))
1009 src = ast.parse('write("spam")')
1010 src.body.append(ast.Expr(ast.Call(ast.Name('spam', ast.Load()),
1011 [ast.Str('eggs')], [])))
1012 self.assertEqual(src, ast.fix_missing_locations(src))
1014 self.assertEqual(ast.dump(src, include_attributes=True),
1029 src = ast.parse('1 + 1', mode='eval')
1030 self.assertEqual(ast.increment_lineno(src, n=3), src)
1031 self.assertEqual(ast.dump(src, include_attributes=True),
1038 src = ast.parse('1 + 1', mode='eval')
1039 self.assertEqual(ast.increment_lineno(src.body, n=3), src.body)
1040 self.assertEqual(ast.dump(src, include_attributes=True),
1046 src = ast.Call(
1047 func=ast.Name("test", ast.Load()), args=[], keywords=[], lineno=1
1049 self.assertEqual(ast.increment_lineno(src).lineno, 2)
1050 self.assertIsNone(ast.increment_lineno(src).end_lineno)
1053 src = ast.parse(dedent("""\
1059 ast.increment_lineno(src, n=5)
1065 node = ast.parse('foo()', mode='eval')
1066 d = dict(ast.iter_fields(node.body))
1071 node = ast.parse("spam(23, 42, eggs='leek')", mode='eval')
1072 self.assertEqual(len(list(ast.iter_child_nodes(node.body))), 4)
1073 iterator = ast.iter_child_nodes(node.body)
1077 self.assertEqual(ast.dump(next(iterator)),
1082 node = ast.parse('"""line one\n line two"""')
1083 self.assertEqual(ast.get_docstring(node),
1086 node = ast.parse('class foo:\n """line one\n line two"""')
1087 self.assertEqual(ast.get_docstring(node.body[0]),
1090 node = ast.parse('def foo():\n """line one\n line two"""')
1091 self.assertEqual(ast.get_docstring(node.body[0]),
1094 node = ast.parse('async def foo():\n """spam\n ham"""')
1095 self.assertEqual(ast.get_docstring(node.body[0]), 'spam\nham')
1098 self.assertIsNone(ast.get_docstring(ast.parse('')))
1099 node = ast.parse('x = "not docstring"')
1100 self.assertIsNone(ast.get_docstring(node))
1101 node = ast.parse('def foo():\n pass')
1102 self.assertIsNone(ast.get_docstring(node))
1104 node = ast.parse('class foo:\n pass')
1105 self.assertIsNone(ast.get_docstring(node.body[0]))
1106 node = ast.parse('class foo:\n x = "not docstring"')
1107 self.assertIsNone(ast.get_docstring(node.body[0]))
1108 node = ast.parse('class foo:\n def bar(self): pass')
1109 self.assertIsNone(ast.get_docstring(node.body[0]))
1111 node = ast.parse('def foo():\n pass')
1112 self.assertIsNone(ast.get_docstring(node.body[0]))
1113 node = ast.parse('def foo():\n x = "not docstring"')
1114 self.assertIsNone(ast.get_docstring(node.body[0]))
1116 node = ast.parse('async def foo():\n pass')
1117 self.assertIsNone(ast.get_docstring(node.body[0]))
1118 node = ast.parse('async def foo():\n x = "not docstring"')
1119 self.assertIsNone(ast.get_docstring(node.body[0]))
1122 node = ast.parse(
1141 node = ast.parse('if a:\n pass\nelif b:\n pass\n')
1147 node = ast.parse('if a:\n pass\nelif b:\n pass\nelse:\n pass\n')
1153 node = ast.parse('f(*[0, 1])')
1159 self.assertEqual(ast.literal_eval('[1, 2, 3]'), [1, 2, 3])
1160 self.assertEqual(ast.literal_eval('{"foo": 42}'), {"foo": 42})
1161 self.assertEqual(ast.literal_eval('(True, False, None)'), (True, False, None))
1162 self.assertEqual(ast.literal_eval('{1, 2, 3}'), {1, 2, 3})
1163 self.assertEqual(ast.literal_eval('b"hi"'), b"hi")
1164 self.assertEqual(ast.literal_eval('set()'), set())
1165 self.assertRaises(ValueError, ast.literal_eval, 'foo()')
1166 self.assertEqual(ast.literal_eval('6'), 6)
1167 self.assertEqual(ast.literal_eval('+6'), 6)
1168 self.assertEqual(ast.literal_eval('-6'), -6)
1169 self.assertEqual(ast.literal_eval('3.25'), 3.25)
1170 self.assertEqual(ast.literal_eval('+3.25'), 3.25)
1171 self.assertEqual(ast.literal_eval('-3.25'), -3.25)
1172 self.assertEqual(repr(ast.literal_eval('-0.0')), '-0.0')
1173 self.assertRaises(ValueError, ast.literal_eval, '++6')
1174 self.assertRaises(ValueError, ast.literal_eval, '+True')
1175 self.assertRaises(ValueError, ast.literal_eval, '2+3')
1179 ast.literal_eval('3'*4000) # no error
1181 ast.literal_eval('3'*4001)
1187 self.assertEqual(ast.literal_eval('6j'), 6j)
1188 self.assertEqual(ast.literal_eval('-6j'), -6j)
1189 self.assertEqual(ast.literal_eval('6.75j'), 6.75j)
1190 self.assertEqual(ast.literal_eval('-6.75j'), -6.75j)
1191 self.assertEqual(ast.literal_eval('3+6j'), 3+6j)
1192 self.assertEqual(ast.literal_eval('-3+6j'), -3+6j)
1193 self.assertEqual(ast.literal_eval('3-6j'), 3-6j)
1194 self.assertEqual(ast.literal_eval('-3-6j'), -3-6j)
1195 self.assertEqual(ast.literal_eval('3.25+6.75j'), 3.25+6.75j)
1196 self.assertEqual(ast.literal_eval('-3.25+6.75j'), -3.25+6.75j)
1197 self.assertEqual(ast.literal_eval('3.25-6.75j'), 3.25-6.75j)
1198 self.assertEqual(ast.literal_eval('-3.25-6.75j'), -3.25-6.75j)
1199 self.assertEqual(ast.literal_eval('(3+6j)'), 3+6j)
1200 self.assertRaises(ValueError, ast.literal_eval, '-6j+3')
1201 self.assertRaises(ValueError, ast.literal_eval, '-6j+3j')
1202 self.assertRaises(ValueError, ast.literal_eval, '3+-6j')
1203 self.assertRaises(ValueError, ast.literal_eval, '3+(0+6j)')
1204 self.assertRaises(ValueError, ast.literal_eval, '-(3+6j)')
1207 malformed = ast.Dict(keys=[ast.Constant(1), ast.Constant(2)], values=[ast.Constant(3)])
1208 self.assertRaises(ValueError, ast.literal_eval, malformed)
1209 malformed = ast.Dict(keys=[ast.Constant(1)], values=[ast.Constant(2), ast.Constant(3)])
1210 self.assertRaises(ValueError, ast.literal_eval, malformed)
1213 self.assertEqual(ast.literal_eval(" -1"), -1)
1214 self.assertEqual(ast.literal_eval("\t\t-1"), -1)
1215 self.assertEqual(ast.literal_eval(" \t -1"), -1)
1216 self.assertRaises(IndentationError, ast.literal_eval, "\n -1")
1221 ast.literal_eval("{'a': 1,\n'b':2,\n'c':++3,\n'd':4}")
1223 node = ast.UnaryOp(
1224 ast.UAdd(), ast.UnaryOp(ast.UAdd(), ast.Constant(6)))
1228 ast.literal_eval(node)
1232 ast.literal_eval(r'''
1239 body = [ast.ImportFrom(module='time',
1240 names=[ast.alias(name='sleep')],
1243 mod = ast.Module(body, [])
1249 body = [ast.ImportFrom(module='time',
1250 names=[ast.alias(name='sleep',
1254 mod = ast.Module(body, [])
1261 e = ast.UnaryOp(op=ast.Not(), lineno=0, col_offset=0)
1265 compile(ast.Expression(e), "<test>", "eval")
1268 e = ast.UnaryOp(op=ast.Not(), lineno=0, col_offset=0)
1269 f = ast.UnaryOp(op=ast.Not(), lineno=0, col_offset=0)
1274 compile(ast.Expression(e), "<test>", "eval")
1281 ast.fix_missing_locations(mod)
1290 mod = ast.Module([ast.Expr(node)], [])
1294 mod = ast.Module([stmt], [])
1298 m = ast.Interactive([ast.Expr(ast.Name("x", ast.Store()))])
1300 m = ast.Expression(ast.Name("x", ast.Store()))
1317 args = ast.arguments(args, posonlyargs, vararg, kwonlyargs,
1320 args = [ast.arg("x", ast.Name("x", ast.Store()))]
1324 check(arguments(defaults=[ast.Num(3)]),
1326 check(arguments(kw_defaults=[ast.Num(4)]),
1328 args = [ast.arg("x", ast.Name("x", ast.Load()))]
1329 check(arguments(args=args, defaults=[ast.Name("x", ast.Store())]),
1331 args = [ast.arg("a", ast.Name("x", ast.Load())),
1332 ast.arg("b", ast.Name("y", ast.Load()))]
1334 kw_defaults=[None, ast.Name("x", ast.Store())]),
1338 a = ast.arguments([], [], None, [], [], None, [])
1339 f = ast.FunctionDef("x", a, [], [], None)
1341 f = ast.FunctionDef("x", a, [ast.Pass()], [ast.Name("x", ast.Store())],
1344 f = ast.FunctionDef("x", a, [ast.Pass()], [],
1345 ast.Name("x", ast.Store()))
1348 return ast.FunctionDef("x", args, [ast.Pass()], [], None)
1358 body = [ast.Pass()]
1361 return ast.ClassDef("myclass", bases, keywords,
1363 self.stmt(cls(bases=[ast.Name("x", ast.Store())]),
1365 self.stmt(cls(keywords=[ast.keyword("x", ast.Name("x", ast.Store()))]),
1369 self.stmt(cls(decorator_list=[ast.Name("x", ast.Store())]),
1373 self.stmt(ast.Delete([]), "empty targets on Delete")
1374 self.stmt(ast.Delete([None]), "None disallowed")
1375 self.stmt(ast.Delete([ast.Name("x", ast.Load())]),
1379 self.stmt(ast.Assign([], ast.Num(3)), "empty targets on Assign")
1380 self.stmt(ast.Assign([None], ast.Num(3)), "None disallowed")
1381 self.stmt(ast.Assign([ast.Name("x", ast.Load())], ast.Num(3)),
1383 self.stmt(ast.Assign([ast.Name("x", ast.Store())],
1384 ast.Name("y", ast.Store())),
1388 aug = ast.AugAssign(ast.Name("x", ast.Load()), ast.Add(),
1389 ast.Name("y", ast.Load()))
1391 aug = ast.AugAssign(ast.Name("x", ast.Store()), ast.Add(),
1392 ast.Name("y", ast.Store()))
1396 x = ast.Name("x", ast.Store())
1397 y = ast.Name("y", ast.Load())
1398 p = ast.Pass()
1399 self.stmt(ast.For(x, y, [], []), "empty body on For")
1400 self.stmt(ast.For(ast.Name("x", ast.Load()), y, [p], []),
1402 self.stmt(ast.For(x, ast.Name("y", ast.Store()), [p], []),
1404 e = ast.Expr(ast.Name("x", ast.Store()))
1405 self.stmt(ast.For(x, y, [e], []), "must have Load context")
1406 self.stmt(ast.For(x, y, [p], [e]), "must have Load context")
1409 self.stmt(ast.While(ast.Num(3), [], []), "empty body on While")
1410 self.stmt(ast.While(ast.Name("x", ast.Store()), [ast.Pass()], []),
1412 self.stmt(ast.While(ast.Num(3), [ast.Pass()],
1413 [ast.Expr(ast.Name("x", ast.Store()))]),
1417 self.stmt(ast.If(ast.Num(3), [], []), "empty body on If")
1418 i = ast.If(ast.Name("x", ast.Store()), [ast.Pass()], [])
1420 i = ast.If(ast.Num(3), [ast.Expr(ast.Name("x", ast.Store()))], [])
1422 i = ast.If(ast.Num(3), [ast.Pass()],
1423 [ast.Expr(ast.Name("x", ast.Store()))])
1427 p = ast.Pass()
1428 self.stmt(ast.With([], [p]), "empty items on With")
1429 i = ast.withitem(ast.Num(3), None)
1430 self.stmt(ast.With([i], []), "empty body on With")
1431 i = ast.withitem(ast.Name("x", ast.Store()), None)
1432 self.stmt(ast.With([i], [p]), "must have Load context")
1433 i = ast.withitem(ast.Num(3), ast.Name("x", ast.Load()))
1434 self.stmt(ast.With([i], [p]), "must have Store context")
1437 r = ast.Raise(None, ast.Num(3))
1439 r = ast.Raise(ast.Name("x", ast.Store()), None)
1441 r = ast.Raise(ast.Num(4), ast.Name("x", ast.Store()))
1445 p = ast.Pass()
1446 t = ast.Try([], [], [], [p])
1448 t = ast.Try([ast.Expr(ast.Name("x", ast.Store()))], [], [], [p])
1450 t = ast.Try([p], [], [], [])
1452 t = ast.Try([p], [], [p], [p])
1454 t = ast.Try([p], [ast.ExceptHandler(None, "x", [])], [], [])
1456 e = [ast.ExceptHandler(ast.Name("x", ast.Store()), "y", [p])]
1457 self.stmt(ast.Try([p], e, [], []), "must have Load context")
1458 e = [ast.ExceptHandler(None, "x", [p])]
1459 t = ast.Try([p], e, [ast.Expr(ast.Name("x", ast.Store()))], [p])
1461 t = ast.Try([p], e, [p], [ast.Expr(ast.Name("x", ast.Store()))])
1465 p = ast.Pass()
1466 t = ast.TryStar([], [], [], [p])
1468 t = ast.TryStar([ast.Expr(ast.Name("x", ast.Store()))], [], [], [p])
1470 t = ast.TryStar([p], [], [], [])
1472 t = ast.TryStar([p], [], [p], [p])
1474 t = ast.TryStar([p], [ast.ExceptHandler(None, "x", [])], [], [])
1476 e = [ast.ExceptHandler(ast.Name("x", ast.Store()), "y", [p])]
1477 self.stmt(ast.TryStar([p], e, [], []), "must have Load context")
1478 e = [ast.ExceptHandler(None, "x", [p])]
1479 t = ast.TryStar([p], e, [ast.Expr(ast.Name("x", ast.Store()))], [p])
1481 t = ast.TryStar([p], e, [p], [ast.Expr(ast.Name("x", ast.Store()))])
1485 self.stmt(ast.Assert(ast.Name("x", ast.Store()), None),
1487 assrt = ast.Assert(ast.Name("x", ast.Load()),
1488 ast.Name("y", ast.Store()))
1492 self.stmt(ast.Import([]), "empty names on Import")
1495 imp = ast.ImportFrom(None, [ast.alias("x", None)], -42)
1497 self.stmt(ast.ImportFrom(None, [], 0), "empty names on ImportFrom")
1500 self.stmt(ast.Global([]), "empty names on Global")
1503 self.stmt(ast.Nonlocal([]), "empty names on Nonlocal")
1506 e = ast.Expr(ast.Name("x", ast.Store()))
1510 b = ast.BoolOp(ast.And(), [])
1512 b = ast.BoolOp(ast.And(), [ast.Num(3)])
1514 b = ast.BoolOp(ast.And(), [ast.Num(4), None])
1516 b = ast.BoolOp(ast.And(), [ast.Num(4), ast.Name("x", ast.Store())])
1520 u = ast.UnaryOp(ast.Not(), ast.Name("x", ast.Store()))
1524 a = ast.arguments([], [], None, [], [], None, [])
1525 self.expr(ast.Lambda(a, ast.Name("x", ast.Store())),
1528 return ast.Lambda(args, ast.Name("x", ast.Load()))
1532 l = ast.Name("x", ast.Load())
1533 s = ast.Name("y", ast.Store())
1535 self.expr(ast.IfExp(*args), "must have Load context")
1538 d = ast.Dict([], [ast.Name("x", ast.Load())])
1540 d = ast.Dict([ast.Name("x", ast.Load())], [None])
1544 self.expr(ast.Set([None]), "None disallowed")
1545 s = ast.Set([ast.Name("x", ast.Store())])
1550 g = ast.comprehension(ast.Name("x", ast.Load()),
1551 ast.Name("x", ast.Load()), [], 0)
1553 g = ast.comprehension(ast.Name("x", ast.Store()),
1554 ast.Name("x", ast.Store()), [], 0)
1556 x = ast.Name("x", ast.Store())
1557 y = ast.Name("y", ast.Load())
1558 g = ast.comprehension(x, y, [None], 0)
1560 g = ast.comprehension(x, y, [ast.Name("x", ast.Store())], 0)
1564 g = ast.comprehension(ast.Name("x", ast.Store()),
1565 ast.Name("x", ast.Load()), [], 0)
1566 self.expr(fac(ast.Name("x", ast.Store()), [g]),
1569 return fac(ast.Name("x", ast.Store()), gens)
1573 self._simple_comp(ast.ListComp)
1576 self._simple_comp(ast.SetComp)
1579 self._simple_comp(ast.GeneratorExp)
1582 g = ast.comprehension(ast.Name("y", ast.Store()),
1583 ast.Name("p", ast.Load()), [], 0)
1584 c = ast.DictComp(ast.Name("x", ast.Store()),
1585 ast.Name("y", ast.Load()), [g])
1587 c = ast.DictComp(ast.Name("x", ast.Load()),
1588 ast.Name("y", ast.Store()), [g])
1591 k = ast.Name("x", ast.Load())
1592 v = ast.Name("y", ast.Load())
1593 return ast.DictComp(k, v, comps)
1597 self.expr(ast.Yield(ast.Name("x", ast.Store())), "must have Load")
1598 self.expr(ast.YieldFrom(ast.Name("x", ast.Store())), "must have Load")
1601 left = ast.Name("x", ast.Load())
1602 comp = ast.Compare(left, [ast.In()], [])
1604 comp = ast.Compare(left, [ast.In()], [ast.Num(4), ast.Num(5)])
1606 comp = ast.Compare(ast.Num("blah"), [ast.In()], [left])
1608 comp = ast.Compare(left, [ast.In()], [ast.Num("blah")])
1612 func = ast.Name("x", ast.Load())
1613 args = [ast.Name("y", ast.Load())]
1614 keywords = [ast.keyword("w", ast.Name("z", ast.Load()))]
1615 call = ast.Call(ast.Name("x", ast.Store()), args, keywords)
1617 call = ast.Call(func, [None], keywords)
1619 bad_keywords = [ast.keyword("w", ast.Name("z", ast.Store()))]
1620 call = ast.Call(func, args, bad_keywords)
1631 self.expr(ast.Num(obj))
1633 self.expr(ast.Num(obj), "invalid type", exc=TypeError)
1636 attr = ast.Attribute(ast.Name("x", ast.Store()), "y", ast.Load())
1640 sub = ast.Subscript(ast.Name("x", ast.Store()), ast.Num(3),
1641 ast.Load())
1643 x = ast.Name("x", ast.Load())
1644 sub = ast.Subscript(x, ast.Name("y", ast.Store()),
1645 ast.Load())
1647 s = ast.Name("x", ast.Store())
1649 sl = ast.Slice(*args)
1650 self.expr(ast.Subscript(x, sl, ast.Load()),
1652 sl = ast.Tuple([], ast.Load())
1653 self.expr(ast.Subscript(x, sl, ast.Load()))
1654 sl = ast.Tuple([s], ast.Load())
1655 self.expr(ast.Subscript(x, sl, ast.Load()), "must have Load context")
1658 left = ast.List([ast.Starred(ast.Name("x", ast.Load()), ast.Store())],
1659 ast.Store())
1660 assign = ast.Assign([left], ast.Num(4))
1664 self.expr(fac([None], ast.Load()), "None disallowed")
1665 self.expr(fac([ast.Name("x", ast.Store())], ast.Load()),
1669 self._sequence(ast.List)
1672 self._sequence(ast.Tuple)
1675 self.expr(ast.NameConstant(4))
1678 stdlib = os.path.dirname(ast.__file__)
1686 mod = ast.parse(source, fn)
1689 constant_1 = ast.Constant(1)
1690 pattern_1 = ast.MatchValue(constant_1)
1692 constant_x = ast.Constant('x')
1693 pattern_x = ast.MatchValue(constant_x)
1695 constant_true = ast.Constant(True)
1696 pattern_true = ast.MatchSingleton(True)
1698 name_carter = ast.Name('carter', ast.Load())
1701 ast.MatchValue(
1702 ast.Attribute(
1703 ast.Attribute(
1704 ast.Name('x', ast.Store()),
1705 'y', ast.Load()
1707 'z', ast.Load()
1710 ast.MatchValue(
1711 ast.Attribute(
1712 ast.Attribute(
1713 ast.Name('x', ast.Load()),
1714 'y', ast.Store()
1716 'z', ast.Load()
1719 ast.MatchValue(
1720 ast.Constant(...)
1722 ast.MatchValue(
1723 ast.Constant(True)
1725 ast.MatchValue(
1726 ast.Constant((1,2,3))
1728 ast.MatchSingleton('string'),
1729 ast.MatchSequence([
1730 ast.MatchSingleton('string')
1732 ast.MatchSequence(
1734 ast.MatchSequence(
1736 ast.MatchSingleton('string')
1741 ast.MatchMapping(
1745 ast.MatchMapping(
1750 ast.MatchMapping(
1751 [constant_true, ast.Starred(ast.Name('lol', ast.Load()), ast.Load())],
1755 ast.MatchClass(
1756 ast.Attribute(
1757 ast.Attribute(
1759 'y', ast.Load()),
1760 'z', ast.Load()),
1763 ast.MatchClass(
1769 ast.MatchClass(
1775 ast.MatchClass(
1777 patterns=[ast.MatchSingleton('string')],
1781 ast.MatchClass(
1783 patterns=[ast.MatchStar()],
1787 ast.MatchClass(
1791 kwd_patterns=[ast.MatchStar()]
1793 ast.MatchClass(
1799 ast.MatchSequence(
1801 ast.MatchStar("True")
1804 ast.MatchAs(
1807 ast.MatchOr(
1810 ast.MatchOr(
1813 ast.MatchOr(
1814 [pattern_1, pattern_x, ast.MatchSingleton('xxx')]
1816 ast.MatchAs(name="_"),
1817 ast.MatchStar(name="x"),
1818 ast.MatchSequence([ast.MatchStar("_")]),
1819 ast.MatchMapping([], [], rest="_"),
1823 name_x = ast.Name('x', ast.Load())
1825 with self.subTest(ast.dump(pattern, indent=4)):
1826 node = ast.Match(
1829 ast.match_case(
1831 body = [ast.Pass()]
1835 node = ast.fix_missing_locations(node)
1836 module = ast.Module([node], [])
1842 """Tests on the ast.Constant node type."""
1845 tree = ast.parse("x = 123")
1848 new_node = ast.Constant(value=value)
1849 ast.copy_location(new_node, node)
1886 tree = ast.parse("x = 1")
1889 new_target = ast.Constant(value=1)
1890 ast.copy_location(new_target, target)
1900 tree = ast.parse("'docstring'\nx = 1")
1901 self.assertEqual(ast.get_docstring(tree), 'docstring')
1928 tree = ast.parse(code)
1934 assert isinstance(assign, ast.Assign), ast.dump(assign)
1935 new_node = ast.Constant(value=const)
1936 ast.copy_location(new_node, assign.value)
1943 tree = ast.parse("1 + 2")
1946 new_left = ast.Constant(value=10)
1947 ast.copy_location(new_left, binop.left)
1950 new_right = ast.Constant(value=20j)
1951 ast.copy_location(new_right, binop.right)
1954 self.assertEqual(ast.literal_eval(binop), 10+20j)
1957 c = ast.parse('"x"', mode='eval').body
1961 c = ast.parse('u"x"', mode='eval').body
1965 c = ast.parse('r"x"', mode='eval').body
1969 c = ast.parse('b"x"', mode='eval').body
1985 self.assertEqual(ast.get_source_segment(source, ast_node), content)
1990 return ast.parse(s).body[0].value
2007 fdef = ast.parse(s).body[0]
2033 cdef = ast.parse(s).body[0]
2040 cdef = ast.parse(s).body[0]
2049 assign = ast.parse(s).body[0]
2058 assign = ast.parse(s).body[0]
2086 mod = ast.parse(s)
2134 imp = ast.parse(s).body[0]
2173 bop = ast.parse(s).body[0].test
2201 v = ast.parse(s).body[0].value
2205 v = ast.parse(s2).body[0].value.value
2218 v = ast.parse(s).body[0].value
2222 v = ast.parse(s2).body[0].value.value
2255 fdef = ast.parse(s).body[0]
2271 self.assertEqual(ast.get_source_segment(s_orig, binop.left), s_tuple)
2281 cdef = ast.parse(s_orig).body[0]
2282 self.assertEqual(ast.get_source_segment(s_orig, cdef.body[0], padded=True),
2287 v, w, x, y, z = ast.parse(s).body
2303 cdef = ast.parse(s).body[0]
2304 self.assertEqual(ast.get_source_segment(s, cdef.body[0], padded=True), s_method)
2308 v, w, x, y = ast.parse(s).body
2313 self.assertIsNone(ast.get_source_segment(s, v))
2314 self.assertIsNone(ast.get_source_segment(s, w))
2315 self.assertIsNone(ast.get_source_segment(s, x))
2316 self.assertIsNone(ast.get_source_segment(s, y))
2320 class Visitor(ast.NodeVisitor):
2331 mod = ast.parse(dedent('''\
2379 ast_tree = compile(code, filename, mode, flags=ast.PyCF_ONLY_AST)
2429 import ast
2436 flags=ast.PyCF_ONLY_AST)
2442 del ast, _ast
2443 del sys.modules['ast'], sys.modules['_ast']
2458 tree = ast.parse(statement, "?", kind)