maxDiff = None

def _is_ast_node(self, name, node):

if not isinstance(node, type):

return False

if "ast" not in node.__module__:

return False

return name != 'AST' and name[0].isupper()

def _assertTrueorder(self, ast_node, parent_pos):

if not isinstance(ast_node, ast.AST) or ast_node._fields is None:

return

if isinstance(ast_node, (ast.expr, ast.stmt, ast.excepthandler)):

node_pos = (ast_node.lineno, ast_node.col_offset)

self.assertGreaterEqual(node_pos, parent_pos)

parent_pos = (ast_node.lineno, ast_node.col_offset)

for name in ast_node._fields:

value = getattr(ast_node, name)

if isinstance(value, list):

first_pos = parent_pos

if value and name == 'decorator_list':

first_pos = (value[0].lineno, value[0].col_offset)

for child in value:

self._assertTrueorder(child, first_pos)

elif value is not None:

self._assertTrueorder(value, parent_pos)

self.assertEqual(ast_node._fields, ast_node.__match_args__)

def test_AST_objects(self):

x = ast.AST()

self.assertEqual(x._fields, ())

x.foobar = 42

self.assertEqual(x.foobar, 42)

self.assertEqual(x.__dict__["foobar"], 42)

with self.assertRaises(AttributeError):

x.vararg

with self.assertRaises(TypeError):

# "ast.AST constructor takes 0 positional arguments"

ast.AST(2)

def test_AST_fields_NULL_check(self):

# See: https://github.com/python/cpython/issues/126105

old_value = ast.AST._fields

def cleanup():

ast.AST._fields = old_value

self.addCleanup(cleanup)

del ast.AST._fields

msg = "type object 'ast.AST' has no attribute '_fields'"

# Both examples used to crash:

with self.assertRaisesRegex(AttributeError, msg):

ast.AST(arg1=123)

with self.assertRaisesRegex(AttributeError, msg):

ast.AST()

def test_AST_garbage_collection(self):

class X:

pass

a = ast.AST()

a.x = X()

a.x.a = a

ref = weakref.ref(a.x)

del a

support.gc_collect()

self.assertIsNone(ref())

def test_snippets(self):

for input, output, kind in ((exec_tests, exec_results, "exec"),

(single_tests, single_results, "single"),

(eval_tests, eval_results, "eval")):

for i, o in zip(input, output):

with self.subTest(action="parsing", input=i):

ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST)

self.assertEqual(to_tuple(ast_tree), o)

self._assertTrueorder(ast_tree, (0, 0))

with self.subTest(action="compiling", input=i, kind=kind):

compile(ast_tree, "?", kind)

def test_ast_validation(self):

# compile() is the only function that calls PyAST_Validate

snippets_to_validate = exec_tests + single_tests + eval_tests

for snippet in snippets_to_validate:

tree = ast.parse(snippet)

compile(tree, '<string>', 'exec')

def test_parse_invalid_ast(self):

# see gh-130139

for optval in (-1, 0, 1, 2):

self.assertRaises(TypeError, ast.parse, ast.Constant(42),

optimize=optval)

def test_optimization_levels__debug__(self):

cases = [(-1, '__debug__'), (0, '__debug__'), (1, False), (2, False)]

for (optval, expected) in cases:

with self.subTest(optval=optval, expected=expected):

res1 = ast.parse("__debug__", optimize=optval)

res2 = ast.parse(ast.parse("__debug__"), optimize=optval)

for res in [res1, res2]:

self.assertIsInstance(res.body[0], ast.Expr)

if isinstance(expected, bool):

self.assertIsInstance(res.body[0].value, ast.Constant)

self.assertEqual(res.body[0].value.value, expected)

else:

self.assertIsInstance(res.body[0].value, ast.Name)

self.assertEqual(res.body[0].value.id, expected)

def test_invalid_position_information(self):

invalid_linenos = [

(10, 1), (-10, -11), (10, -11), (-5, -2), (-5, 1)

]

