# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2022, Python Software Foundation

# This file is distributed under the same license as the Python package.

#

# Translators:

# Leon H., 2017

msgid ""

msgstr ""

"Project-Id-Version: Python 3.13\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-06-27 07:36+0000\n"

"PO-Revision-Date: 2017-09-22 18:27+0000\n"

"Last-Translator: Leon H.\n"

"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"

"tw)\n"

"Language: zh_TW\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../reference/grammar.rst:4

msgid "Full Grammar specification"

msgstr "完整的語法規格書"

#: ../../reference/grammar.rst:6

msgid ""

"This is the full Python grammar, derived directly from the grammar used to "

"generate the CPython parser (see :source:`Grammar/python.gram`). The version "

"here omits details related to code generation and error recovery."

msgstr ""

#: ../../reference/grammar.rst:11

msgid ""

"The notation is a mixture of `EBNF <https://en.wikipedia.org/wiki/"

"Extended_Backus%E2%80%93Naur_form>`_ and `PEG <https://en.wikipedia.org/wiki/"

"Parsing_expression_grammar>`_. In particular, ``&`` followed by a symbol, "

"token or parenthesized group indicates a positive lookahead (i.e., is "

"required to match but not consumed), while ``!`` indicates a negative "

"lookahead (i.e., is required *not* to match). We use the ``|`` separator to "

"mean PEG's \"ordered choice\" (written as ``/`` in traditional PEG "

"grammars). See :pep:`617` for more details on the grammar's syntax."

msgstr ""

#: ../../reference/grammar.rst:21

msgid ""

"# PEG grammar for Python\n"

"\n"

"@trailer '''\n"

"void *\n"

"_PyPegen_parse(Parser *p)\n"

"{\n"

" // Initialize keywords\n"

" p->keywords = reserved_keywords;\n"

" p->n_keyword_lists = n_keyword_lists;\n"

" p->soft_keywords = soft_keywords;\n"

"\n"

" // Run parser\n"

" void *result = NULL;\n"

" if (p->start_rule == Py_file_input) {\n"

" result = file_rule(p);\n"

" } else if (p->start_rule == Py_single_input) {\n"

" result = interactive_rule(p);\n"

" } else if (p->start_rule == Py_eval_input) {\n"

" result = eval_rule(p);\n"

" } else if (p->start_rule == Py_func_type_input) {\n"

" result = func_type_rule(p);\n"

" }\n"

"\n"

" return result;\n"

"}\n"

"'''\n"

"\n"

"# ========================= START OF THE GRAMMAR =========================\n"

"\n"

"# General grammatical elements and rules:\n"

"#\n"

"# * Strings with double quotes (\") denote SOFT KEYWORDS\n"

"# * Strings with single quotes (') denote KEYWORDS\n"

"# * Upper case names (NAME) denote tokens in the Grammar/Tokens file\n"

"# * Rule names starting with \"invalid_\" are used for specialized syntax "

"errors\n"

"# - These rules are NOT used in the first pass of the parser.\n"

"# - Only if the first pass fails to parse, a second pass including the "

"invalid\n"

"# rules will be executed.\n"

"# - If the parser fails in the second phase with a generic syntax error, "

"the\n"

"# location of the generic failure of the first pass will be used (this "

"avoids\n"

"# reporting incorrect locations due to the invalid rules).\n"

"# - The order of the alternatives involving invalid rules matter\n"

"# (like any rule in PEG).\n"

"#\n"

"# Grammar Syntax (see PEP 617 for more information):\n"

"#\n"

"# rule_name: expression\n"

"# Optionally, a type can be included right after the rule name, which\n"

"# specifies the return type of the C or Python function corresponding to "

"the\n"

"# rule:\n"

"# rule_name[return_type]: expression\n"

"# If the return type is omitted, then a void * is returned in C and an Any "

"in\n"

"# Python.\n"

"# e1 e2\n"

"# Match e1, then match e2.\n"

"# e1 | e2\n"

"# Match e1 or e2.\n"

"# The first alternative can also appear on the line after the rule name "

"for\n"

"# formatting purposes. In that case, a | must be used before the first\n"

"# alternative, like so:\n"

"# rule_name[return_type]:\n"

"# | first_alt\n"

"# | second_alt\n"

"# ( e )\n"

"# Match e (allows also to use other operators in the group like '(e)*')\n"

"# [ e ] or e?\n"

"# Optionally match e.\n"

"# e*\n"

"# Match zero or more occurrences of e.\n"

"# e+\n"

"# Match one or more occurrences of e.\n"

"# s.e+\n"

"# Match one or more occurrences of e, separated by s. The generated parse "

"tree\n"

"# does not include the separator. This is otherwise identical to (e (s "

"e)*).\n"

"# &e\n"

"# Succeed if e can be parsed, without consuming any input.\n"

"# !e\n"

"# Fail if e can be parsed, without consuming any input.\n"

"# ~\n"

"# Commit to the current alternative, even if it fails to parse.\n"

"# &&e\n"

"# Eager parse e. The parser will not backtrack and will immediately\n"

"# fail with SyntaxError if e cannot be parsed.\n"

"#\n"

"\n"

"# STARTING RULES\n"

"# ==============\n"

"\n"

"file[mod_ty]: a=[statements] ENDMARKER { _PyPegen_make_module(p, a) }\n"

"interactive[mod_ty]: a=statement_newline { _PyAST_Interactive(a, p-"

">arena) }\n"

"eval[mod_ty]: a=expressions NEWLINE* ENDMARKER { _PyAST_Expression(a, p-"

">arena) }\n"

"func_type[mod_ty]: '(' a=[type_expressions] ')' '->' b=expression NEWLINE* "

"ENDMARKER { _PyAST_FunctionType(a, b, p->arena) }\n"

"\n"

"# GENERAL STATEMENTS\n"

"# ==================\n"

"\n"

"statements[asdl_stmt_seq*]: a=statement+ "

"{ (asdl_stmt_seq*)_PyPegen_seq_flatten(p, a) }\n"

"\n"

"statement[asdl_stmt_seq*]: a=compound_stmt "

"{ (asdl_stmt_seq*)_PyPegen_singleton_seq(p, a) } | "

"a[asdl_stmt_seq*]=simple_stmts { a }\n"

"\n"

"statement_newline[asdl_stmt_seq*]:\n"

" | a=compound_stmt NEWLINE { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, "

"a) }\n"