for lineno, end_lineno in invalid_linenos:

with self.subTest(f"Check invalid linenos {lineno}:{end_lineno}"):

snippet = "a = 1"

tree = ast.parse(snippet)

tree.body[0].lineno = lineno

tree.body[0].end_lineno = end_lineno

with self.assertRaises(ValueError):

compile(tree, '<string>', 'exec')

invalid_col_offsets = [

(10, 1), (-10, -11), (10, -11), (-5, -2), (-5, 1)

]

for col_offset, end_col_offset in invalid_col_offsets:

with self.subTest(f"Check invalid col_offset {col_offset}:{end_col_offset}"):

snippet = "a = 1"

tree = ast.parse(snippet)

tree.body[0].col_offset = col_offset

tree.body[0].end_col_offset = end_col_offset

with self.assertRaises(ValueError):

compile(tree, '<string>', 'exec')

def test_compilation_of_ast_nodes_with_default_end_position_values(self):

tree = ast.Module(body=[

ast.Import(names=[ast.alias(name='builtins', lineno=1, col_offset=0)], lineno=1, col_offset=0),

ast.Import(names=[ast.alias(name='traceback', lineno=0, col_offset=0)], lineno=0, col_offset=1)

], type_ignores=[])

# Check that compilation doesn't crash. Note: this may crash explicitly only on debug mode.

compile(tree, "<string>", "exec")

def test_negative_locations_for_compile(self):

# See https://github.com/python/cpython/issues/130775

alias = ast.alias(name='traceback', lineno=0, col_offset=0)

for attrs in (

{'lineno': -2, 'col_offset': 0},

{'lineno': 0, 'col_offset': -2},

{'lineno': 0, 'col_offset': -2, 'end_col_offset': -2},

{'lineno': -2, 'end_lineno': -2, 'col_offset': 0},

):

with self.subTest(attrs=attrs):

tree = ast.Module(body=[

ast.Import(names=[alias], **attrs)

], type_ignores=[])

# It used to crash on this step:

compile(tree, "<string>", "exec")

# This also must not crash:

ast.parse(tree, optimize=2)

def test_slice(self):

slc = ast.parse("x[::]").body[0].value.slice

self.assertIsNone(slc.upper)

self.assertIsNone(slc.lower)

self.assertIsNone(slc.step)

def test_from_import(self):

im = ast.parse("from . import y").body[0]

self.assertIsNone(im.module)

def test_non_interned_future_from_ast(self):

mod = ast.parse("from __future__ import division")

self.assertIsInstance(mod.body[0], ast.ImportFrom)

mod.body[0].module = " __future__ ".strip()

compile(mod, "<test>", "exec")

def test_alias(self):

im = ast.parse("from bar import y").body[0]

self.assertEqual(len(im.names), 1)

alias = im.names[0]

self.assertEqual(alias.name, 'y')

self.assertIsNone(alias.asname)

self.assertEqual(alias.lineno, 1)

self.assertEqual(alias.end_lineno, 1)

self.assertEqual(alias.col_offset, 16)

self.assertEqual(alias.end_col_offset, 17)

im = ast.parse("from bar import *").body[0]

alias = im.names[0]

self.assertEqual(alias.name, '*')

self.assertIsNone(alias.asname)

self.assertEqual(alias.lineno, 1)

self.assertEqual(alias.end_lineno, 1)

self.assertEqual(alias.col_offset, 16)

self.assertEqual(alias.end_col_offset, 17)

im = ast.parse("from bar import y as z").body[0]

alias = im.names[0]

self.assertEqual(alias.name, "y")

self.assertEqual(alias.asname, "z")

self.assertEqual(alias.lineno, 1)

self.assertEqual(alias.end_lineno, 1)

self.assertEqual(alias.col_offset, 16)

self.assertEqual(alias.end_col_offset, 22)

im = ast.parse("import bar as foo").body[0]