" | simple_stmts\n"

" | NEWLINE { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, CHECK(stmt_ty, "

"_PyAST_Pass(EXTRA))) }\n"

" | ENDMARKER { _PyPegen_interactive_exit(p) }\n"

"\n"

"simple_stmts[asdl_stmt_seq*]:\n"

" | a=simple_stmt !';' NEWLINE { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, "

"a) } # Not needed, there for speedup\n"

" | a[asdl_stmt_seq*]=';'.simple_stmt+ [';'] NEWLINE { a }\n"

"\n"

"# NOTE: assignment MUST precede expression, else parsing a simple "

"assignment\n"

"# will throw a SyntaxError.\n"

"simple_stmt[stmt_ty] (memo):\n"

" | assignment\n"

" | &\"type\" type_alias\n"

" | e=star_expressions { _PyAST_Expr(e, EXTRA) }\n"

" | &'return' return_stmt\n"

" | &('import' | 'from') import_stmt\n"

" | &'raise' raise_stmt\n"

" | 'pass' { _PyAST_Pass(EXTRA) }\n"

" | &'del' del_stmt\n"

" | &'yield' yield_stmt\n"

" | &'assert' assert_stmt\n"

" | 'break' { _PyAST_Break(EXTRA) }\n"

" | 'continue' { _PyAST_Continue(EXTRA) }\n"

" | &'global' global_stmt\n"

" | &'nonlocal' nonlocal_stmt\n"

"\n"

"compound_stmt[stmt_ty]:\n"

" | &('def' | '@' | 'async') function_def\n"

" | &'if' if_stmt\n"

" | &('class' | '@') class_def\n"

" | &('with' | 'async') with_stmt\n"

" | &('for' | 'async') for_stmt\n"

" | &'try' try_stmt\n"

" | &'while' while_stmt\n"

" | match_stmt\n"

"\n"

"# SIMPLE STATEMENTS\n"

"# =================\n"

"\n"

"# NOTE: annotated_rhs may start with 'yield'; yield_expr must start with "

"'yield'\n"

"assignment[stmt_ty]:\n"

" | a=NAME ':' b=expression c=['=' d=annotated_rhs { d }] {\n"

" CHECK_VERSION(\n"

" stmt_ty,\n"

" 6,\n"

" \"Variable annotation syntax is\",\n"

" _PyAST_AnnAssign(CHECK(expr_ty, _PyPegen_set_expr_context(p, a, "

"Store)), b, c, 1, EXTRA)\n"

" ) }\n"

" | a=('(' b=single_target ')' { b }\n"

" | single_subscript_attribute_target) ':' b=expression c=['=' "

"d=annotated_rhs { d }] {\n"

" CHECK_VERSION(stmt_ty, 6, \"Variable annotations syntax is\", "

"_PyAST_AnnAssign(a, b, c, 0, EXTRA)) }\n"

" | a[asdl_expr_seq*]=(z=star_targets '=' { z })+ b=(yield_expr | "

"star_expressions) !'=' tc=[TYPE_COMMENT] {\n"

" _PyAST_Assign(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA) }\n"

" | a=single_target b=augassign ~ c=(yield_expr | star_expressions) {\n"

" _PyAST_AugAssign(a, b->kind, c, EXTRA) }\n"

" | invalid_assignment\n"

"\n"

"annotated_rhs[expr_ty]: yield_expr | star_expressions\n"

"\n"

"augassign[AugOperator*]:\n"

" | '+=' { _PyPegen_augoperator(p, Add) }\n"

" | '-=' { _PyPegen_augoperator(p, Sub) }\n"

" | '*=' { _PyPegen_augoperator(p, Mult) }\n"

" | '@=' { CHECK_VERSION(AugOperator*, 5, \"The '@' operator is\", "

"_PyPegen_augoperator(p, MatMult)) }\n"

" | '/=' { _PyPegen_augoperator(p, Div) }\n"

" | '%=' { _PyPegen_augoperator(p, Mod) }\n"

" | '&=' { _PyPegen_augoperator(p, BitAnd) }\n"

" | '|=' { _PyPegen_augoperator(p, BitOr) }\n"

" | '^=' { _PyPegen_augoperator(p, BitXor) }\n"

" | '<<=' { _PyPegen_augoperator(p, LShift) }\n"

" | '>>=' { _PyPegen_augoperator(p, RShift) }\n"

" | '**=' { _PyPegen_augoperator(p, Pow) }\n"

" | '//=' { _PyPegen_augoperator(p, FloorDiv) }\n"

"\n"

"return_stmt[stmt_ty]:\n"

" | 'return' a=[star_expressions] { _PyAST_Return(a, EXTRA) }\n"

"\n"

"raise_stmt[stmt_ty]:\n"

" | 'raise' a=expression b=['from' z=expression { z }] { _PyAST_Raise(a, "

"b, EXTRA) }\n"

" | 'raise' { _PyAST_Raise(NULL, NULL, EXTRA) }\n"

"\n"

"global_stmt[stmt_ty]: 'global' a[asdl_expr_seq*]=','.NAME+ {\n"

" _PyAST_Global(CHECK(asdl_identifier_seq*, _PyPegen_map_names_to_ids(p, "

"a)), EXTRA) }\n"

"\n"

"nonlocal_stmt[stmt_ty]: 'nonlocal' a[asdl_expr_seq*]=','.NAME+ {\n"

" _PyAST_Nonlocal(CHECK(asdl_identifier_seq*, _PyPegen_map_names_to_ids(p, "

"a)), EXTRA) }\n"

"\n"

"del_stmt[stmt_ty]:\n"

" | 'del' a=del_targets &(';' | NEWLINE) { _PyAST_Delete(a, EXTRA) }\n"

" | invalid_del_stmt\n"

"\n"

"yield_stmt[stmt_ty]: y=yield_expr { _PyAST_Expr(y, EXTRA) }\n"

"\n"

"assert_stmt[stmt_ty]: 'assert' a=expression b=[',' z=expression { z }] "

"{ _PyAST_Assert(a, b, EXTRA) }\n"

"\n"

"import_stmt[stmt_ty]:\n"

" | invalid_import\n"

" | import_name\n"

" | import_from\n"

"\n"

"# Import statements\n"

"# -----------------\n"

"\n"

"import_name[stmt_ty]: 'import' a=dotted_as_names { _PyAST_Import(a, "

"EXTRA) }\n"