alias = im.names[0]

self.assertEqual(alias.name, "bar")

self.assertEqual(alias.asname, "foo")

self.assertEqual(alias.lineno, 1)

self.assertEqual(alias.end_lineno, 1)

self.assertEqual(alias.col_offset, 7)

self.assertEqual(alias.end_col_offset, 17)

def test_base_classes(self):

self.assertIsSubclass(ast.For, ast.stmt)

self.assertIsSubclass(ast.Name, ast.expr)

self.assertIsSubclass(ast.stmt, ast.AST)

self.assertIsSubclass(ast.expr, ast.AST)

self.assertIsSubclass(ast.comprehension, ast.AST)

self.assertIsSubclass(ast.Gt, ast.AST)

def test_field_attr_existence(self):

for name, item in ast.__dict__.items():

# constructor has a different signature

if name == 'Index':

continue

if self._is_ast_node(name, item):

x = self._construct_ast_class(item)

if isinstance(x, ast.AST):

self.assertIs(type(x._fields), tuple)

def _construct_ast_class(self, cls):

kwargs = {}

for name, typ in cls.__annotations__.items():

if typ is str:

kwargs[name] = 'capybara'

elif typ is int:

kwargs[name] = 42

elif typ is object:

kwargs[name] = b'capybara'

elif isinstance(typ, type) and issubclass(typ, ast.AST):

kwargs[name] = self._construct_ast_class(typ)

return cls(**kwargs)

def test_arguments(self):

x = ast.arguments()

self.assertEqual(x._fields, ('posonlyargs', 'args', 'vararg', 'kwonlyargs',

'kw_defaults', 'kwarg', 'defaults'))

self.assertEqual(ast.arguments.__annotations__, {

'posonlyargs': list[ast.arg],

'args': list[ast.arg],

'vararg': ast.arg | None,

'kwonlyargs': list[ast.arg],

'kw_defaults': list[ast.expr],

'kwarg': ast.arg | None,

'defaults': list[ast.expr],

})

self.assertEqual(x.args, [])

self.assertIsNone(x.vararg)

x = ast.arguments(*range(1, 8))

self.assertEqual(x.args, 2)

self.assertEqual(x.vararg, 3)

def test_field_attr_writable(self):

x = ast.Constant(1)

# We can assign to _fields

x._fields = 666

self.assertEqual(x._fields, 666)

def test_classattrs(self):

with self.assertWarns(DeprecationWarning):

x = ast.Constant()

self.assertEqual(x._fields, ('value', 'kind'))

with self.assertRaises(AttributeError):

x.value

x = ast.Constant(42)

self.assertEqual(x.value, 42)

with self.assertRaises(AttributeError):

x.lineno

with self.assertRaises(AttributeError):

x.foobar

x = ast.Constant(lineno=2, value=3)

self.assertEqual(x.lineno, 2)

x = ast.Constant(42, lineno=0)

self.assertEqual(x.lineno, 0)

self.assertEqual(x._fields, ('value', 'kind'))

self.assertEqual(x.value, 42)

self.assertRaises(TypeError, ast.Constant, 1, None, 2)

self.assertRaises(TypeError, ast.Constant, 1, None, 2, lineno=0)

# Arbitrary keyword arguments are supported (but deprecated)

with self.assertWarns(DeprecationWarning):

self.assertEqual(ast.Constant(1, foo='bar').foo, 'bar')

with self.assertRaisesRegex(TypeError, "Constant got multiple values for argument 'value'"):

ast.Constant(1, value=2)

self.assertEqual(ast.Constant(42).value, 42)

self.assertEqual(ast.Constant(4.25).value, 4.25)

self.assertEqual(ast.Constant(4.25j).value, 4.25j)

self.assertEqual(ast.Constant('42').value, '42')

self.assertEqual(ast.Constant(b'42').value, b'42')

self.assertIs(ast.Constant(True).value, True)

self.assertIs(ast.Constant(False).value, False)