"# note below: the ('.' | '...') is necessary because '...' is tokenized as "

"ELLIPSIS\n"

"import_from[stmt_ty]:\n"

" | 'from' a=('.' | '...')* b=dotted_name 'import' c=import_from_targets "

"{\n"

" _PyPegen_checked_future_import(p, b->v.Name.id, c, "

"_PyPegen_seq_count_dots(a), EXTRA) }\n"

" | 'from' a=('.' | '...')+ 'import' b=import_from_targets {\n"

" _PyAST_ImportFrom(NULL, b, _PyPegen_seq_count_dots(a), EXTRA) }\n"

"import_from_targets[asdl_alias_seq*]:\n"

" | '(' a=import_from_as_names [','] ')' { a }\n"

" | import_from_as_names !','\n"

" | '*' { (asdl_alias_seq*)_PyPegen_singleton_seq(p, CHECK(alias_ty, "

"_PyPegen_alias_for_star(p, EXTRA))) }\n"

" | invalid_import_from_targets\n"

"import_from_as_names[asdl_alias_seq*]:\n"

" | a[asdl_alias_seq*]=','.import_from_as_name+ { a }\n"

"import_from_as_name[alias_ty]:\n"

" | a=NAME b=['as' z=NAME { z }] { _PyAST_alias(a->v.Name.id,\n"

" (b) ? ((expr_ty) b)->v.Name."

"id : NULL,\n"

" EXTRA) }\n"

"dotted_as_names[asdl_alias_seq*]:\n"

" | a[asdl_alias_seq*]=','.dotted_as_name+ { a }\n"

"dotted_as_name[alias_ty]:\n"

" | a=dotted_name b=['as' z=NAME { z }] { _PyAST_alias(a->v.Name.id,\n"

" (b) ? ((expr_ty) b)->v."

"Name.id : NULL,\n"

" EXTRA) }\n"

"dotted_name[expr_ty]:\n"

" | a=dotted_name '.' b=NAME { _PyPegen_join_names_with_dot(p, a, b) }\n"

" | NAME\n"

"\n"

"# COMPOUND STATEMENTS\n"

"# ===================\n"

"\n"

"# Common elements\n"

"# ---------------\n"

"\n"

"block[asdl_stmt_seq*] (memo):\n"

" | NEWLINE INDENT a=statements DEDENT { a }\n"

" | simple_stmts\n"

" | invalid_block\n"

"\n"

"decorators[asdl_expr_seq*]: a[asdl_expr_seq*]=('@' f=named_expression "

"NEWLINE { f })+ { a }\n"

"\n"

"# Class definitions\n"

"# -----------------\n"

"\n"

"class_def[stmt_ty]:\n"

" | a=decorators b=class_def_raw { _PyPegen_class_def_decorators(p, a, "

"b) }\n"

" | class_def_raw\n"

"\n"

"class_def_raw[stmt_ty]:\n"

" | invalid_class_def_raw\n"

" | 'class' a=NAME t=[type_params] b=['(' z=[arguments] ')' { z }] ':' "

"c=block {\n"

" _PyAST_ClassDef(a->v.Name.id,\n"

" (b) ? ((expr_ty) b)->v.Call.args : NULL,\n"

" (b) ? ((expr_ty) b)->v.Call.keywords : NULL,\n"

" c, NULL, t, EXTRA) }\n"

"\n"

"# Function definitions\n"

"# --------------------\n"

"\n"

"function_def[stmt_ty]:\n"

" | d=decorators f=function_def_raw { _PyPegen_function_def_decorators(p, "

"d, f) }\n"

" | function_def_raw\n"

"\n"

"function_def_raw[stmt_ty]:\n"

" | invalid_def_raw\n"

" | 'def' n=NAME t=[type_params] '(' params=[params] ')' a=['->' "

"z=expression { z }] ':' tc=[func_type_comment] b=block {\n"

" _PyAST_FunctionDef(n->v.Name.id,\n"

" (params) ? params : CHECK(arguments_ty, "

"_PyPegen_empty_arguments(p)),\n"

" b, NULL, a, NEW_TYPE_COMMENT(p, tc), t, EXTRA) }\n"

" | 'async' 'def' n=NAME t=[type_params] '(' params=[params] ')' a=['->' "

"z=expression { z }] ':' tc=[func_type_comment] b=block {\n"

" CHECK_VERSION(\n"

" stmt_ty,\n"

" 5,\n"

" \"Async functions are\",\n"

" _PyAST_AsyncFunctionDef(n->v.Name.id,\n"

" (params) ? params : CHECK(arguments_ty, "

"_PyPegen_empty_arguments(p)),\n"

" b, NULL, a, NEW_TYPE_COMMENT(p, tc), t, EXTRA)\n"

" ) }\n"

"\n"

"# Function parameters\n"

"# -------------------\n"

"\n"

"params[arguments_ty]:\n"

" | invalid_parameters\n"

" | parameters\n"

"\n"

"parameters[arguments_ty]:\n"

" | a=slash_no_default b[asdl_arg_seq*]=param_no_default* "

"c=param_with_default* d=[star_etc] {\n"

" CHECK_VERSION(arguments_ty, 8, \"Positional-only parameters are\", "

"_PyPegen_make_arguments(p, a, NULL, b, c, d)) }\n"

" | a=slash_with_default b=param_with_default* c=[star_etc] {\n"

" CHECK_VERSION(arguments_ty, 8, \"Positional-only parameters are\", "

"_PyPegen_make_arguments(p, NULL, a, NULL, b, c)) }\n"

" | a[asdl_arg_seq*]=param_no_default+ b=param_with_default* c=[star_etc] "

"{\n"

" _PyPegen_make_arguments(p, NULL, NULL, a, b, c) }\n"

" | a=param_with_default+ b=[star_etc] { _PyPegen_make_arguments(p, NULL, "

"NULL, NULL, a, b)}\n"

" | a=star_etc { _PyPegen_make_arguments(p, NULL, NULL, NULL, NULL, a) }\n"

"\n"

"# Some duplication here because we can't write (',' | &')'),\n"

"# which is because we don't support empty alternatives (yet).\n"

"\n"

"slash_no_default[asdl_arg_seq*]:\n"

" | a[asdl_arg_seq*]=param_no_default+ '/' ',' { a }\n"

" | a[asdl_arg_seq*]=param_no_default+ '/' &')' { a }\n"

"slash_with_default[SlashWithDefault*]:\n"