self.assertIs(ast.Constant(None).value, None)

self.assertIs(ast.Constant(...).value, ...)

def test_constant_subclasses(self):

class N(ast.Constant):

def __init__(self, *args, **kwargs):

super().__init__(*args, **kwargs)

self.z = 'spam'

class N2(ast.Constant):

pass

n = N(42)

self.assertEqual(n.value, 42)

self.assertEqual(n.z, 'spam')

self.assertEqual(type(n), N)

self.assertTrue(isinstance(n, N))

self.assertTrue(isinstance(n, ast.Constant))

self.assertFalse(isinstance(n, N2))

self.assertFalse(isinstance(ast.Constant(42), N))

n = N(value=42)

self.assertEqual(n.value, 42)

self.assertEqual(type(n), N)

def test_module(self):

body = [ast.Constant(42)]

x = ast.Module(body, [])

self.assertEqual(x.body, body)

def test_nodeclasses(self):

# Zero arguments constructor explicitly allowed (but deprecated)

with self.assertWarns(DeprecationWarning):

x = ast.BinOp()

self.assertEqual(x._fields, ('left', 'op', 'right'))

# Random attribute allowed too

x.foobarbaz = 5

self.assertEqual(x.foobarbaz, 5)

n1 = ast.Constant(1)

n3 = ast.Constant(3)

addop = ast.Add()

x = ast.BinOp(n1, addop, n3)

self.assertEqual(x.left, n1)

self.assertEqual(x.op, addop)

self.assertEqual(x.right, n3)

x = ast.BinOp(1, 2, 3)

self.assertEqual(x.left, 1)

self.assertEqual(x.op, 2)

self.assertEqual(x.right, 3)

x = ast.BinOp(1, 2, 3, lineno=0)

self.assertEqual(x.left, 1)

self.assertEqual(x.op, 2)

self.assertEqual(x.right, 3)

self.assertEqual(x.lineno, 0)

# node raises exception when given too many arguments

self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4)

# node raises exception when given too many arguments

self.assertRaises(TypeError, ast.BinOp, 1, 2, 3, 4, lineno=0)

# can set attributes through kwargs too

x = ast.BinOp(left=1, op=2, right=3, lineno=0)

self.assertEqual(x.left, 1)

self.assertEqual(x.op, 2)

self.assertEqual(x.right, 3)

self.assertEqual(x.lineno, 0)

# Random kwargs also allowed (but deprecated)

with self.assertWarns(DeprecationWarning):

x = ast.BinOp(1, 2, 3, foobarbaz=42)

self.assertEqual(x.foobarbaz, 42)

def test_no_fields(self):

# this used to fail because Sub._fields was None

x = ast.Sub()

self.assertEqual(x._fields, ())

def test_invalid_sum(self):

pos = dict(lineno=2, col_offset=3)

m = ast.Module([ast.Expr(ast.expr(**pos), **pos)], [])

with self.assertRaises(TypeError) as cm:

compile(m, "<test>", "exec")

self.assertIn("but got expr()", str(cm.exception))

def test_invalid_identifier(self):

m = ast.Module([ast.Expr(ast.Name(42, ast.Load()))], [])

ast.fix_missing_locations(m)

with self.assertRaises(TypeError) as cm:

compile(m, "<test>", "exec")

self.assertIn("identifier must be of type str", str(cm.exception))

def test_invalid_constant(self):

for invalid_constant in int, (1, 2, int), frozenset((1, 2, int)):

e = ast.Expression(body=ast.Constant(invalid_constant))

ast.fix_missing_locations(e)

with self.assertRaisesRegex(

TypeError, "invalid type in Constant: type"

):

compile(e, "<test>", "eval")

def test_empty_yield_from(self):

# Issue 16546: yield from value is not optional.

empty_yield_from = ast.parse("def f():\n yield from g()")

empty_yield_from.body[0].body[0].value.value = None

with self.assertRaises(ValueError) as cm:

compile(empty_yield_from, "<test>", "exec")

self.assertIn("field 'value' is required", str(cm.exception))

@support.cpython_only

def test_issue31592(self):

# There shouldn't be an assertion failure in case of a bad

# unicodedata.normalize().

import unicodedata

def bad_normalize(*args):

return None

with support.swap_attr(unicodedata, 'normalize', bad_normalize):

self.assertRaises(TypeError, ast.parse, '\u03D5')

def test_issue18374_binop_col_offset(self):

tree = ast.parse('4+5+6+7')

parent_binop = tree.body[0].value

child_binop = parent_binop.left

grandchild_binop = child_binop.left

self.assertEqual(parent_binop.col_offset, 0)

self.assertEqual(parent_binop.end_col_offset, 7)

self.assertEqual(child_binop.col_offset, 0)

self.assertEqual(child_binop.end_col_offset, 5)

self.assertEqual(grandchild_binop.col_offset, 0)

self.assertEqual(grandchild_binop.end_col_offset, 3)

tree = ast.parse('4+5-\\\n 6-7')

parent_binop = tree.body[0].value

child_binop = parent_binop.left

grandchild_binop = child_binop.left

self.assertEqual(parent_binop.col_offset, 0)

self.assertEqual(parent_binop.lineno, 1)

self.assertEqual(parent_binop.end_col_offset, 4)

self.assertEqual(parent_binop.end_lineno, 2)

self.assertEqual(child_binop.col_offset, 0)

self.assertEqual(child_binop.lineno, 1)

self.assertEqual(child_binop.end_col_offset, 2)

self.assertEqual(child_binop.end_lineno, 2)

self.assertEqual(grandchild_binop.col_offset, 0)

self.assertEqual(grandchild_binop.lineno, 1)

self.assertEqual(grandchild_binop.end_col_offset, 3)

self.assertEqual(grandchild_binop.end_lineno, 1)

def test_issue39579_dotted_name_end_col_offset(self):

tree = ast.parse('@a.b.c\ndef f(): pass')

attr_b = tree.body[0].decorator_list[0].value

self.assertEqual(attr_b.end_col_offset, 4)

def test_ast_asdl_signature(self):

self.assertEqual(ast.withitem.__doc__, "withitem(expr context_expr, expr? optional_vars)")

self.assertEqual(ast.GtE.__doc__, "GtE")

self.assertEqual(ast.Name.__doc__, "Name(identifier id, expr_context ctx)")

self.assertEqual(ast.cmpop.__doc__, "cmpop = Eq | NotEq | Lt | LtE | Gt | GtE | Is | IsNot | In | NotIn")

expressions = [f" | {node.__doc__}" for node in ast.expr.__subclasses__()]

expressions[0] = f"expr = {ast.expr.__subclasses__()[0].__doc__}"

self.assertCountEqual(ast.expr.__doc__.split("\n"), expressions)

def test_compare_basics(self):

self.assertTrue(ast.compare(ast.parse("x = 10"), ast.parse("x = 10")))

self.assertFalse(ast.compare(ast.parse("x = 10"), ast.parse("")))

self.assertFalse(ast.compare(ast.parse("x = 10"), ast.parse("x")))

self.assertFalse(

ast.compare(ast.parse("x = 10;y = 20"), ast.parse("class C:pass"))

)

def test_compare_modified_ast(self):

# The ast API is a bit underspecified. The objects are mutable,

# and even _fields and _attributes are mutable. The compare() does

# some simple things to accommodate mutability.

a = ast.parse("m * x + b", mode="eval")

b = ast.parse("m * x + b", mode="eval")

self.assertTrue(ast.compare(a, b))

a._fields = a._fields + ("spam",)

a.spam = "Spam"

self.assertNotEqual(a._fields, b._fields)

self.assertFalse(ast.compare(a, b))

self.assertFalse(ast.compare(b, a))

b._fields = a._fields

b.spam = a.spam