" | a=param_no_default* b=param_with_default+ '/' "

"',' { _PyPegen_slash_with_default(p, (asdl_arg_seq *)a, b) }\n"

" | a=param_no_default* b=param_with_default+ '/' "

"&')' { _PyPegen_slash_with_default(p, (asdl_arg_seq *)a, b) }\n"

"\n"

"star_etc[StarEtc*]:\n"

" | invalid_star_etc\n"

" | '*' a=param_no_default b=param_maybe_default* c=[kwds] {\n"

" _PyPegen_star_etc(p, a, b, c) }\n"

" | '*' a=param_no_default_star_annotation b=param_maybe_default* c=[kwds] "

"{\n"

" _PyPegen_star_etc(p, a, b, c) }\n"

" | '*' ',' b=param_maybe_default+ c=[kwds] {\n"

" _PyPegen_star_etc(p, NULL, b, c) }\n"

" | a=kwds { _PyPegen_star_etc(p, NULL, NULL, a) }\n"

"\n"

"kwds[arg_ty]:\n"

" | invalid_kwds\n"

" | '**' a=param_no_default { a }\n"

"\n"

"# One parameter. This *includes* a following comma and type comment.\n"

"#\n"

"# There are three styles:\n"

"# - No default\n"

"# - With default\n"

"# - Maybe with default\n"

"#\n"

"# There are two alternative forms of each, to deal with type comments:\n"

"# - Ends in a comma followed by an optional type comment\n"

"# - No comma, optional type comment, must be followed by close paren\n"

"# The latter form is for a final parameter without trailing comma.\n"

"#\n"

"\n"

"param_no_default[arg_ty]:\n"

" | a=param ',' tc=TYPE_COMMENT? { _PyPegen_add_type_comment_to_arg(p, a, "

"tc) }\n"

" | a=param tc=TYPE_COMMENT? &')' { _PyPegen_add_type_comment_to_arg(p, a, "

"tc) }\n"

"param_no_default_star_annotation[arg_ty]:\n"

" | a=param_star_annotation ',' tc=TYPE_COMMENT? "

"{ _PyPegen_add_type_comment_to_arg(p, a, tc) }\n"

" | a=param_star_annotation tc=TYPE_COMMENT? "

"&')' { _PyPegen_add_type_comment_to_arg(p, a, tc) }\n"

"param_with_default[NameDefaultPair*]:\n"

" | a=param c=default ',' tc=TYPE_COMMENT? { _PyPegen_name_default_pair(p, "

"a, c, tc) }\n"

" | a=param c=default tc=TYPE_COMMENT? "

"&')' { _PyPegen_name_default_pair(p, a, c, tc) }\n"

"param_maybe_default[NameDefaultPair*]:\n"

" | a=param c=default? ',' tc=TYPE_COMMENT? "

"{ _PyPegen_name_default_pair(p, a, c, tc) }\n"

" | a=param c=default? tc=TYPE_COMMENT? "

"&')' { _PyPegen_name_default_pair(p, a, c, tc) }\n"

"param[arg_ty]: a=NAME b=annotation? { _PyAST_arg(a->v.Name.id, b, NULL, "

"EXTRA) }\n"

"param_star_annotation[arg_ty]: a=NAME b=star_annotation { _PyAST_arg(a->v."

"Name.id, b, NULL, EXTRA) }\n"

"annotation[expr_ty]: ':' a=expression { a }\n"

"star_annotation[expr_ty]: ':' a=star_expression { a }\n"

"default[expr_ty]: '=' a=expression { a } | invalid_default\n"

"\n"

"# If statement\n"

"# ------------\n"

"\n"

"if_stmt[stmt_ty]:\n"

" | invalid_if_stmt\n"

" | 'if' a=named_expression ':' b=block c=elif_stmt {\n"

" _PyAST_If(a, b, CHECK(asdl_stmt_seq*, _PyPegen_singleton_seq(p, c)), "

"EXTRA) }\n"

" | 'if' a=named_expression ':' b=block c=[else_block] { _PyAST_If(a, b, "

"c, EXTRA) }\n"

"elif_stmt[stmt_ty]:\n"

" | invalid_elif_stmt\n"

" | 'elif' a=named_expression ':' b=block c=elif_stmt {\n"

" _PyAST_If(a, b, CHECK(asdl_stmt_seq*, _PyPegen_singleton_seq(p, c)), "

"EXTRA) }\n"

" | 'elif' a=named_expression ':' b=block c=[else_block] { _PyAST_If(a, b, "

"c, EXTRA) }\n"

"else_block[asdl_stmt_seq*]:\n"

" | invalid_else_stmt\n"

" | 'else' &&':' b=block { b }\n"

"\n"

"# While statement\n"

"# ---------------\n"

"\n"

"while_stmt[stmt_ty]:\n"

" | invalid_while_stmt\n"

" | 'while' a=named_expression ':' b=block c=[else_block] "

"{ _PyAST_While(a, b, c, EXTRA) }\n"

"\n"

"# For statement\n"

"# -------------\n"

"\n"

"for_stmt[stmt_ty]:\n"

" | invalid_for_stmt\n"

" | 'for' t=star_targets 'in' ~ ex=star_expressions ':' tc=[TYPE_COMMENT] "

"b=block el=[else_block] {\n"

" _PyAST_For(t, ex, b, el, NEW_TYPE_COMMENT(p, tc), EXTRA) }\n"

" | 'async' 'for' t=star_targets 'in' ~ ex=star_expressions ':' "

"tc=[TYPE_COMMENT] b=block el=[else_block] {\n"

" CHECK_VERSION(stmt_ty, 5, \"Async for loops are\", "

"_PyAST_AsyncFor(t, ex, b, el, NEW_TYPE_COMMENT(p, tc), EXTRA)) }\n"

" | invalid_for_target\n"

"\n"

"# With statement\n"

"# --------------\n"

"\n"

"with_stmt[stmt_ty]:\n"

" | invalid_with_stmt_indent\n"

" | 'with' '(' a[asdl_withitem_seq*]=','.with_item+ ','? ')' ':' "

"tc=[TYPE_COMMENT] b=block {\n"

" _PyAST_With(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA) }\n"

" | 'with' a[asdl_withitem_seq*]=','.with_item+ ':' tc=[TYPE_COMMENT] "

"b=block {\n"

" _PyAST_With(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA) }\n"

" | 'async' 'with' '(' a[asdl_withitem_seq*]=','.with_item+ ','? ')' ':' "

"b=block {\n"

" CHECK_VERSION(stmt_ty, 5, \"Async with statements are\", "

"_PyAST_AsyncWith(a, b, NULL, EXTRA)) }\n"

" | 'async' 'with' a[asdl_withitem_seq*]=','.with_item+ ':' "

"tc=[TYPE_COMMENT] b=block {\n"

" CHECK_VERSION(stmt_ty, 5, \"Async with statements are\", "

"_PyAST_AsyncWith(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA)) }\n"

" | invalid_with_stmt\n"

"\n"

"with_item[withitem_ty]:\n"

" | e=expression 'as' t=star_target &(',' | ')' | ':') "

"{ _PyAST_withitem(e, t, p->arena) }\n"

" | invalid_with_item\n"

" | e=expression { _PyAST_withitem(e, NULL, p->arena) }\n"

"\n"

"# Try statement\n"

"# -------------\n"

"\n"

"try_stmt[stmt_ty]:\n"

" | invalid_try_stmt\n"

" | 'try' &&':' b=block f=finally_block { _PyAST_Try(b, NULL, NULL, f, "

"EXTRA) }\n"

" | 'try' &&':' b=block ex[asdl_excepthandler_seq*]=except_block+ "

"el=[else_block] f=[finally_block] { _PyAST_Try(b, ex, el, f, EXTRA) }\n"

" | 'try' &&':' b=block ex[asdl_excepthandler_seq*]=except_star_block+ "

"el=[else_block] f=[finally_block] {\n"

" CHECK_VERSION(stmt_ty, 11, \"Exception groups are\",\n"

" _PyAST_TryStar(b, ex, el, f, EXTRA)) }\n"

"\n"

"\n"

"# Except statement\n"

"# ----------------\n"

"\n"

"except_block[excepthandler_ty]:\n"

" | invalid_except_stmt_indent\n"

" | 'except' e=expression t=['as' z=NAME { z }] ':' b=block {\n"

" _PyAST_ExceptHandler(e, (t) ? ((expr_ty) t)->v.Name.id : NULL, b, "

"EXTRA) }\n"

" | 'except' ':' b=block { _PyAST_ExceptHandler(NULL, NULL, b, EXTRA) }\n"

" | invalid_except_stmt\n"

"except_star_block[excepthandler_ty]:\n"

" | invalid_except_star_stmt_indent\n"

" | 'except' '*' e=expression t=['as' z=NAME { z }] ':' b=block {\n"

" _PyAST_ExceptHandler(e, (t) ? ((expr_ty) t)->v.Name.id : NULL, b, "

"EXTRA) }\n"

" | invalid_except_stmt\n"

"finally_block[asdl_stmt_seq*]:\n"

" | invalid_finally_stmt\n"

" | 'finally' &&':' a=block { a }\n"

"\n"

"# Match statement\n"

"# ---------------\n"

"\n"

"match_stmt[stmt_ty]:\n"

" | \"match\" subject=subject_expr ':' NEWLINE INDENT "

"cases[asdl_match_case_seq*]=case_block+ DEDENT {\n"

" CHECK_VERSION(stmt_ty, 10, \"Pattern matching is\", "

"_PyAST_Match(subject, cases, EXTRA)) }\n"

" | invalid_match_stmt\n"

"\n"

"subject_expr[expr_ty]:\n"

" | value=star_named_expression ',' values=star_named_expressions? {\n"

" _PyAST_Tuple(CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, "

"value, values)), Load, EXTRA) }\n"

" | named_expression\n"

"\n"

"case_block[match_case_ty]:\n"

" | invalid_case_block\n"

" | \"case\" pattern=patterns guard=guard? ':' body=block {\n"

" _PyAST_match_case(pattern, guard, body, p->arena) }\n"

"\n"

"guard[expr_ty]: 'if' guard=named_expression { guard }\n"

"\n"

"patterns[pattern_ty]:\n"

" | patterns[asdl_pattern_seq*]=open_sequence_pattern {\n"

" _PyAST_MatchSequence(patterns, EXTRA) }\n"

" | pattern\n"

"\n"

"pattern[pattern_ty]:\n"

" | as_pattern\n"

" | or_pattern\n"

"\n"

"as_pattern[pattern_ty]:\n"

" | pattern=or_pattern 'as' target=pattern_capture_target {\n"

" _PyAST_MatchAs(pattern, target->v.Name.id, EXTRA) }\n"

" | invalid_as_pattern\n"

"\n"

"or_pattern[pattern_ty]:\n"

" | patterns[asdl_pattern_seq*]='|'.closed_pattern+ {\n"

" asdl_seq_LEN(patterns) == 1 ? asdl_seq_GET(patterns, 0) : "

"_PyAST_MatchOr(patterns, EXTRA) }\n"

"\n"

"closed_pattern[pattern_ty] (memo):\n"

" | literal_pattern\n"

" | capture_pattern\n"

" | wildcard_pattern\n"

" | value_pattern\n"

" | group_pattern\n"

" | sequence_pattern\n"

" | mapping_pattern\n"

" | class_pattern\n"

"\n"

"# Literal patterns are used for equality and identity constraints\n"

"literal_pattern[pattern_ty]:\n"

" | value=signed_number !('+' | '-') { _PyAST_MatchValue(value, EXTRA) }\n"

" | value=complex_number { _PyAST_MatchValue(value, EXTRA) }\n"

" | value=strings { _PyAST_MatchValue(value, EXTRA) }\n"

" | 'None' { _PyAST_MatchSingleton(Py_None, EXTRA) }\n"

" | 'True' { _PyAST_MatchSingleton(Py_True, EXTRA) }\n"

" | 'False' { _PyAST_MatchSingleton(Py_False, EXTRA) }\n"

"\n"

"# Literal expressions are used to restrict permitted mapping pattern keys\n"

"literal_expr[expr_ty]:\n"

" | signed_number !('+' | '-')\n"

" | complex_number\n"

" | strings\n"

" | 'None' { _PyAST_Constant(Py_None, NULL, EXTRA) }\n"

" | 'True' { _PyAST_Constant(Py_True, NULL, EXTRA) }\n"

" | 'False' { _PyAST_Constant(Py_False, NULL, EXTRA) }\n"

"\n"

"complex_number[expr_ty]:\n"

" | real=signed_real_number '+' imag=imaginary_number {\n"