self.assertTrue(ast.compare(a, b))

self.assertTrue(ast.compare(b, a))

b._attributes = b._attributes + ("eggs",)

b.eggs = "eggs"

self.assertNotEqual(a._attributes, b._attributes)

self.assertFalse(ast.compare(a, b, compare_attributes=True))

self.assertFalse(ast.compare(b, a, compare_attributes=True))

a._attributes = b._attributes

a.eggs = b.eggs

self.assertTrue(ast.compare(a, b, compare_attributes=True))

self.assertTrue(ast.compare(b, a, compare_attributes=True))

def test_compare_literals(self):

constants = (

-20,

20,

20.0,

1,

1.0,

True,

0,

False,

frozenset(),

tuple(),

"ABCD",

"abcd",

"中文字",

1e1000,

-1e1000,

)

for next_index, constant in enumerate(constants[:-1], 1):

next_constant = constants[next_index]

with self.subTest(literal=constant, next_literal=next_constant):

self.assertTrue(

ast.compare(ast.Constant(constant), ast.Constant(constant))

)

self.assertFalse(

ast.compare(

ast.Constant(constant), ast.Constant(next_constant)

)

)

same_looking_literal_cases = [

{1, 1.0, True, 1 + 0j},

{0, 0.0, False, 0 + 0j},

]

for same_looking_literals in same_looking_literal_cases:

for literal in same_looking_literals:

for same_looking_literal in same_looking_literals - {literal}:

self.assertFalse(

ast.compare(

ast.Constant(literal),

ast.Constant(same_looking_literal),

)

)

def test_compare_fieldless(self):

self.assertTrue(ast.compare(ast.Add(), ast.Add()))

self.assertFalse(ast.compare(ast.Sub(), ast.Add()))

# test that missing runtime fields is handled in ast.compare()

a1, a2 = ast.Name('a'), ast.Name('a')

self.assertTrue(ast.compare(a1, a2))

self.assertTrue(ast.compare(a1, a2))

del a1.id

self.assertFalse(ast.compare(a1, a2))

del a2.id

self.assertTrue(ast.compare(a1, a2))

def test_compare_modes(self):

for mode, sources in (

("exec", exec_tests),

("eval", eval_tests),

("single", single_tests),

):

for source in sources:

a = ast.parse(source, mode=mode)

b = ast.parse(source, mode=mode)

self.assertTrue(

ast.compare(a, b), f"{ast.dump(a)} != {ast.dump(b)}"

)

def test_compare_attributes_option(self):

def parse(a, b):

return ast.parse(a), ast.parse(b)

a, b = parse("2 + 2", "2+2")

self.assertTrue(ast.compare(a, b))

self.assertTrue(ast.compare(a, b, compare_attributes=False))

self.assertFalse(ast.compare(a, b, compare_attributes=True))

def test_compare_attributes_option_missing_attribute(self):

# test that missing runtime attributes is handled in ast.compare()

a1, a2 = ast.Name('a', lineno=1), ast.Name('a', lineno=1)

self.assertTrue(ast.compare(a1, a2))

self.assertTrue(ast.compare(a1, a2, compare_attributes=True))

del a1.lineno

self.assertFalse(ast.compare(a1, a2, compare_attributes=True))

del a2.lineno

self.assertTrue(ast.compare(a1, a2, compare_attributes=True))

def test_positional_only_feature_version(self):

ast.parse('def foo(x, /): ...', feature_version=(3, 8))

ast.parse('def bar(x=1, /): ...', feature_version=(3, 8))

with self.assertRaises(SyntaxError):

ast.parse('def foo(x, /): ...', feature_version=(3, 7))

with self.assertRaises(SyntaxError):

ast.parse('def bar(x=1, /): ...', feature_version=(3, 7))

ast.parse('lambda x, /: ...', feature_version=(3, 8))

ast.parse('lambda x=1, /: ...', feature_version=(3, 8))