" _PyAST_BinOp(real, Add, imag, EXTRA) }\n"

" | real=signed_real_number '-' imag=imaginary_number {\n"

" _PyAST_BinOp(real, Sub, imag, EXTRA) }\n"

"\n"

"signed_number[expr_ty]:\n"

" | NUMBER\n"

" | '-' number=NUMBER { _PyAST_UnaryOp(USub, number, EXTRA) }\n"

"\n"

"signed_real_number[expr_ty]:\n"

" | real_number\n"

" | '-' real=real_number { _PyAST_UnaryOp(USub, real, EXTRA) }\n"

"\n"

"real_number[expr_ty]:\n"

" | real=NUMBER { _PyPegen_ensure_real(p, real) }\n"

"\n"

"imaginary_number[expr_ty]:\n"

" | imag=NUMBER { _PyPegen_ensure_imaginary(p, imag) }\n"

"\n"

"capture_pattern[pattern_ty]:\n"

" | target=pattern_capture_target { _PyAST_MatchAs(NULL, target->v.Name."

"id, EXTRA) }\n"

"\n"

"pattern_capture_target[expr_ty]:\n"

" | !\"_\" name=NAME !('.' | '(' | '=') {\n"

" _PyPegen_set_expr_context(p, name, Store) }\n"

"\n"

"wildcard_pattern[pattern_ty]:\n"

" | \"_\" { _PyAST_MatchAs(NULL, NULL, EXTRA) }\n"

"\n"

"value_pattern[pattern_ty]:\n"

" | attr=attr !('.' | '(' | '=') { _PyAST_MatchValue(attr, EXTRA) }\n"

"\n"

"attr[expr_ty]:\n"

" | value=name_or_attr '.' attr=NAME {\n"

" _PyAST_Attribute(value, attr->v.Name.id, Load, EXTRA) }\n"

"\n"

"name_or_attr[expr_ty]:\n"

" | attr\n"

" | NAME\n"

"\n"

"group_pattern[pattern_ty]:\n"

" | '(' pattern=pattern ')' { pattern }\n"

"\n"

"sequence_pattern[pattern_ty]:\n"

" | '[' patterns=maybe_sequence_pattern? "

"']' { _PyAST_MatchSequence(patterns, EXTRA) }\n"

" | '(' patterns=open_sequence_pattern? "

"')' { _PyAST_MatchSequence(patterns, EXTRA) }\n"

"\n"

"open_sequence_pattern[asdl_seq*]:\n"

" | pattern=maybe_star_pattern ',' patterns=maybe_sequence_pattern? {\n"

" _PyPegen_seq_insert_in_front(p, pattern, patterns) }\n"

"\n"

"maybe_sequence_pattern[asdl_seq*]:\n"

" | patterns=','.maybe_star_pattern+ ','? { patterns }\n"

"\n"

"maybe_star_pattern[pattern_ty]:\n"

" | star_pattern\n"

" | pattern\n"

"\n"

"star_pattern[pattern_ty] (memo):\n"

" | '*' target=pattern_capture_target {\n"

" _PyAST_MatchStar(target->v.Name.id, EXTRA) }\n"

" | '*' wildcard_pattern {\n"

" _PyAST_MatchStar(NULL, EXTRA) }\n"

"\n"

"mapping_pattern[pattern_ty]:\n"

" | '{' '}' {\n"

" _PyAST_MatchMapping(NULL, NULL, NULL, EXTRA) }\n"

" | '{' rest=double_star_pattern ','? '}' {\n"

" _PyAST_MatchMapping(NULL, NULL, rest->v.Name.id, EXTRA) }\n"

" | '{' items=items_pattern ',' rest=double_star_pattern ','? '}' {\n"

" _PyAST_MatchMapping(\n"

" CHECK(asdl_expr_seq*, _PyPegen_get_pattern_keys(p, items)),\n"

" CHECK(asdl_pattern_seq*, _PyPegen_get_patterns(p, items)),\n"

" rest->v.Name.id,\n"

" EXTRA) }\n"

" | '{' items=items_pattern ','? '}' {\n"

" _PyAST_MatchMapping(\n"

" CHECK(asdl_expr_seq*, _PyPegen_get_pattern_keys(p, items)),\n"

" CHECK(asdl_pattern_seq*, _PyPegen_get_patterns(p, items)),\n"

" NULL,\n"

" EXTRA) }\n"

"\n"

"items_pattern[asdl_seq*]:\n"

" | ','.key_value_pattern+\n"

"\n"

"key_value_pattern[KeyPatternPair*]:\n"

" | key=(literal_expr | attr) ':' pattern=pattern {\n"

" _PyPegen_key_pattern_pair(p, key, pattern) }\n"

"\n"

"double_star_pattern[expr_ty]:\n"

" | '**' target=pattern_capture_target { target }\n"

"\n"

"class_pattern[pattern_ty]:\n"

" | cls=name_or_attr '(' ')' {\n"

" _PyAST_MatchClass(cls, NULL, NULL, NULL, EXTRA) }\n"

" | cls=name_or_attr '(' patterns=positional_patterns ','? ')' {\n"

" _PyAST_MatchClass(cls, patterns, NULL, NULL, EXTRA) }\n"

" | cls=name_or_attr '(' keywords=keyword_patterns ','? ')' {\n"

" _PyAST_MatchClass(\n"

" cls, NULL,\n"

" CHECK(asdl_identifier_seq*, _PyPegen_map_names_to_ids(p,\n"

" CHECK(asdl_expr_seq*, _PyPegen_get_pattern_keys(p, "

"keywords)))),\n"

" CHECK(asdl_pattern_seq*, _PyPegen_get_patterns(p, keywords)),\n"

" EXTRA) }\n"

" | cls=name_or_attr '(' patterns=positional_patterns ',' "

"keywords=keyword_patterns ','? ')' {\n"

" _PyAST_MatchClass(\n"

" cls,\n"

" patterns,\n"

" CHECK(asdl_identifier_seq*, _PyPegen_map_names_to_ids(p,\n"

" CHECK(asdl_expr_seq*, _PyPegen_get_pattern_keys(p, "

"keywords)))),\n"

" CHECK(asdl_pattern_seq*, _PyPegen_get_patterns(p, keywords)),\n"

" EXTRA) }\n"

" | invalid_class_pattern\n"

"\n"

"positional_patterns[asdl_pattern_seq*]:\n"

" | args[asdl_pattern_seq*]=','.pattern+ { args }\n"

"\n"

"keyword_patterns[asdl_seq*]:\n"

" | ','.keyword_pattern+\n"

"\n"

"keyword_pattern[KeyPatternPair*]:\n"

" | arg=NAME '=' value=pattern { _PyPegen_key_pattern_pair(p, arg, "

"value) }\n"

"\n"

"# Type statement\n"

"# ---------------\n"

"\n"

"type_alias[stmt_ty]:\n"

" | \"type\" n=NAME t=[type_params] '=' b=expression {\n"

" CHECK_VERSION(stmt_ty, 12, \"Type statement is\",\n"

" _PyAST_TypeAlias(CHECK(expr_ty, _PyPegen_set_expr_context(p, n, "

"Store)), t, b, EXTRA)) }\n"

"\n"

"# Type parameter declaration\n"

"# --------------------------\n"

"\n"

"type_params[asdl_type_param_seq*]:\n"

" | invalid_type_params\n"

" | '[' t=type_param_seq ']' {\n"

" CHECK_VERSION(asdl_type_param_seq *, 12, \"Type parameter lists "

"are\", t) }\n"

"\n"

"type_param_seq[asdl_type_param_seq*]: a[asdl_type_param_seq*]=','."

"type_param+ [','] { a }\n"

"\n"

"type_param[type_param_ty] (memo):\n"

" | a=NAME b=[type_param_bound] c=[type_param_default] { _PyAST_TypeVar(a-"

">v.Name.id, b, c, EXTRA) }\n"

" | '*' a=NAME colon=':' e=expression {\n"

" RAISE_SYNTAX_ERROR_STARTING_FROM(colon, e->kind == Tuple_kind\n"

" ? \"cannot use constraints with TypeVarTuple\"\n"

" : \"cannot use bound with TypeVarTuple\")\n"

" }\n"

" | '*' a=NAME b=[type_param_starred_default] { _PyAST_TypeVarTuple(a->v."

"Name.id, b, EXTRA) }\n"

" | '**' a=NAME colon=':' e=expression {\n"

" RAISE_SYNTAX_ERROR_STARTING_FROM(colon, e->kind == Tuple_kind\n"

" ? \"cannot use constraints with ParamSpec\"\n"

" : \"cannot use bound with ParamSpec\")\n"

" }\n"

" | '**' a=NAME b=[type_param_default] { _PyAST_ParamSpec(a->v.Name.id, b, "

"EXTRA) }\n"

"\n"

"type_param_bound[expr_ty]: ':' e=expression { e }\n"

"type_param_default[expr_ty]: '=' e=expression {\n"

" CHECK_VERSION(expr_ty, 13, \"Type parameter defaults are\", e) }\n"

"type_param_starred_default[expr_ty]: '=' e=star_expression {\n"

" CHECK_VERSION(expr_ty, 13, \"Type parameter defaults are\", e) }\n"

"\n"

"# EXPRESSIONS\n"

"# -----------\n"

"\n"

"expressions[expr_ty]:\n"

" | a=expression b=(',' c=expression { c })+ [','] {\n"

" _PyAST_Tuple(CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, "

"a, b)), Load, EXTRA) }\n"

" | a=expression ',' { _PyAST_Tuple(CHECK(asdl_expr_seq*, "

"_PyPegen_singleton_seq(p, a)), Load, EXTRA) }\n"

" | expression\n"

"\n"

"expression[expr_ty] (memo):\n"

" | invalid_expression\n"

" | invalid_legacy_expression\n"

" | a=disjunction 'if' b=disjunction 'else' c=expression { _PyAST_IfExp(b, "

"a, c, EXTRA) }\n"

" | disjunction\n"

" | lambdef\n"

"\n"

"yield_expr[expr_ty]:\n"

" | 'yield' 'from' a=expression { _PyAST_YieldFrom(a, EXTRA) }\n"

" | 'yield' a=[star_expressions] { _PyAST_Yield(a, EXTRA) }\n"

"\n"

"star_expressions[expr_ty]:\n"

" | a=star_expression b=(',' c=star_expression { c })+ [','] {\n"

" _PyAST_Tuple(CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, "

"a, b)), Load, EXTRA) }\n"

" | a=star_expression ',' { _PyAST_Tuple(CHECK(asdl_expr_seq*, "

"_PyPegen_singleton_seq(p, a)), Load, EXTRA) }\n"

" | star_expression\n"

"\n"

"star_expression[expr_ty] (memo):\n"

" | '*' a=bitwise_or { _PyAST_Starred(a, Load, EXTRA) }\n"

" | expression\n"

"\n"

"star_named_expressions[asdl_expr_seq*]: a[asdl_expr_seq*]=','."

"star_named_expression+ [','] { a }\n"

"\n"

"star_named_expression[expr_ty]:\n"

" | '*' a=bitwise_or { _PyAST_Starred(a, Load, EXTRA) }\n"

" | named_expression\n"

"\n"

"assignment_expression[expr_ty]:\n"

" | a=NAME ':=' ~ b=expression {\n"

" CHECK_VERSION(expr_ty, 8, \"Assignment expressions are\",\n"

" _PyAST_NamedExpr(CHECK(expr_ty, _PyPegen_set_expr_context(p, a, "

"Store)), b, EXTRA)) }\n"

"\n"

"named_expression[expr_ty]:\n"

" | assignment_expression\n"

" | invalid_named_expression\n"

" | expression !':='\n"

"\n"

"disjunction[expr_ty] (memo):\n"

" | a=conjunction b=('or' c=conjunction { c })+ { _PyAST_BoolOp(\n"

" Or,\n"

" CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, a, b)),\n"

" EXTRA) }\n"

" | conjunction\n"

"\n"

"conjunction[expr_ty] (memo):\n"

" | a=inversion b=('and' c=inversion { c })+ { _PyAST_BoolOp(\n"

" And,\n"

" CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, a, b)),\n"

" EXTRA) }\n"

" | inversion\n"

"\n"

"inversion[expr_ty] (memo):\n"

" | 'not' a=inversion { _PyAST_UnaryOp(Not, a, EXTRA) }\n"

" | comparison\n"

"\n"

"# Comparison operators\n"

"# --------------------\n"

"\n"

"comparison[expr_ty]:\n"

" | a=bitwise_or b=compare_op_bitwise_or_pair+ {\n"

" _PyAST_Compare(\n"