with self.assertRaises(SyntaxError):

ast.parse('lambda x, /: ...', feature_version=(3, 7))

with self.assertRaises(SyntaxError):

ast.parse('lambda x=1, /: ...', feature_version=(3, 7))

def test_assignment_expression_feature_version(self):

ast.parse('(x := 0)', feature_version=(3, 8))

with self.assertRaises(SyntaxError):

ast.parse('(x := 0)', feature_version=(3, 7))

def test_pep750_tstring(self):

code = 't""'

ast.parse(code, feature_version=(3, 14))

with self.assertRaises(SyntaxError):

ast.parse(code, feature_version=(3, 13))

def test_pep758_except_without_parens(self):

code = textwrap.dedent("""

""")

ast.parse(code, feature_version=(3, 14))

with self.assertRaises(SyntaxError):

ast.parse(code, feature_version=(3, 13))

def test_pep758_except_with_single_expr(self):

single_expr = textwrap.dedent("""

""")

single_expr_with_as = textwrap.dedent("""

""")

single_tuple_expr = textwrap.dedent("""

""")

single_tuple_expr_with_as = textwrap.dedent("""

""")

single_parens_expr = textwrap.dedent("""

""")

single_parens_expr_with_as = textwrap.dedent("""

""")

for code in [

single_expr,

single_expr_with_as,

single_tuple_expr,

single_tuple_expr_with_as,

single_parens_expr,

single_parens_expr_with_as,

]:

for star in [True, False]:

code = code.format('*' if star else '')

with self.subTest(code=code, star=star):

ast.parse(code, feature_version=(3, 14))

ast.parse(code, feature_version=(3, 13))

def test_pep758_except_star_without_parens(self):

code = textwrap.dedent("""

""")

ast.parse(code, feature_version=(3, 14))

with self.assertRaises(SyntaxError):

ast.parse(code, feature_version=(3, 13))

def test_conditional_context_managers_parse_with_low_feature_version(self):

# regression test for gh-115881

ast.parse('with (x() if y else z()): ...', feature_version=(3, 8))

def test_exception_groups_feature_version(self):

code = dedent('''

''')

ast.parse(code)

with self.assertRaises(SyntaxError):

ast.parse(code, feature_version=(3, 10))

def test_type_params_feature_version(self):

samples = [

"type X = int",

"class X[T]: pass",

"def f[T](): pass",

]

for sample in samples:

with self.subTest(sample):

ast.parse(sample)

with self.assertRaises(SyntaxError):

ast.parse(sample, feature_version=(3, 11))

def test_type_params_default_feature_version(self):

samples = [

"type X[*Ts=int] = int",

"class X[T=int]: pass",

"def f[**P=int](): pass",

]

for sample in samples:

with self.subTest(sample):

ast.parse(sample)

with self.assertRaises(SyntaxError):

ast.parse(sample, feature_version=(3, 12))

def test_invalid_major_feature_version(self):

with self.assertRaises(ValueError):

ast.parse('pass', feature_version=(2, 7))

with self.assertRaises(ValueError):

ast.parse('pass', feature_version=(4, 0))

def test_constant_as_name(self):

for constant in "True", "False", "None":

expr = ast.Expression(ast.Name(constant, ast.Load()))

ast.fix_missing_locations(expr)

with self.assertRaisesRegex(ValueError, f"identifier field can't represent '{constant}' constant"):

compile(expr, "<test>", "eval")

def test_constant_as_unicode_name(self):

constants = [

("True", b"Tru\xe1\xb5\x89"),

("False", b"Fal\xc5\xbfe"),

("None", b"N\xc2\xbane"),

]

for constant in constants:

with self.assertRaisesRegex(ValueError,

f"identifier field can't represent '{constant[0]}' constant"):

ast.parse(constant[1], mode="eval")

def test_precedence_enum(self):

class _Precedence(enum.IntEnum):

"""Precedence table that originated from python grammar."""

NAMED_EXPR = enum.auto() # <target> := <expr1>

TUPLE = enum.auto() # <expr1>, <expr2>

YIELD = enum.auto() # 'yield', 'yield from'

TEST = enum.auto() # 'if'-'else', 'lambda'

OR = enum.auto() # 'or'

AND = enum.auto() # 'and'

NOT = enum.auto() # 'not'

CMP = enum.auto() # '<', '>', '==', '>=', '<=', '!=',

# 'in', 'not in', 'is', 'is not'

EXPR = enum.auto()

BOR = EXPR # '|'

BXOR = enum.auto() # '^'

BAND = enum.auto() # '&'

SHIFT = enum.auto() # '<<', '>>'

ARITH = enum.auto() # '+', '-'

TERM = enum.auto() # '*', '@', '/', '%', '//'

FACTOR = enum.auto() # unary '+', '-', '~'

POWER = enum.auto() # '**'

AWAIT = enum.auto() # 'await'

ATOM = enum.auto()

def next(self):

try:

return self.__class__(self + 1)

except ValueError:

return self

enum._test_simple_enum(_Precedence, _ast_unparse._Precedence)

@support.cpython_only

@skip_wasi_stack_overflow()

@skip_emscripten_stack_overflow()

def test_ast_recursion_limit(self):

crash_depth = 500_000

success_depth = 200

if _testinternalcapi is not None:

remaining = _testinternalcapi.get_c_recursion_remaining()

success_depth = min(success_depth, remaining)

def check_limit(prefix, repeated):

expect_ok = prefix + repeated * success_depth

ast.parse(expect_ok)

broken = prefix + repeated * crash_depth

details = "Compiling ({!r} + {!r} * {})".format(

prefix, repeated, crash_depth)

with self.assertRaises(RecursionError, msg=details):

with support.infinite_recursion():

ast.parse(broken)

check_limit("a", "()")

check_limit("a", ".b")

check_limit("a", "[0]")

check_limit("a", "*a")

def test_null_bytes(self):

with self.assertRaises(SyntaxError,

msg="source code string cannot contain null bytes"):

ast.parse("a\0b")

def assert_none_check(self, node: type[ast.AST], attr: str, source: str) -> None:

with self.subTest(f"{node.__name__}.{attr}"):

tree = ast.parse(source)

found = 0

for child in ast.walk(tree):

if isinstance(child, node):

setattr(child, attr, None)

found += 1

self.assertEqual(found, 1)

e = re.escape(f"field '{attr}' is required for {node.__name__}")

with self.assertRaisesRegex(ValueError, f"^{e}$"):

compile(tree, "<test>", "exec")

def test_none_checks(self) -> None:

tests = [

(ast.alias, "name", "import spam as SPAM"),

(ast.arg, "arg", "def spam(SPAM): spam"),

(ast.comprehension, "target", "[spam for SPAM in spam]"),

(ast.comprehension, "iter", "[spam for spam in SPAM]"),

(ast.keyword, "value", "spam(**SPAM)"),

(ast.match_case, "pattern", "match spam:\n case SPAM: spam"),

(ast.withitem, "context_expr", "with SPAM: spam"),

]

for node, attr, source in tests:

self.assert_none_check(node, attr, source)

def test_repr(self) -> None:

snapshots = AST_REPR_DATA_FILE.read_text().split("\n")

for test, snapshot in zip(ast_repr_get_test_cases(), snapshots, strict=True):

with self.subTest(test_input=test):

self.assertEqual(repr(ast.parse(test)), snapshot)

def test_repr_large_input_crash(self):

# gh-125010: Fix use-after-free in ast repr()

source = "0x0" + "e" * 10_000

with self.assertRaisesRegex(ValueError,

r"Exceeds the limit \(\d+ digits\)"):

repr(ast.Constant(value=eval(source)))

def test_pep_765_warnings(self):

srcs = [

textwrap.dedent("""

"""),

textwrap.dedent("""