" a,\n"

" CHECK(asdl_int_seq*, _PyPegen_get_cmpops(p, b)),\n"

" CHECK(asdl_expr_seq*, _PyPegen_get_exprs(p, b)),\n"

" EXTRA) }\n"

" | bitwise_or\n"

"\n"

"compare_op_bitwise_or_pair[CmpopExprPair*]:\n"

" | eq_bitwise_or\n"

" | noteq_bitwise_or\n"

" | lte_bitwise_or\n"

" | lt_bitwise_or\n"

" | gte_bitwise_or\n"

" | gt_bitwise_or\n"

" | notin_bitwise_or\n"

" | in_bitwise_or\n"

" | isnot_bitwise_or\n"

" | is_bitwise_or\n"

"\n"

"eq_bitwise_or[CmpopExprPair*]: '==' a=bitwise_or "

"{ _PyPegen_cmpop_expr_pair(p, Eq, a) }\n"

"noteq_bitwise_or[CmpopExprPair*]:\n"

" | (tok='!=' { _PyPegen_check_barry_as_flufl(p, tok) ? NULL : tok}) "

"a=bitwise_or {_PyPegen_cmpop_expr_pair(p, NotEq, a) }\n"

"lte_bitwise_or[CmpopExprPair*]: '<=' a=bitwise_or "

"{ _PyPegen_cmpop_expr_pair(p, LtE, a) }\n"

"lt_bitwise_or[CmpopExprPair*]: '<' a=bitwise_or "

"{ _PyPegen_cmpop_expr_pair(p, Lt, a) }\n"

"gte_bitwise_or[CmpopExprPair*]: '>=' a=bitwise_or "

"{ _PyPegen_cmpop_expr_pair(p, GtE, a) }\n"

"gt_bitwise_or[CmpopExprPair*]: '>' a=bitwise_or "

"{ _PyPegen_cmpop_expr_pair(p, Gt, a) }\n"

"notin_bitwise_or[CmpopExprPair*]: 'not' 'in' a=bitwise_or "

"{ _PyPegen_cmpop_expr_pair(p, NotIn, a) }\n"

"in_bitwise_or[CmpopExprPair*]: 'in' a=bitwise_or "

"{ _PyPegen_cmpop_expr_pair(p, In, a) }\n"

"isnot_bitwise_or[CmpopExprPair*]: 'is' 'not' a=bitwise_or "

"{ _PyPegen_cmpop_expr_pair(p, IsNot, a) }\n"

"is_bitwise_or[CmpopExprPair*]: 'is' a=bitwise_or "

"{ _PyPegen_cmpop_expr_pair(p, Is, a) }\n"

"\n"

"# Bitwise operators\n"

"# -----------------\n"

"\n"

"bitwise_or[expr_ty]:\n"

" | a=bitwise_or '|' b=bitwise_xor { _PyAST_BinOp(a, BitOr, b, EXTRA) }\n"

" | bitwise_xor\n"

"\n"

"bitwise_xor[expr_ty]:\n"

" | a=bitwise_xor '^' b=bitwise_and { _PyAST_BinOp(a, BitXor, b, EXTRA) }\n"

" | bitwise_and\n"

"\n"

"bitwise_and[expr_ty]:\n"

" | a=bitwise_and '&' b=shift_expr { _PyAST_BinOp(a, BitAnd, b, EXTRA) }\n"

" | shift_expr\n"

"\n"

"shift_expr[expr_ty]:\n"

" | a=shift_expr '<<' b=sum { _PyAST_BinOp(a, LShift, b, EXTRA) }\n"

" | a=shift_expr '>>' b=sum { _PyAST_BinOp(a, RShift, b, EXTRA) }\n"

" | invalid_arithmetic\n"

" | sum\n"

"\n"

"# Arithmetic operators\n"

"# --------------------\n"

"\n"

"sum[expr_ty]:\n"

" | a=sum '+' b=term { _PyAST_BinOp(a, Add, b, EXTRA) }\n"

" | a=sum '-' b=term { _PyAST_BinOp(a, Sub, b, EXTRA) }\n"

" | term\n"

"\n"

"term[expr_ty]:\n"

" | a=term '*' b=factor { _PyAST_BinOp(a, Mult, b, EXTRA) }\n"

" | a=term '/' b=factor { _PyAST_BinOp(a, Div, b, EXTRA) }\n"

" | a=term '//' b=factor { _PyAST_BinOp(a, FloorDiv, b, EXTRA) }\n"

" | a=term '%' b=factor { _PyAST_BinOp(a, Mod, b, EXTRA) }\n"

" | a=term '@' b=factor { CHECK_VERSION(expr_ty, 5, \"The '@' operator "

"is\", _PyAST_BinOp(a, MatMult, b, EXTRA)) }\n"

" | invalid_factor\n"

" | factor\n"

"\n"

"factor[expr_ty] (memo):\n"

" | '+' a=factor { _PyAST_UnaryOp(UAdd, a, EXTRA) }\n"

" | '-' a=factor { _PyAST_UnaryOp(USub, a, EXTRA) }\n"

" | '~' a=factor { _PyAST_UnaryOp(Invert, a, EXTRA) }\n"

" | power\n"

"\n"

"power[expr_ty]:\n"

" | a=await_primary '**' b=factor { _PyAST_BinOp(a, Pow, b, EXTRA) }\n"

" | await_primary\n"

"\n"

"# Primary elements\n"

"# ----------------\n"

"\n"

"# Primary elements are things like \"obj.something.something\", "

"\"obj[something]\", \"obj(something)\", \"obj\" ...\n"

"\n"

"await_primary[expr_ty] (memo):\n"

" | 'await' a=primary { CHECK_VERSION(expr_ty, 5, \"Await expressions "

"are\", _PyAST_Await(a, EXTRA)) }\n"

" | primary\n"

"\n"

"primary[expr_ty]:\n"

" | a=primary '.' b=NAME { _PyAST_Attribute(a, b->v.Name.id, Load, "

"EXTRA) }\n"

" | a=primary b=genexp { _PyAST_Call(a, CHECK(asdl_expr_seq*, "

"(asdl_expr_seq*)_PyPegen_singleton_seq(p, b)), NULL, EXTRA) }\n"

" | a=primary '(' b=[arguments] ')' {\n"

" _PyAST_Call(a,\n"

" (b) ? ((expr_ty) b)->v.Call.args : NULL,\n"