Skip to content

Instantly share code, notes, and snippets.

@sobolevn

sobolevn/parse.py

Created August 30, 2022 11:44
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save sobolevn/37cfd12ad9d2c157e72e7589747f4ed2 to your computer and use it in GitHub Desktop.
Save sobolevn/37cfd12ad9d2c157e72e7589747f4ed2 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
parse.py
#!/usr/bin/env python3.8
# @generated by pegen from python.gram
import ast
import sys
import tokenize
from typing import Any, Optional
from pegen.parser import memoize, memoize_left_rec, logger, Parser
# Keywords and soft keywords are listed at the end of the parser definition.
class GeneratedParser(Parser):
@memoize
def file(self) -> Optional[mod_ty]:
# file: statements? $
mark = self._mark()
if (
(a := self.statements(),)
and
(_endmarker := self.expect('ENDMARKER'))
):
return _PyPegen_make_module ( p , a )
self._reset(mark)
return None
@memoize
def interactive(self) -> Optional[mod_ty]:
# interactive: statement_newline
mark = self._mark()
if (
(a := self.statement_newline())
):
return _PyAST_Interactive ( a , p -> arena )
self._reset(mark)
return None
@memoize
def eval(self) -> Optional[mod_ty]:
# eval: expressions NEWLINE* $
mark = self._mark()
if (
(a := self.expressions())
and
(_loop0_1 := self._loop0_1(),)
and
(_endmarker := self.expect('ENDMARKER'))
):
return _PyAST_Expression ( a , p -> arena )
self._reset(mark)
return None
@memoize
def func_type(self) -> Optional[mod_ty]:
# func_type: '(' type_expressions? ')' '->' expression NEWLINE* $
mark = self._mark()
if (
(literal := self.expect('('))
and
(a := self.type_expressions(),)
and
(literal_1 := self.expect(')'))
and
(literal_2 := self.expect('->'))
and
(b := self.expression())
and
(_loop0_2 := self._loop0_2(),)
and
(_endmarker := self.expect('ENDMARKER'))
):
return _PyAST_FunctionType ( a , b , p -> arena )
self._reset(mark)
return None
@memoize
def fstring(self) -> Optional[expr_ty]:
# fstring: star_expressions
mark = self._mark()
if (
(star_expressions := self.star_expressions())
):
return star_expressions
self._reset(mark)
return None
@memoize
def statements(self) -> Optional[asdl_stmt_seq*]:
# statements: statement+
mark = self._mark()
if (
(a := self._loop1_3())
):
return ( asdl_stmt_seq* ) _PyPegen_seq_flatten ( p , a )
self._reset(mark)
return None
@memoize
def statement(self) -> Optional[asdl_stmt_seq*]:
# statement: compound_stmt | simple_stmts
mark = self._mark()
if (
(a := self.compound_stmt())
):
return ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a )
self._reset(mark)
if (
(a := self.simple_stmts())
):
return a
self._reset(mark)
return None
@memoize
def statement_newline(self) -> Optional[asdl_stmt_seq*]:
# statement_newline: compound_stmt NEWLINE | simple_stmts | NEWLINE | $
mark = self._mark()
if (
(a := self.compound_stmt())
and
(_newline := self.expect('NEWLINE'))
):
return ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a )
self._reset(mark)
if (
(simple_stmts := self.simple_stmts())
):
return simple_stmts
self._reset(mark)
if (
(_newline := self.expect('NEWLINE'))
):
return ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , CHECK ( stmt_ty , _PyAST_Pass ( EXTRA ) ) )
self._reset(mark)
if (
(_endmarker := self.expect('ENDMARKER'))
):
return _PyPegen_interactive_exit ( p )
self._reset(mark)
return None
@memoize
def simple_stmts(self) -> Optional[asdl_stmt_seq*]:
# simple_stmts: simple_stmt !';' NEWLINE | ';'.simple_stmt+ ';'? NEWLINE
mark = self._mark()
if (
(a := self.simple_stmt())
and
self.negative_lookahead(self.expect, ';')
and
(_newline := self.expect('NEWLINE'))
):
return ( asdl_stmt_seq* ) _PyPegen_singleton_seq ( p , a )
self._reset(mark)
if (
(a := self._gather_4())
and
(opt := self.expect(';'),)
and
(_newline := self.expect('NEWLINE'))
):
return a
self._reset(mark)
return None
@memoize
def simple_stmt(self) -> Optional[stmt_ty]:
# simple_stmt: assignment | star_expressions | &'return' return_stmt | &('import' | 'from') import_stmt | &'raise' raise_stmt | 'pass' | &'del' del_stmt | &'yield' yield_stmt | &'assert' assert_stmt | 'break' | 'continue' | &'global' global_stmt | &'nonlocal' nonlocal_stmt
mark = self._mark()
if (
(assignment := self.assignment())
):
return assignment
self._reset(mark)
if (
(e := self.star_expressions())
):
return _PyAST_Expr ( e , EXTRA )
self._reset(mark)
if (
self.positive_lookahead(self.expect, 'return')
and
(return_stmt := self.return_stmt())
):
return return_stmt
self._reset(mark)
if (
self.positive_lookahead(self._tmp_6, )
and
(import_stmt := self.import_stmt())
):
return import_stmt
self._reset(mark)
if (
self.positive_lookahead(self.expect, 'raise')
and
(raise_stmt := self.raise_stmt())
):
return raise_stmt
self._reset(mark)
if (
(literal := self.expect('pass'))
):
return _PyAST_Pass ( EXTRA )
self._reset(mark)
if (
self.positive_lookahead(self.expect, 'del')
and
(del_stmt := self.del_stmt())
):
return del_stmt
self._reset(mark)
if (
self.positive_lookahead(self.expect, 'yield')
and
(yield_stmt := self.yield_stmt())
):
return yield_stmt
self._reset(mark)
if (
self.positive_lookahead(self.expect, 'assert')
and
(assert_stmt := self.assert_stmt())
):
return assert_stmt
self._reset(mark)
if (
(literal := self.expect('break'))
):
return _PyAST_Break ( EXTRA )
self._reset(mark)
if (
(literal := self.expect('continue'))
):
return _PyAST_Continue ( EXTRA )
self._reset(mark)
if (
self.positive_lookahead(self.expect, 'global')
and
(global_stmt := self.global_stmt())
):
return global_stmt
self._reset(mark)
if (
self.positive_lookahead(self.expect, 'nonlocal')
and
(nonlocal_stmt := self.nonlocal_stmt())
):
return nonlocal_stmt
self._reset(mark)
return None
@memoize
def compound_stmt(self) -> Optional[stmt_ty]:
# compound_stmt: &('def' | '@' | ASYNC) function_def | &'if' if_stmt | &('class' | '@') class_def | &('with' | ASYNC) with_stmt | &('for' | ASYNC) for_stmt | &'try' try_stmt | &'while' while_stmt | match_stmt
mark = self._mark()
if (
self.positive_lookahead(self._tmp_7, )
and
(function_def := self.function_def())
):
return function_def
self._reset(mark)
if (
self.positive_lookahead(self.expect, 'if')
and
(if_stmt := self.if_stmt())
):
return if_stmt
self._reset(mark)
if (
self.positive_lookahead(self._tmp_8, )
and
(class_def := self.class_def())
):
return class_def
self._reset(mark)
if (
self.positive_lookahead(self._tmp_9, )
and
(with_stmt := self.with_stmt())
):
return with_stmt
self._reset(mark)
if (
self.positive_lookahead(self._tmp_10, )
and
(for_stmt := self.for_stmt())
):
return for_stmt
self._reset(mark)
if (
self.positive_lookahead(self.expect, 'try')
and
(try_stmt := self.try_stmt())
):
return try_stmt
self._reset(mark)
if (
self.positive_lookahead(self.expect, 'while')
and
(while_stmt := self.while_stmt())
):
return while_stmt
self._reset(mark)
if (
(match_stmt := self.match_stmt())
):
return match_stmt
self._reset(mark)
return None
@memoize
def assignment(self) -> Optional[stmt_ty]:
# assignment: NAME ':' expression ['=' annotated_rhs] | ('(' single_target ')' | single_subscript_attribute_target) ':' expression ['=' annotated_rhs] | ((star_targets '='))+ (yield_expr | star_expressions) !'=' TYPE_COMMENT? | single_target augassign ~ (yield_expr | star_expressions) | invalid_assignment
mark = self._mark()
if (
(a := self.name())
and
(literal := self.expect(':'))
and
(b := self.expression())
and
(c := self._tmp_11(),)
):
return CHECK_VERSION ( stmt_ty , 6 , "Variable annotation syntax is" , _PyAST_AnnAssign ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b , c , 1 , EXTRA ) )
self._reset(mark)
if (
(a := self._tmp_12())
and
(literal := self.expect(':'))
and
(b := self.expression())
and
(c := self._tmp_13(),)
):
return CHECK_VERSION ( stmt_ty , 6 , "Variable annotations syntax is" , _PyAST_AnnAssign ( a , b , c , 0 , EXTRA ) )
self._reset(mark)
if (
(a := self._loop1_14())
and
(b := self._tmp_15())
and
self.negative_lookahead(self.expect, '=')
and
(tc := self.type_comment(),)
):
return _PyAST_Assign ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA )
self._reset(mark)
cut = False
if (
(a := self.single_target())
and
(b := self.augassign())
and
(cut := True)
and
(c := self._tmp_16())
):
return _PyAST_AugAssign ( a , b -> kind , c , EXTRA )
self._reset(mark)
if cut: return None
if (
(invalid_assignment := self.invalid_assignment())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def annotated_rhs(self) -> Optional[expr_ty]:
# annotated_rhs: yield_expr | star_expressions
mark = self._mark()
if (
(yield_expr := self.yield_expr())
):
return yield_expr
self._reset(mark)
if (
(star_expressions := self.star_expressions())
):
return star_expressions
self._reset(mark)
return None
@memoize
def augassign(self) -> Optional[AugOperator*]:
# augassign: '+=' | '-=' | '*=' | '@=' | '/=' | '%=' | '&=' | '|=' | '^=' | '<<=' | '>>=' | '**=' | '//='
mark = self._mark()
if (
(literal := self.expect('+='))
):
return _PyPegen_augoperator ( p , Add )
self._reset(mark)
if (
(literal := self.expect('-='))
):
return _PyPegen_augoperator ( p , Sub )
self._reset(mark)
if (
(literal := self.expect('*='))
):
return _PyPegen_augoperator ( p , Mult )
self._reset(mark)
if (
(literal := self.expect('@='))
):
return CHECK_VERSION ( AugOperator* , 5 , "The '@' operator is" , _PyPegen_augoperator ( p , MatMult ) )
self._reset(mark)
if (
(literal := self.expect('/='))
):
return _PyPegen_augoperator ( p , Div )
self._reset(mark)
if (
(literal := self.expect('%='))
):
return _PyPegen_augoperator ( p , Mod )
self._reset(mark)
if (
(literal := self.expect('&='))
):
return _PyPegen_augoperator ( p , BitAnd )
self._reset(mark)
if (
(literal := self.expect('|='))
):
return _PyPegen_augoperator ( p , BitOr )
self._reset(mark)
if (
(literal := self.expect('^='))
):
return _PyPegen_augoperator ( p , BitXor )
self._reset(mark)
if (
(literal := self.expect('<<='))
):
return _PyPegen_augoperator ( p , LShift )
self._reset(mark)
if (
(literal := self.expect('>>='))
):
return _PyPegen_augoperator ( p , RShift )
self._reset(mark)
if (
(literal := self.expect('**='))
):
return _PyPegen_augoperator ( p , Pow )
self._reset(mark)
if (
(literal := self.expect('//='))
):
return _PyPegen_augoperator ( p , FloorDiv )
self._reset(mark)
return None
@memoize
def return_stmt(self) -> Optional[stmt_ty]:
# return_stmt: 'return' star_expressions?
mark = self._mark()
if (
(literal := self.expect('return'))
and
(a := self.star_expressions(),)
):
return _PyAST_Return ( a , EXTRA )
self._reset(mark)
return None
@memoize
def raise_stmt(self) -> Optional[stmt_ty]:
# raise_stmt: 'raise' expression ['from' expression] | 'raise'
mark = self._mark()
if (
(literal := self.expect('raise'))
and
(a := self.expression())
and
(b := self._tmp_17(),)
):
return _PyAST_Raise ( a , b , EXTRA )
self._reset(mark)
if (
(literal := self.expect('raise'))
):
return _PyAST_Raise ( NULL , NULL , EXTRA )
self._reset(mark)
return None
@memoize
def global_stmt(self) -> Optional[stmt_ty]:
# global_stmt: 'global' ','.NAME+
mark = self._mark()
if (
(literal := self.expect('global'))
and
(a := self._gather_18())
):
return _PyAST_Global ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA )
self._reset(mark)
return None
@memoize
def nonlocal_stmt(self) -> Optional[stmt_ty]:
# nonlocal_stmt: 'nonlocal' ','.NAME+
mark = self._mark()
if (
(literal := self.expect('nonlocal'))
and
(a := self._gather_20())
):
return _PyAST_Nonlocal ( CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , a ) ) , EXTRA )
self._reset(mark)
return None
@memoize
def del_stmt(self) -> Optional[stmt_ty]:
# del_stmt: 'del' del_targets &(';' | NEWLINE) | invalid_del_stmt
mark = self._mark()
if (
(literal := self.expect('del'))
and
(a := self.del_targets())
and
self.positive_lookahead(self._tmp_22, )
):
return _PyAST_Delete ( a , EXTRA )
self._reset(mark)
if (
(invalid_del_stmt := self.invalid_del_stmt())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def yield_stmt(self) -> Optional[stmt_ty]:
# yield_stmt: yield_expr
mark = self._mark()
if (
(y := self.yield_expr())
):
return _PyAST_Expr ( y , EXTRA )
self._reset(mark)
return None
@memoize
def assert_stmt(self) -> Optional[stmt_ty]:
# assert_stmt: 'assert' expression [',' expression]
mark = self._mark()
if (
(literal := self.expect('assert'))
and
(a := self.expression())
and
(b := self._tmp_23(),)
):
return _PyAST_Assert ( a , b , EXTRA )
self._reset(mark)
return None
@memoize
def import_stmt(self) -> Optional[stmt_ty]:
# import_stmt: import_name | import_from
mark = self._mark()
if (
(import_name := self.import_name())
):
return import_name
self._reset(mark)
if (
(import_from := self.import_from())
):
return import_from
self._reset(mark)
return None
@memoize
def import_name(self) -> Optional[stmt_ty]:
# import_name: 'import' dotted_as_names
mark = self._mark()
if (
(literal := self.expect('import'))
and
(a := self.dotted_as_names())
):
return _PyAST_Import ( a , EXTRA )
self._reset(mark)
return None
@memoize
def import_from(self) -> Optional[stmt_ty]:
# import_from: 'from' (('.' | '...'))* dotted_name 'import' import_from_targets | 'from' (('.' | '...'))+ 'import' import_from_targets
mark = self._mark()
if (
(literal := self.expect('from'))
and
(a := self._loop0_24(),)
and
(b := self.dotted_name())
and
(literal_1 := self.expect('import'))
and
(c := self.import_from_targets())
):
return _PyAST_ImportFrom ( b -> v . Name . id , c , _PyPegen_seq_count_dots ( a ) , EXTRA )
self._reset(mark)
if (
(literal := self.expect('from'))
and
(a := self._loop1_25())
and
(literal_1 := self.expect('import'))
and
(b := self.import_from_targets())
):
return _PyAST_ImportFrom ( NULL , b , _PyPegen_seq_count_dots ( a ) , EXTRA )
self._reset(mark)
return None
@memoize
def import_from_targets(self) -> Optional[asdl_alias_seq*]:
# import_from_targets: '(' import_from_as_names ','? ')' | import_from_as_names !',' | '*' | invalid_import_from_targets
mark = self._mark()
if (
(literal := self.expect('('))
and
(a := self.import_from_as_names())
and
(opt := self.expect(','),)
and
(literal_1 := self.expect(')'))
):
return a
self._reset(mark)
if (
(import_from_as_names := self.import_from_as_names())
and
self.negative_lookahead(self.expect, ',')
):
return import_from_as_names
self._reset(mark)
if (
(literal := self.expect('*'))
):
return ( asdl_alias_seq* ) _PyPegen_singleton_seq ( p , CHECK ( alias_ty , _PyPegen_alias_for_star ( p , EXTRA ) ) )
self._reset(mark)
if (
(invalid_import_from_targets := self.invalid_import_from_targets())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def import_from_as_names(self) -> Optional[asdl_alias_seq*]:
# import_from_as_names: ','.import_from_as_name+
mark = self._mark()
if (
(a := self._gather_26())
):
return a
self._reset(mark)
return None
@memoize
def import_from_as_name(self) -> Optional[alias_ty]:
# import_from_as_name: NAME ['as' NAME]
mark = self._mark()
if (
(a := self.name())
and
(b := self._tmp_28(),)
):
return _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , EXTRA )
self._reset(mark)
return None
@memoize
def dotted_as_names(self) -> Optional[asdl_alias_seq*]:
# dotted_as_names: ','.dotted_as_name+
mark = self._mark()
if (
(a := self._gather_29())
):
return a
self._reset(mark)
return None
@memoize
def dotted_as_name(self) -> Optional[alias_ty]:
# dotted_as_name: dotted_name ['as' NAME]
mark = self._mark()
if (
(a := self.dotted_name())
and
(b := self._tmp_31(),)
):
return _PyAST_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , EXTRA )
self._reset(mark)
return None
@memoize_left_rec
def dotted_name(self) -> Optional[expr_ty]:
# dotted_name: dotted_name '.' NAME | NAME
mark = self._mark()
if (
(a := self.dotted_name())
and
(literal := self.expect('.'))
and
(b := self.name())
):
return _PyPegen_join_names_with_dot ( p , a , b )
self._reset(mark)
if (
(name := self.name())
):
return name
self._reset(mark)
return None
@memoize
def block(self) -> Optional[asdl_stmt_seq*]:
# block: NEWLINE INDENT statements DEDENT | simple_stmts | invalid_block
mark = self._mark()
if (
(_newline := self.expect('NEWLINE'))
and
(_indent := self.expect('INDENT'))
and
(a := self.statements())
and
(_dedent := self.expect('DEDENT'))
):
return a
self._reset(mark)
if (
(simple_stmts := self.simple_stmts())
):
return simple_stmts
self._reset(mark)
if (
(invalid_block := self.invalid_block())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def decorators(self) -> Optional[asdl_expr_seq*]:
# decorators: (('@' named_expression NEWLINE))+
mark = self._mark()
if (
(a := self._loop1_32())
):
return a
self._reset(mark)
return None
@memoize
def class_def(self) -> Optional[stmt_ty]:
# class_def: decorators class_def_raw | class_def_raw
mark = self._mark()
if (
(a := self.decorators())
and
(b := self.class_def_raw())
):
return _PyPegen_class_def_decorators ( p , a , b )
self._reset(mark)
if (
(class_def_raw := self.class_def_raw())
):
return class_def_raw
self._reset(mark)
return None
@memoize
def class_def_raw(self) -> Optional[stmt_ty]:
# class_def_raw: invalid_class_def_raw | 'class' NAME ['(' arguments? ')'] ':' block
mark = self._mark()
if (
(invalid_class_def_raw := self.invalid_class_def_raw())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('class'))
and
(a := self.name())
and
(b := self._tmp_33(),)
and
(literal_1 := self.expect(':'))
and
(c := self.block())
):
return _PyAST_ClassDef ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , c , NULL , EXTRA )
self._reset(mark)
return None
@memoize
def function_def(self) -> Optional[stmt_ty]:
# function_def: decorators function_def_raw | function_def_raw
mark = self._mark()
if (
(d := self.decorators())
and
(f := self.function_def_raw())
):
return _PyPegen_function_def_decorators ( p , d , f )
self._reset(mark)
if (
(function_def_raw := self.function_def_raw())
):
return function_def_raw
self._reset(mark)
return None
@memoize
def function_def_raw(self) -> Optional[stmt_ty]:
# function_def_raw: invalid_def_raw | 'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block | ASYNC 'def' NAME &&'(' params? ')' ['->' expression] &&':' func_type_comment? block
mark = self._mark()
if (
(invalid_def_raw := self.invalid_def_raw())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('def'))
and
(n := self.name())
and
(forced := self.expect_forced(self.expect('('), "'('"))
and
(params := self.params(),)
and
(literal_1 := self.expect(')'))
and
(a := self._tmp_34(),)
and
(forced_1 := self.expect_forced(self.expect(':'), "':'"))
and
(tc := self.func_type_comment(),)
and
(b := self.block())
):
return _PyAST_FunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA )
self._reset(mark)
if (
(_async := self.expect('ASYNC'))
and
(literal := self.expect('def'))
and
(n := self.name())
and
(forced := self.expect_forced(self.expect('('), "'('"))
and
(params := self.params(),)
and
(literal_1 := self.expect(')'))
and
(a := self._tmp_35(),)
and
(forced_1 := self.expect_forced(self.expect(':'), "':'"))
and
(tc := self.func_type_comment(),)
and
(b := self.block())
):
return CHECK_VERSION ( stmt_ty , 5 , "Async functions are" , _PyAST_AsyncFunctionDef ( n -> v . Name . id , ( params ) ? params : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , NULL , a , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) )
self._reset(mark)
return None
@memoize
def params(self) -> Optional[arguments_ty]:
# params: invalid_parameters | parameters
mark = self._mark()
if (
(invalid_parameters := self.invalid_parameters())
):
return None # pragma: no cover
self._reset(mark)
if (
(parameters := self.parameters())
):
return parameters
self._reset(mark)
return None
@memoize
def parameters(self) -> Optional[arguments_ty]:
# parameters: slash_no_default param_no_default* param_with_default* star_etc? | slash_with_default param_with_default* star_etc? | param_no_default+ param_with_default* star_etc? | param_with_default+ star_etc? | star_etc
mark = self._mark()
if (
(a := self.slash_no_default())
and
(b := self._loop0_36(),)
and
(c := self._loop0_37(),)
and
(d := self.star_etc(),)
):
return CHECK_VERSION ( arguments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , a , NULL , b , c , d ) )
self._reset(mark)
if (
(a := self.slash_with_default())
and
(b := self._loop0_38(),)
and
(c := self.star_etc(),)
):
return CHECK_VERSION ( arguments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , NULL , a , NULL , b , c ) )
self._reset(mark)
if (
(a := self._loop1_39())
and
(b := self._loop0_40(),)
and
(c := self.star_etc(),)
):
return _PyPegen_make_arguments ( p , NULL , NULL , a , b , c )
self._reset(mark)
if (
(a := self._loop1_41())
and
(b := self.star_etc(),)
):
return _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b )
self._reset(mark)
if (
(a := self.star_etc())
):
return _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a )
self._reset(mark)
return None
@memoize
def slash_no_default(self) -> Optional[asdl_arg_seq*]:
# slash_no_default: param_no_default+ '/' ',' | param_no_default+ '/' &')'
mark = self._mark()
if (
(a := self._loop1_42())
and
(literal := self.expect('/'))
and
(literal_1 := self.expect(','))
):
return a
self._reset(mark)
if (
(a := self._loop1_43())
and
(literal := self.expect('/'))
and
self.positive_lookahead(self.expect, ')')
):
return a
self._reset(mark)
return None
@memoize
def slash_with_default(self) -> Optional[SlashWithDefault*]:
# slash_with_default: param_no_default* param_with_default+ '/' ',' | param_no_default* param_with_default+ '/' &')'
mark = self._mark()
if (
(a := self._loop0_44(),)
and
(b := self._loop1_45())
and
(literal := self.expect('/'))
and
(literal_1 := self.expect(','))
):
return _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b )
self._reset(mark)
if (
(a := self._loop0_46(),)
and
(b := self._loop1_47())
and
(literal := self.expect('/'))
and
self.positive_lookahead(self.expect, ')')
):
return _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b )
self._reset(mark)
return None
@memoize
def star_etc(self) -> Optional[StarEtc*]:
# star_etc: invalid_star_etc | '*' param_no_default param_maybe_default* kwds? | '*' param_no_default_star_annotation param_maybe_default* kwds? | '*' ',' param_maybe_default+ kwds? | kwds
mark = self._mark()
if (
(invalid_star_etc := self.invalid_star_etc())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('*'))
and
(a := self.param_no_default())
and
(b := self._loop0_48(),)
and
(c := self.kwds(),)
):
return _PyPegen_star_etc ( p , a , b , c )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(a := self.param_no_default_star_annotation())
and
(b := self._loop0_49(),)
and
(c := self.kwds(),)
):
return _PyPegen_star_etc ( p , a , b , c )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(literal_1 := self.expect(','))
and
(b := self._loop1_50())
and
(c := self.kwds(),)
):
return _PyPegen_star_etc ( p , NULL , b , c )
self._reset(mark)
if (
(a := self.kwds())
):
return _PyPegen_star_etc ( p , NULL , NULL , a )
self._reset(mark)
return None
@memoize
def kwds(self) -> Optional[arg_ty]:
# kwds: invalid_kwds | '**' param_no_default
mark = self._mark()
if (
(invalid_kwds := self.invalid_kwds())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('**'))
and
(a := self.param_no_default())
):
return a
self._reset(mark)
return None
@memoize
def param_no_default(self) -> Optional[arg_ty]:
# param_no_default: param ',' TYPE_COMMENT? | param TYPE_COMMENT? &')'
mark = self._mark()
if (
(a := self.param())
and
(literal := self.expect(','))
and
(tc := self.type_comment(),)
):
return _PyPegen_add_type_comment_to_arg ( p , a , tc )
self._reset(mark)
if (
(a := self.param())
and
(tc := self.type_comment(),)
and
self.positive_lookahead(self.expect, ')')
):
return _PyPegen_add_type_comment_to_arg ( p , a , tc )
self._reset(mark)
return None
@memoize
def param_no_default_star_annotation(self) -> Optional[arg_ty]:
# param_no_default_star_annotation: param_star_annotation ',' TYPE_COMMENT? | param_star_annotation TYPE_COMMENT? &')'
mark = self._mark()
if (
(a := self.param_star_annotation())
and
(literal := self.expect(','))
and
(tc := self.type_comment(),)
):
return _PyPegen_add_type_comment_to_arg ( p , a , tc )
self._reset(mark)
if (
(a := self.param_star_annotation())
and
(tc := self.type_comment(),)
and
self.positive_lookahead(self.expect, ')')
):
return _PyPegen_add_type_comment_to_arg ( p , a , tc )
self._reset(mark)
return None
@memoize
def param_with_default(self) -> Optional[NameDefaultPair*]:
# param_with_default: param default ',' TYPE_COMMENT? | param default TYPE_COMMENT? &')'
mark = self._mark()
if (
(a := self.param())
and
(c := self.default())
and
(literal := self.expect(','))
and
(tc := self.type_comment(),)
):
return _PyPegen_name_default_pair ( p , a , c , tc )
self._reset(mark)
if (
(a := self.param())
and
(c := self.default())
and
(tc := self.type_comment(),)
and
self.positive_lookahead(self.expect, ')')
):
return _PyPegen_name_default_pair ( p , a , c , tc )
self._reset(mark)
return None
@memoize
def param_maybe_default(self) -> Optional[NameDefaultPair*]:
# param_maybe_default: param default? ',' TYPE_COMMENT? | param default? TYPE_COMMENT? &')'
mark = self._mark()
if (
(a := self.param())
and
(c := self.default(),)
and
(literal := self.expect(','))
and
(tc := self.type_comment(),)
):
return _PyPegen_name_default_pair ( p , a , c , tc )
self._reset(mark)
if (
(a := self.param())
and
(c := self.default(),)
and
(tc := self.type_comment(),)
and
self.positive_lookahead(self.expect, ')')
):
return _PyPegen_name_default_pair ( p , a , c , tc )
self._reset(mark)
return None
@memoize
def param(self) -> Optional[arg_ty]:
# param: NAME annotation?
mark = self._mark()
if (
(a := self.name())
and
(b := self.annotation(),)
):
return _PyAST_arg ( a -> v . Name . id , b , NULL , EXTRA )
self._reset(mark)
return None
@memoize
def param_star_annotation(self) -> Optional[arg_ty]:
# param_star_annotation: NAME star_annotation
mark = self._mark()
if (
(a := self.name())
and
(b := self.star_annotation())
):
return _PyAST_arg ( a -> v . Name . id , b , NULL , EXTRA )
self._reset(mark)
return None
@memoize
def annotation(self) -> Optional[expr_ty]:
# annotation: ':' expression
mark = self._mark()
if (
(literal := self.expect(':'))
and
(a := self.expression())
):
return a
self._reset(mark)
return None
@memoize
def star_annotation(self) -> Optional[expr_ty]:
# star_annotation: ':' star_expression
mark = self._mark()
if (
(literal := self.expect(':'))
and
(a := self.star_expression())
):
return a
self._reset(mark)
return None
@memoize
def default(self) -> Optional[expr_ty]:
# default: '=' expression | invalid_default
mark = self._mark()
if (
(literal := self.expect('='))
and
(a := self.expression())
):
return a
self._reset(mark)
if (
(invalid_default := self.invalid_default())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def if_stmt(self) -> Optional[stmt_ty]:
# if_stmt: invalid_if_stmt | 'if' named_expression ':' block elif_stmt | 'if' named_expression ':' block else_block?
mark = self._mark()
if (
(invalid_if_stmt := self.invalid_if_stmt())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('if'))
and
(a := self.named_expression())
and
(literal_1 := self.expect(':'))
and
(b := self.block())
and
(c := self.elif_stmt())
):
return _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA )
self._reset(mark)
if (
(literal := self.expect('if'))
and
(a := self.named_expression())
and
(literal_1 := self.expect(':'))
and
(b := self.block())
and
(c := self.else_block(),)
):
return _PyAST_If ( a , b , c , EXTRA )
self._reset(mark)
return None
@memoize
def elif_stmt(self) -> Optional[stmt_ty]:
# elif_stmt: invalid_elif_stmt | 'elif' named_expression ':' block elif_stmt | 'elif' named_expression ':' block else_block?
mark = self._mark()
if (
(invalid_elif_stmt := self.invalid_elif_stmt())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('elif'))
and
(a := self.named_expression())
and
(literal_1 := self.expect(':'))
and
(b := self.block())
and
(c := self.elif_stmt())
):
return _PyAST_If ( a , b , CHECK ( asdl_stmt_seq* , _PyPegen_singleton_seq ( p , c ) ) , EXTRA )
self._reset(mark)
if (
(literal := self.expect('elif'))
and
(a := self.named_expression())
and
(literal_1 := self.expect(':'))
and
(b := self.block())
and
(c := self.else_block(),)
):
return _PyAST_If ( a , b , c , EXTRA )
self._reset(mark)
return None
@memoize
def else_block(self) -> Optional[asdl_stmt_seq*]:
# else_block: invalid_else_stmt | 'else' &&':' block
mark = self._mark()
if (
(invalid_else_stmt := self.invalid_else_stmt())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('else'))
and
(forced := self.expect_forced(self.expect(':'), "':'"))
and
(b := self.block())
):
return b
self._reset(mark)
return None
@memoize
def while_stmt(self) -> Optional[stmt_ty]:
# while_stmt: invalid_while_stmt | 'while' named_expression ':' block else_block?
mark = self._mark()
if (
(invalid_while_stmt := self.invalid_while_stmt())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('while'))
and
(a := self.named_expression())
and
(literal_1 := self.expect(':'))
and
(b := self.block())
and
(c := self.else_block(),)
):
return _PyAST_While ( a , b , c , EXTRA )
self._reset(mark)
return None
@memoize
def for_stmt(self) -> Optional[stmt_ty]:
# for_stmt: invalid_for_stmt | 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? | ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? | invalid_for_target
mark = self._mark()
if (
(invalid_for_stmt := self.invalid_for_stmt())
):
return None # pragma: no cover
self._reset(mark)
cut = False
if (
(literal := self.expect('for'))
and
(t := self.star_targets())
and
(literal_1 := self.expect('in'))
and
(cut := True)
and
(ex := self.star_expressions())
and
(literal_2 := self.expect(':'))
and
(tc := self.type_comment(),)
and
(b := self.block())
and
(el := self.else_block(),)
):
return _PyAST_For ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA )
self._reset(mark)
if cut: return None
cut = False
if (
(_async := self.expect('ASYNC'))
and
(literal := self.expect('for'))
and
(t := self.star_targets())
and
(literal_1 := self.expect('in'))
and
(cut := True)
and
(ex := self.star_expressions())
and
(literal_2 := self.expect(':'))
and
(tc := self.type_comment(),)
and
(b := self.block())
and
(el := self.else_block(),)
):
return CHECK_VERSION ( stmt_ty , 5 , "Async for loops are" , _PyAST_AsyncFor ( t , ex , b , el , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) )
self._reset(mark)
if cut: return None
if (
(invalid_for_target := self.invalid_for_target())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def with_stmt(self) -> Optional[stmt_ty]:
# with_stmt: invalid_with_stmt_indent | 'with' '(' ','.with_item+ ','? ')' ':' block | 'with' ','.with_item+ ':' TYPE_COMMENT? block | ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block | ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block | invalid_with_stmt
mark = self._mark()
if (
(invalid_with_stmt_indent := self.invalid_with_stmt_indent())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('with'))
and
(literal_1 := self.expect('('))
and
(a := self._gather_51())
and
(opt := self.expect(','),)
and
(literal_2 := self.expect(')'))
and
(literal_3 := self.expect(':'))
and
(b := self.block())
):
return CHECK_VERSION ( stmt_ty , 9 , "Parenthesized context managers are" , _PyAST_With ( a , b , NULL , EXTRA ) )
self._reset(mark)
if (
(literal := self.expect('with'))
and
(a := self._gather_53())
and
(literal_1 := self.expect(':'))
and
(tc := self.type_comment(),)
and
(b := self.block())
):
return _PyAST_With ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA )
self._reset(mark)
if (
(_async := self.expect('ASYNC'))
and
(literal := self.expect('with'))
and
(literal_1 := self.expect('('))
and
(a := self._gather_55())
and
(opt := self.expect(','),)
and
(literal_2 := self.expect(')'))
and
(literal_3 := self.expect(':'))
and
(b := self.block())
):
return CHECK_VERSION ( stmt_ty , 5 , "Async with statements are" , _PyAST_AsyncWith ( a , b , NULL , EXTRA ) )
self._reset(mark)
if (
(_async := self.expect('ASYNC'))
and
(literal := self.expect('with'))
and
(a := self._gather_57())
and
(literal_1 := self.expect(':'))
and
(tc := self.type_comment(),)
and
(b := self.block())
):
return CHECK_VERSION ( stmt_ty , 5 , "Async with statements are" , _PyAST_AsyncWith ( a , b , NEW_TYPE_COMMENT ( p , tc ) , EXTRA ) )
self._reset(mark)
if (
(invalid_with_stmt := self.invalid_with_stmt())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def with_item(self) -> Optional[withitem_ty]:
# with_item: expression 'as' star_target &(',' | ')' | ':') | invalid_with_item | expression
mark = self._mark()
if (
(e := self.expression())
and
(literal := self.expect('as'))
and
(t := self.star_target())
and
self.positive_lookahead(self._tmp_59, )
):
return _PyAST_withitem ( e , t , p -> arena )
self._reset(mark)
if (
(invalid_with_item := self.invalid_with_item())
):
return None # pragma: no cover
self._reset(mark)
if (
(e := self.expression())
):
return _PyAST_withitem ( e , NULL , p -> arena )
self._reset(mark)
return None
@memoize
def try_stmt(self) -> Optional[stmt_ty]:
# try_stmt: invalid_try_stmt | 'try' &&':' block finally_block | 'try' &&':' block except_block+ else_block? finally_block? | 'try' &&':' block except_star_block+ else_block? finally_block?
mark = self._mark()
if (
(invalid_try_stmt := self.invalid_try_stmt())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('try'))
and
(forced := self.expect_forced(self.expect(':'), "':'"))
and
(b := self.block())
and
(f := self.finally_block())
):
return _PyAST_Try ( b , NULL , NULL , f , EXTRA )
self._reset(mark)
if (
(literal := self.expect('try'))
and
(forced := self.expect_forced(self.expect(':'), "':'"))
and
(b := self.block())
and
(ex := self._loop1_60())
and
(el := self.else_block(),)
and
(f := self.finally_block(),)
):
return _PyAST_Try ( b , ex , el , f , EXTRA )
self._reset(mark)
if (
(literal := self.expect('try'))
and
(forced := self.expect_forced(self.expect(':'), "':'"))
and
(b := self.block())
and
(ex := self._loop1_61())
and
(el := self.else_block(),)
and
(f := self.finally_block(),)
):
return _PyAST_TryStar ( b , ex , el , f , EXTRA )
self._reset(mark)
return None
@memoize
def except_block(self) -> Optional[excepthandler_ty]:
# except_block: invalid_except_stmt_indent | 'except' expression ['as' NAME] ':' block | 'except' ':' block | invalid_except_stmt
mark = self._mark()
if (
(invalid_except_stmt_indent := self.invalid_except_stmt_indent())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('except'))
and
(e := self.expression())
and
(t := self._tmp_62(),)
and
(literal_1 := self.expect(':'))
and
(b := self.block())
):
return _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA )
self._reset(mark)
if (
(literal := self.expect('except'))
and
(literal_1 := self.expect(':'))
and
(b := self.block())
):
return _PyAST_ExceptHandler ( NULL , NULL , b , EXTRA )
self._reset(mark)
if (
(invalid_except_stmt := self.invalid_except_stmt())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def except_star_block(self) -> Optional[excepthandler_ty]:
# except_star_block: invalid_except_star_stmt_indent | 'except' '*' expression ['as' NAME] ':' block | invalid_except_stmt
mark = self._mark()
if (
(invalid_except_star_stmt_indent := self.invalid_except_star_stmt_indent())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('except'))
and
(literal_1 := self.expect('*'))
and
(e := self.expression())
and
(t := self._tmp_63(),)
and
(literal_2 := self.expect(':'))
and
(b := self.block())
):
return _PyAST_ExceptHandler ( e , ( t ) ? ( ( expr_ty ) t ) -> v . Name . id : NULL , b , EXTRA )
self._reset(mark)
if (
(invalid_except_stmt := self.invalid_except_stmt())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def finally_block(self) -> Optional[asdl_stmt_seq*]:
# finally_block: invalid_finally_stmt | 'finally' &&':' block
mark = self._mark()
if (
(invalid_finally_stmt := self.invalid_finally_stmt())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('finally'))
and
(forced := self.expect_forced(self.expect(':'), "':'"))
and
(a := self.block())
):
return a
self._reset(mark)
return None
@memoize
def match_stmt(self) -> Optional[stmt_ty]:
# match_stmt: "match" subject_expr ':' NEWLINE INDENT case_block+ DEDENT | invalid_match_stmt
mark = self._mark()
if (
(literal := self.expect("match"))
and
(subject := self.subject_expr())
and
(literal_1 := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
(_indent := self.expect('INDENT'))
and
(cases := self._loop1_64())
and
(_dedent := self.expect('DEDENT'))
):
return CHECK_VERSION ( stmt_ty , 10 , "Pattern matching is" , _PyAST_Match ( subject , cases , EXTRA ) )
self._reset(mark)
if (
(invalid_match_stmt := self.invalid_match_stmt())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def subject_expr(self) -> Optional[expr_ty]:
# subject_expr: star_named_expression ',' star_named_expressions? | named_expression
mark = self._mark()
if (
(value := self.star_named_expression())
and
(literal := self.expect(','))
and
(values := self.star_named_expressions(),)
):
return _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , value , values ) ) , Load , EXTRA )
self._reset(mark)
if (
(named_expression := self.named_expression())
):
return named_expression
self._reset(mark)
return None
@memoize
def case_block(self) -> Optional[match_case_ty]:
# case_block: invalid_case_block | "case" patterns guard? ':' block
mark = self._mark()
if (
(invalid_case_block := self.invalid_case_block())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect("case"))
and
(pattern := self.patterns())
and
(guard := self.guard(),)
and
(literal_1 := self.expect(':'))
and
(body := self.block())
):
return _PyAST_match_case ( pattern , guard , body , p -> arena )
self._reset(mark)
return None
@memoize
def guard(self) -> Optional[expr_ty]:
# guard: 'if' named_expression
mark = self._mark()
if (
(literal := self.expect('if'))
and
(guard := self.named_expression())
):
return guard
self._reset(mark)
return None
@memoize
def patterns(self) -> Optional[pattern_ty]:
# patterns: open_sequence_pattern | pattern
mark = self._mark()
if (
(patterns := self.open_sequence_pattern())
):
return _PyAST_MatchSequence ( patterns , EXTRA )
self._reset(mark)
if (
(pattern := self.pattern())
):
return pattern
self._reset(mark)
return None
@memoize
def pattern(self) -> Optional[pattern_ty]:
# pattern: as_pattern | or_pattern
mark = self._mark()
if (
(as_pattern := self.as_pattern())
):
return as_pattern
self._reset(mark)
if (
(or_pattern := self.or_pattern())
):
return or_pattern
self._reset(mark)
return None
@memoize
def as_pattern(self) -> Optional[pattern_ty]:
# as_pattern: or_pattern 'as' pattern_capture_target | invalid_as_pattern
mark = self._mark()
if (
(pattern := self.or_pattern())
and
(literal := self.expect('as'))
and
(target := self.pattern_capture_target())
):
return _PyAST_MatchAs ( pattern , target -> v . Name . id , EXTRA )
self._reset(mark)
if (
(invalid_as_pattern := self.invalid_as_pattern())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def or_pattern(self) -> Optional[pattern_ty]:
# or_pattern: '|'.closed_pattern+
mark = self._mark()
if (
(patterns := self._gather_65())
):
return asdl_seq_LEN ( patterns ) == 1 ? asdl_seq_GET ( patterns , 0 ) : _PyAST_MatchOr ( patterns , EXTRA )
self._reset(mark)
return None
@memoize
def closed_pattern(self) -> Optional[pattern_ty]:
# closed_pattern: literal_pattern | capture_pattern | wildcard_pattern | value_pattern | group_pattern | sequence_pattern | mapping_pattern | class_pattern
mark = self._mark()
if (
(literal_pattern := self.literal_pattern())
):
return literal_pattern
self._reset(mark)
if (
(capture_pattern := self.capture_pattern())
):
return capture_pattern
self._reset(mark)
if (
(wildcard_pattern := self.wildcard_pattern())
):
return wildcard_pattern
self._reset(mark)
if (
(value_pattern := self.value_pattern())
):
return value_pattern
self._reset(mark)
if (
(group_pattern := self.group_pattern())
):
return group_pattern
self._reset(mark)
if (
(sequence_pattern := self.sequence_pattern())
):
return sequence_pattern
self._reset(mark)
if (
(mapping_pattern := self.mapping_pattern())
):
return mapping_pattern
self._reset(mark)
if (
(class_pattern := self.class_pattern())
):
return class_pattern
self._reset(mark)
return None
@memoize
def literal_pattern(self) -> Optional[pattern_ty]:
# literal_pattern: signed_number !('+' | '-') | complex_number | strings | 'None' | 'True' | 'False'
mark = self._mark()
if (
(value := self.signed_number())
and
self.negative_lookahead(self._tmp_67, )
):
return _PyAST_MatchValue ( value , EXTRA )
self._reset(mark)
if (
(value := self.complex_number())
):
return _PyAST_MatchValue ( value , EXTRA )
self._reset(mark)
if (
(value := self.strings())
):
return _PyAST_MatchValue ( value , EXTRA )
self._reset(mark)
if (
(literal := self.expect('None'))
):
return _PyAST_MatchSingleton ( Py_None , EXTRA )
self._reset(mark)
if (
(literal := self.expect('True'))
):
return _PyAST_MatchSingleton ( Py_True , EXTRA )
self._reset(mark)
if (
(literal := self.expect('False'))
):
return _PyAST_MatchSingleton ( Py_False , EXTRA )
self._reset(mark)
return None
@memoize
def literal_expr(self) -> Optional[expr_ty]:
# literal_expr: signed_number !('+' | '-') | complex_number | strings | 'None' | 'True' | 'False'
mark = self._mark()
if (
(signed_number := self.signed_number())
and
self.negative_lookahead(self._tmp_68, )
):
return signed_number
self._reset(mark)
if (
(complex_number := self.complex_number())
):
return complex_number
self._reset(mark)
if (
(strings := self.strings())
):
return strings
self._reset(mark)
if (
(literal := self.expect('None'))
):
return _PyAST_Constant ( Py_None , NULL , EXTRA )
self._reset(mark)
if (
(literal := self.expect('True'))
):
return _PyAST_Constant ( Py_True , NULL , EXTRA )
self._reset(mark)
if (
(literal := self.expect('False'))
):
return _PyAST_Constant ( Py_False , NULL , EXTRA )
self._reset(mark)
return None
@memoize
def complex_number(self) -> Optional[expr_ty]:
# complex_number: signed_real_number '+' imaginary_number | signed_real_number '-' imaginary_number
mark = self._mark()
if (
(real := self.signed_real_number())
and
(literal := self.expect('+'))
and
(imag := self.imaginary_number())
):
return _PyAST_BinOp ( real , Add , imag , EXTRA )
self._reset(mark)
if (
(real := self.signed_real_number())
and
(literal := self.expect('-'))
and
(imag := self.imaginary_number())
):
return _PyAST_BinOp ( real , Sub , imag , EXTRA )
self._reset(mark)
return None
@memoize
def signed_number(self) -> Optional[expr_ty]:
# signed_number: NUMBER | '-' NUMBER
mark = self._mark()
if (
(number := self.number())
):
return number
self._reset(mark)
if (
(literal := self.expect('-'))
and
(number := self.number())
):
return _PyAST_UnaryOp ( USub , number , EXTRA )
self._reset(mark)
return None
@memoize
def signed_real_number(self) -> Optional[expr_ty]:
# signed_real_number: real_number | '-' real_number
mark = self._mark()
if (
(real_number := self.real_number())
):
return real_number
self._reset(mark)
if (
(literal := self.expect('-'))
and
(real := self.real_number())
):
return _PyAST_UnaryOp ( USub , real , EXTRA )
self._reset(mark)
return None
@memoize
def real_number(self) -> Optional[expr_ty]:
# real_number: NUMBER
mark = self._mark()
if (
(real := self.number())
):
return _PyPegen_ensure_real ( p , real )
self._reset(mark)
return None
@memoize
def imaginary_number(self) -> Optional[expr_ty]:
# imaginary_number: NUMBER
mark = self._mark()
if (
(imag := self.number())
):
return _PyPegen_ensure_imaginary ( p , imag )
self._reset(mark)
return None
@memoize
def capture_pattern(self) -> Optional[pattern_ty]:
# capture_pattern: pattern_capture_target
mark = self._mark()
if (
(target := self.pattern_capture_target())
):
return _PyAST_MatchAs ( NULL , target -> v . Name . id , EXTRA )
self._reset(mark)
return None
@memoize
def pattern_capture_target(self) -> Optional[expr_ty]:
# pattern_capture_target: !"_" NAME !('.' | '(' | '=')
mark = self._mark()
if (
self.negative_lookahead(self.expect, "_")
and
(name := self.name())
and
self.negative_lookahead(self._tmp_69, )
):
return _PyPegen_set_expr_context ( p , name , Store )
self._reset(mark)
return None
@memoize
def wildcard_pattern(self) -> Optional[pattern_ty]:
# wildcard_pattern: "_"
mark = self._mark()
if (
(literal := self.expect("_"))
):
return _PyAST_MatchAs ( NULL , NULL , EXTRA )
self._reset(mark)
return None
@memoize
def value_pattern(self) -> Optional[pattern_ty]:
# value_pattern: attr !('.' | '(' | '=')
mark = self._mark()
if (
(attr := self.attr())
and
self.negative_lookahead(self._tmp_70, )
):
return _PyAST_MatchValue ( attr , EXTRA )
self._reset(mark)
return None
@memoize_left_rec
def attr(self) -> Optional[expr_ty]:
# attr: name_or_attr '.' NAME
mark = self._mark()
if (
(value := self.name_or_attr())
and
(literal := self.expect('.'))
and
(attr := self.name())
):
return _PyAST_Attribute ( value , attr -> v . Name . id , Load , EXTRA )
self._reset(mark)
return None
@logger
def name_or_attr(self) -> Optional[expr_ty]:
# name_or_attr: attr | NAME
mark = self._mark()
if (
(attr := self.attr())
):
return attr
self._reset(mark)
if (
(name := self.name())
):
return name
self._reset(mark)
return None
@memoize
def group_pattern(self) -> Optional[pattern_ty]:
# group_pattern: '(' pattern ')'
mark = self._mark()
if (
(literal := self.expect('('))
and
(pattern := self.pattern())
and
(literal_1 := self.expect(')'))
):
return pattern
self._reset(mark)
return None
@memoize
def sequence_pattern(self) -> Optional[pattern_ty]:
# sequence_pattern: '[' maybe_sequence_pattern? ']' | '(' open_sequence_pattern? ')'
mark = self._mark()
if (
(literal := self.expect('['))
and
(patterns := self.maybe_sequence_pattern(),)
and
(literal_1 := self.expect(']'))
):
return _PyAST_MatchSequence ( patterns , EXTRA )
self._reset(mark)
if (
(literal := self.expect('('))
and
(patterns := self.open_sequence_pattern(),)
and
(literal_1 := self.expect(')'))
):
return _PyAST_MatchSequence ( patterns , EXTRA )
self._reset(mark)
return None
@memoize
def open_sequence_pattern(self) -> Optional[asdl_seq*]:
# open_sequence_pattern: maybe_star_pattern ',' maybe_sequence_pattern?
mark = self._mark()
if (
(pattern := self.maybe_star_pattern())
and
(literal := self.expect(','))
and
(patterns := self.maybe_sequence_pattern(),)
):
return _PyPegen_seq_insert_in_front ( p , pattern , patterns )
self._reset(mark)
return None
@memoize
def maybe_sequence_pattern(self) -> Optional[asdl_seq*]:
# maybe_sequence_pattern: ','.maybe_star_pattern+ ','?
mark = self._mark()
if (
(patterns := self._gather_71())
and
(opt := self.expect(','),)
):
return patterns
self._reset(mark)
return None
@memoize
def maybe_star_pattern(self) -> Optional[pattern_ty]:
# maybe_star_pattern: star_pattern | pattern
mark = self._mark()
if (
(star_pattern := self.star_pattern())
):
return star_pattern
self._reset(mark)
if (
(pattern := self.pattern())
):
return pattern
self._reset(mark)
return None
@memoize
def star_pattern(self) -> Optional[pattern_ty]:
# star_pattern: '*' pattern_capture_target | '*' wildcard_pattern
mark = self._mark()
if (
(literal := self.expect('*'))
and
(target := self.pattern_capture_target())
):
return _PyAST_MatchStar ( target -> v . Name . id , EXTRA )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(wildcard_pattern := self.wildcard_pattern())
):
return _PyAST_MatchStar ( NULL , EXTRA )
self._reset(mark)
return None
@memoize
def mapping_pattern(self) -> Optional[pattern_ty]:
# mapping_pattern: '{' '}' | '{' double_star_pattern ','? '}' | '{' items_pattern ',' double_star_pattern ','? '}' | '{' items_pattern ','? '}'
mark = self._mark()
if (
(literal := self.expect('{'))
and
(literal_1 := self.expect('}'))
):
return _PyAST_MatchMapping ( NULL , NULL , NULL , EXTRA )
self._reset(mark)
if (
(literal := self.expect('{'))
and
(rest := self.double_star_pattern())
and
(opt := self.expect(','),)
and
(literal_1 := self.expect('}'))
):
return _PyAST_MatchMapping ( NULL , NULL , rest -> v . Name . id , EXTRA )
self._reset(mark)
if (
(literal := self.expect('{'))
and
(items := self.items_pattern())
and
(literal_1 := self.expect(','))
and
(rest := self.double_star_pattern())
and
(opt := self.expect(','),)
and
(literal_2 := self.expect('}'))
):
return _PyAST_MatchMapping ( CHECK ( asdl_expr_seq* , _PyPegen_get_pattern_keys ( p , items ) ) , CHECK ( asdl_pattern_seq* , _PyPegen_get_patterns ( p , items ) ) , rest -> v . Name . id , EXTRA )
self._reset(mark)
if (
(literal := self.expect('{'))
and
(items := self.items_pattern())
and
(opt := self.expect(','),)
and
(literal_1 := self.expect('}'))
):
return _PyAST_MatchMapping ( CHECK ( asdl_expr_seq* , _PyPegen_get_pattern_keys ( p , items ) ) , CHECK ( asdl_pattern_seq* , _PyPegen_get_patterns ( p , items ) ) , NULL , EXTRA )
self._reset(mark)
return None
@memoize
def items_pattern(self) -> Optional[asdl_seq*]:
# items_pattern: ','.key_value_pattern+
mark = self._mark()
if (
(_gather_73 := self._gather_73())
):
return _gather_73
self._reset(mark)
return None
@memoize
def key_value_pattern(self) -> Optional[KeyPatternPair*]:
# key_value_pattern: (literal_expr | attr) ':' pattern
mark = self._mark()
if (
(key := self._tmp_75())
and
(literal := self.expect(':'))
and
(pattern := self.pattern())
):
return _PyPegen_key_pattern_pair ( p , key , pattern )
self._reset(mark)
return None
@memoize
def double_star_pattern(self) -> Optional[expr_ty]:
# double_star_pattern: '**' pattern_capture_target
mark = self._mark()
if (
(literal := self.expect('**'))
and
(target := self.pattern_capture_target())
):
return target
self._reset(mark)
return None
@memoize
def class_pattern(self) -> Optional[pattern_ty]:
# class_pattern: name_or_attr '(' ')' | name_or_attr '(' positional_patterns ','? ')' | name_or_attr '(' keyword_patterns ','? ')' | name_or_attr '(' positional_patterns ',' keyword_patterns ','? ')' | invalid_class_pattern
mark = self._mark()
if (
(cls := self.name_or_attr())
and
(literal := self.expect('('))
and
(literal_1 := self.expect(')'))
):
return _PyAST_MatchClass ( cls , NULL , NULL , NULL , EXTRA )
self._reset(mark)
if (
(cls := self.name_or_attr())
and
(literal := self.expect('('))
and
(patterns := self.positional_patterns())
and
(opt := self.expect(','),)
and
(literal_1 := self.expect(')'))
):
return _PyAST_MatchClass ( cls , patterns , NULL , NULL , EXTRA )
self._reset(mark)
if (
(cls := self.name_or_attr())
and
(literal := self.expect('('))
and
(keywords := self.keyword_patterns())
and
(opt := self.expect(','),)
and
(literal_1 := self.expect(')'))
):
return _PyAST_MatchClass ( cls , NULL , CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , CHECK ( asdl_expr_seq* , _PyPegen_get_pattern_keys ( p , keywords ) ) ) ) , CHECK ( asdl_pattern_seq* , _PyPegen_get_patterns ( p , keywords ) ) , EXTRA )
self._reset(mark)
if (
(cls := self.name_or_attr())
and
(literal := self.expect('('))
and
(patterns := self.positional_patterns())
and
(literal_1 := self.expect(','))
and
(keywords := self.keyword_patterns())
and
(opt := self.expect(','),)
and
(literal_2 := self.expect(')'))
):
return _PyAST_MatchClass ( cls , patterns , CHECK ( asdl_identifier_seq* , _PyPegen_map_names_to_ids ( p , CHECK ( asdl_expr_seq* , _PyPegen_get_pattern_keys ( p , keywords ) ) ) ) , CHECK ( asdl_pattern_seq* , _PyPegen_get_patterns ( p , keywords ) ) , EXTRA )
self._reset(mark)
if (
(invalid_class_pattern := self.invalid_class_pattern())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def positional_patterns(self) -> Optional[asdl_pattern_seq*]:
# positional_patterns: ','.pattern+
mark = self._mark()
if (
(args := self._gather_76())
):
return args
self._reset(mark)
return None
@memoize
def keyword_patterns(self) -> Optional[asdl_seq*]:
# keyword_patterns: ','.keyword_pattern+
mark = self._mark()
if (
(_gather_78 := self._gather_78())
):
return _gather_78
self._reset(mark)
return None
@memoize
def keyword_pattern(self) -> Optional[KeyPatternPair*]:
# keyword_pattern: NAME '=' pattern
mark = self._mark()
if (
(arg := self.name())
and
(literal := self.expect('='))
and
(value := self.pattern())
):
return _PyPegen_key_pattern_pair ( p , arg , value )
self._reset(mark)
return None
@memoize
def expressions(self) -> Optional[expr_ty]:
# expressions: expression ((',' expression))+ ','? | expression ',' | expression
mark = self._mark()
if (
(a := self.expression())
and
(b := self._loop1_80())
and
(opt := self.expect(','),)
):
return _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA )
self._reset(mark)
if (
(a := self.expression())
and
(literal := self.expect(','))
):
return _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA )
self._reset(mark)
if (
(expression := self.expression())
):
return expression
self._reset(mark)
return None
@memoize
def expression(self) -> Optional[expr_ty]:
# expression: invalid_expression | invalid_legacy_expression | disjunction 'if' disjunction 'else' expression | disjunction | lambdef
mark = self._mark()
if (
(invalid_expression := self.invalid_expression())
):
return None # pragma: no cover
self._reset(mark)
if (
(invalid_legacy_expression := self.invalid_legacy_expression())
):
return None # pragma: no cover
self._reset(mark)
if (
(a := self.disjunction())
and
(literal := self.expect('if'))
and
(b := self.disjunction())
and
(literal_1 := self.expect('else'))
and
(c := self.expression())
):
return _PyAST_IfExp ( b , a , c , EXTRA )
self._reset(mark)
if (
(disjunction := self.disjunction())
):
return disjunction
self._reset(mark)
if (
(lambdef := self.lambdef())
):
return lambdef
self._reset(mark)
return None
@memoize
def yield_expr(self) -> Optional[expr_ty]:
# yield_expr: 'yield' 'from' expression | 'yield' star_expressions?
mark = self._mark()
if (
(literal := self.expect('yield'))
and
(literal_1 := self.expect('from'))
and
(a := self.expression())
):
return _PyAST_YieldFrom ( a , EXTRA )
self._reset(mark)
if (
(literal := self.expect('yield'))
and
(a := self.star_expressions(),)
):
return _PyAST_Yield ( a , EXTRA )
self._reset(mark)
return None
@memoize
def star_expressions(self) -> Optional[expr_ty]:
# star_expressions: star_expression ((',' star_expression))+ ','? | star_expression ',' | star_expression
mark = self._mark()
if (
(a := self.star_expression())
and
(b := self._loop1_81())
and
(opt := self.expect(','),)
):
return _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Load , EXTRA )
self._reset(mark)
if (
(a := self.star_expression())
and
(literal := self.expect(','))
):
return _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_singleton_seq ( p , a ) ) , Load , EXTRA )
self._reset(mark)
if (
(star_expression := self.star_expression())
):
return star_expression
self._reset(mark)
return None
@memoize
def star_expression(self) -> Optional[expr_ty]:
# star_expression: '*' bitwise_or | expression
mark = self._mark()
if (
(literal := self.expect('*'))
and
(a := self.bitwise_or())
):
return _PyAST_Starred ( a , Load , EXTRA )
self._reset(mark)
if (
(expression := self.expression())
):
return expression
self._reset(mark)
return None
@memoize
def star_named_expressions(self) -> Optional[asdl_expr_seq*]:
# star_named_expressions: ','.star_named_expression+ ','?
mark = self._mark()
if (
(a := self._gather_82())
and
(opt := self.expect(','),)
):
return a
self._reset(mark)
return None
@memoize
def star_named_expression(self) -> Optional[expr_ty]:
# star_named_expression: '*' bitwise_or | named_expression
mark = self._mark()
if (
(literal := self.expect('*'))
and
(a := self.bitwise_or())
):
return _PyAST_Starred ( a , Load , EXTRA )
self._reset(mark)
if (
(named_expression := self.named_expression())
):
return named_expression
self._reset(mark)
return None
@memoize
def assignment_expression(self) -> Optional[expr_ty]:
# assignment_expression: NAME ':=' ~ expression
mark = self._mark()
cut = False
if (
(a := self.name())
and
(literal := self.expect(':='))
and
(cut := True)
and
(b := self.expression())
):
return CHECK_VERSION ( expr_ty , 8 , "Assignment expressions are" , _PyAST_NamedExpr ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , b , EXTRA ) )
self._reset(mark)
if cut: return None
return None
@memoize
def named_expression(self) -> Optional[expr_ty]:
# named_expression: assignment_expression | invalid_named_expression | expression !':='
mark = self._mark()
if (
(assignment_expression := self.assignment_expression())
):
return assignment_expression
self._reset(mark)
if (
(invalid_named_expression := self.invalid_named_expression())
):
return None # pragma: no cover
self._reset(mark)
if (
(expression := self.expression())
and
self.negative_lookahead(self.expect, ':=')
):
return expression
self._reset(mark)
return None
@memoize
def disjunction(self) -> Optional[expr_ty]:
# disjunction: conjunction (('or' conjunction))+ | conjunction
mark = self._mark()
if (
(a := self.conjunction())
and
(b := self._loop1_84())
):
return _PyAST_BoolOp ( Or , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA )
self._reset(mark)
if (
(conjunction := self.conjunction())
):
return conjunction
self._reset(mark)
return None
@memoize
def conjunction(self) -> Optional[expr_ty]:
# conjunction: inversion (('and' inversion))+ | inversion
mark = self._mark()
if (
(a := self.inversion())
and
(b := self._loop1_85())
):
return _PyAST_BoolOp ( And , CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , EXTRA )
self._reset(mark)
if (
(inversion := self.inversion())
):
return inversion
self._reset(mark)
return None
@memoize
def inversion(self) -> Optional[expr_ty]:
# inversion: 'not' inversion | comparison
mark = self._mark()
if (
(literal := self.expect('not'))
and
(a := self.inversion())
):
return _PyAST_UnaryOp ( Not , a , EXTRA )
self._reset(mark)
if (
(comparison := self.comparison())
):
return comparison
self._reset(mark)
return None
@memoize
def comparison(self) -> Optional[expr_ty]:
# comparison: bitwise_or compare_op_bitwise_or_pair+ | bitwise_or
mark = self._mark()
if (
(a := self.bitwise_or())
and
(b := self._loop1_86())
):
return _PyAST_Compare ( a , CHECK ( asdl_int_seq* , _PyPegen_get_cmpops ( p , b ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_exprs ( p , b ) ) , EXTRA )
self._reset(mark)
if (
(bitwise_or := self.bitwise_or())
):
return bitwise_or
self._reset(mark)
return None
@memoize
def compare_op_bitwise_or_pair(self) -> Optional[CmpopExprPair*]:
# compare_op_bitwise_or_pair: eq_bitwise_or | noteq_bitwise_or | lte_bitwise_or | lt_bitwise_or | gte_bitwise_or | gt_bitwise_or | notin_bitwise_or | in_bitwise_or | isnot_bitwise_or | is_bitwise_or
mark = self._mark()
if (
(eq_bitwise_or := self.eq_bitwise_or())
):
return eq_bitwise_or
self._reset(mark)
if (
(noteq_bitwise_or := self.noteq_bitwise_or())
):
return noteq_bitwise_or
self._reset(mark)
if (
(lte_bitwise_or := self.lte_bitwise_or())
):
return lte_bitwise_or
self._reset(mark)
if (
(lt_bitwise_or := self.lt_bitwise_or())
):
return lt_bitwise_or
self._reset(mark)
if (
(gte_bitwise_or := self.gte_bitwise_or())
):
return gte_bitwise_or
self._reset(mark)
if (
(gt_bitwise_or := self.gt_bitwise_or())
):
return gt_bitwise_or
self._reset(mark)
if (
(notin_bitwise_or := self.notin_bitwise_or())
):
return notin_bitwise_or
self._reset(mark)
if (
(in_bitwise_or := self.in_bitwise_or())
):
return in_bitwise_or
self._reset(mark)
if (
(isnot_bitwise_or := self.isnot_bitwise_or())
):
return isnot_bitwise_or
self._reset(mark)
if (
(is_bitwise_or := self.is_bitwise_or())
):
return is_bitwise_or
self._reset(mark)
return None
@memoize
def eq_bitwise_or(self) -> Optional[CmpopExprPair*]:
# eq_bitwise_or: '==' bitwise_or
mark = self._mark()
if (
(literal := self.expect('=='))
and
(a := self.bitwise_or())
):
return _PyPegen_cmpop_expr_pair ( p , Eq , a )
self._reset(mark)
return None
@memoize
def noteq_bitwise_or(self) -> Optional[CmpopExprPair*]:
# noteq_bitwise_or: ('!=') bitwise_or
mark = self._mark()
if (
(tok := self.expect('!='))
and
(a := self.bitwise_or())
):
return _PyPegen_cmpop_expr_pair ( p , NotEq , a )
self._reset(mark)
return None
@memoize
def lte_bitwise_or(self) -> Optional[CmpopExprPair*]:
# lte_bitwise_or: '<=' bitwise_or
mark = self._mark()
if (
(literal := self.expect('<='))
and
(a := self.bitwise_or())
):
return _PyPegen_cmpop_expr_pair ( p , LtE , a )
self._reset(mark)
return None
@memoize
def lt_bitwise_or(self) -> Optional[CmpopExprPair*]:
# lt_bitwise_or: '<' bitwise_or
mark = self._mark()
if (
(literal := self.expect('<'))
and
(a := self.bitwise_or())
):
return _PyPegen_cmpop_expr_pair ( p , Lt , a )
self._reset(mark)
return None
@memoize
def gte_bitwise_or(self) -> Optional[CmpopExprPair*]:
# gte_bitwise_or: '>=' bitwise_or
mark = self._mark()
if (
(literal := self.expect('>='))
and
(a := self.bitwise_or())
):
return _PyPegen_cmpop_expr_pair ( p , GtE , a )
self._reset(mark)
return None
@memoize
def gt_bitwise_or(self) -> Optional[CmpopExprPair*]:
# gt_bitwise_or: '>' bitwise_or
mark = self._mark()
if (
(literal := self.expect('>'))
and
(a := self.bitwise_or())
):
return _PyPegen_cmpop_expr_pair ( p , Gt , a )
self._reset(mark)
return None
@memoize
def notin_bitwise_or(self) -> Optional[CmpopExprPair*]:
# notin_bitwise_or: 'not' 'in' bitwise_or
mark = self._mark()
if (
(literal := self.expect('not'))
and
(literal_1 := self.expect('in'))
and
(a := self.bitwise_or())
):
return _PyPegen_cmpop_expr_pair ( p , NotIn , a )
self._reset(mark)
return None
@memoize
def in_bitwise_or(self) -> Optional[CmpopExprPair*]:
# in_bitwise_or: 'in' bitwise_or
mark = self._mark()
if (
(literal := self.expect('in'))
and
(a := self.bitwise_or())
):
return _PyPegen_cmpop_expr_pair ( p , In , a )
self._reset(mark)
return None
@memoize
def isnot_bitwise_or(self) -> Optional[CmpopExprPair*]:
# isnot_bitwise_or: 'is' 'not' bitwise_or
mark = self._mark()
if (
(literal := self.expect('is'))
and
(literal_1 := self.expect('not'))
and
(a := self.bitwise_or())
):
return _PyPegen_cmpop_expr_pair ( p , IsNot , a )
self._reset(mark)
return None
@memoize
def is_bitwise_or(self) -> Optional[CmpopExprPair*]:
# is_bitwise_or: 'is' bitwise_or
mark = self._mark()
if (
(literal := self.expect('is'))
and
(a := self.bitwise_or())
):
return _PyPegen_cmpop_expr_pair ( p , Is , a )
self._reset(mark)
return None
@memoize_left_rec
def bitwise_or(self) -> Optional[expr_ty]:
# bitwise_or: bitwise_or '|' bitwise_xor | bitwise_xor
mark = self._mark()
if (
(a := self.bitwise_or())
and
(literal := self.expect('|'))
and
(b := self.bitwise_xor())
):
return _PyAST_BinOp ( a , BitOr , b , EXTRA )
self._reset(mark)
if (
(bitwise_xor := self.bitwise_xor())
):
return bitwise_xor
self._reset(mark)
return None
@memoize_left_rec
def bitwise_xor(self) -> Optional[expr_ty]:
# bitwise_xor: bitwise_xor '^' bitwise_and | bitwise_and
mark = self._mark()
if (
(a := self.bitwise_xor())
and
(literal := self.expect('^'))
and
(b := self.bitwise_and())
):
return _PyAST_BinOp ( a , BitXor , b , EXTRA )
self._reset(mark)
if (
(bitwise_and := self.bitwise_and())
):
return bitwise_and
self._reset(mark)
return None
@memoize_left_rec
def bitwise_and(self) -> Optional[expr_ty]:
# bitwise_and: bitwise_and '&' shift_expr | shift_expr
mark = self._mark()
if (
(a := self.bitwise_and())
and
(literal := self.expect('&'))
and
(b := self.shift_expr())
):
return _PyAST_BinOp ( a , BitAnd , b , EXTRA )
self._reset(mark)
if (
(shift_expr := self.shift_expr())
):
return shift_expr
self._reset(mark)
return None
@memoize_left_rec
def shift_expr(self) -> Optional[expr_ty]:
# shift_expr: shift_expr '<<' sum | shift_expr '>>' sum | sum
mark = self._mark()
if (
(a := self.shift_expr())
and
(literal := self.expect('<<'))
and
(b := self.sum())
):
return _PyAST_BinOp ( a , LShift , b , EXTRA )
self._reset(mark)
if (
(a := self.shift_expr())
and
(literal := self.expect('>>'))
and
(b := self.sum())
):
return _PyAST_BinOp ( a , RShift , b , EXTRA )
self._reset(mark)
if (
(sum := self.sum())
):
return sum
self._reset(mark)
return None
@memoize_left_rec
def sum(self) -> Optional[expr_ty]:
# sum: sum '+' term | sum '-' term | term
mark = self._mark()
if (
(a := self.sum())
and
(literal := self.expect('+'))
and
(b := self.term())
):
return _PyAST_BinOp ( a , Add , b , EXTRA )
self._reset(mark)
if (
(a := self.sum())
and
(literal := self.expect('-'))
and
(b := self.term())
):
return _PyAST_BinOp ( a , Sub , b , EXTRA )
self._reset(mark)
if (
(term := self.term())
):
return term
self._reset(mark)
return None
@memoize_left_rec
def term(self) -> Optional[expr_ty]:
# term: term '*' factor | term '/' factor | term '//' factor | term '%' factor | term '@' factor | factor
mark = self._mark()
if (
(a := self.term())
and
(literal := self.expect('*'))
and
(b := self.factor())
):
return _PyAST_BinOp ( a , Mult , b , EXTRA )
self._reset(mark)
if (
(a := self.term())
and
(literal := self.expect('/'))
and
(b := self.factor())
):
return _PyAST_BinOp ( a , Div , b , EXTRA )
self._reset(mark)
if (
(a := self.term())
and
(literal := self.expect('//'))
and
(b := self.factor())
):
return _PyAST_BinOp ( a , FloorDiv , b , EXTRA )
self._reset(mark)
if (
(a := self.term())
and
(literal := self.expect('%'))
and
(b := self.factor())
):
return _PyAST_BinOp ( a , Mod , b , EXTRA )
self._reset(mark)
if (
(a := self.term())
and
(literal := self.expect('@'))
and
(b := self.factor())
):
return CHECK_VERSION ( expr_ty , 5 , "The '@' operator is" , _PyAST_BinOp ( a , MatMult , b , EXTRA ) )
self._reset(mark)
if (
(factor := self.factor())
):
return factor
self._reset(mark)
return None
@memoize
def factor(self) -> Optional[expr_ty]:
# factor: '+' factor | '-' factor | '~' factor | power
mark = self._mark()
if (
(literal := self.expect('+'))
and
(a := self.factor())
):
return _PyAST_UnaryOp ( UAdd , a , EXTRA )
self._reset(mark)
if (
(literal := self.expect('-'))
and
(a := self.factor())
):
return _PyAST_UnaryOp ( USub , a , EXTRA )
self._reset(mark)
if (
(literal := self.expect('~'))
and
(a := self.factor())
):
return _PyAST_UnaryOp ( Invert , a , EXTRA )
self._reset(mark)
if (
(power := self.power())
):
return power
self._reset(mark)
return None
@memoize
def power(self) -> Optional[expr_ty]:
# power: await_primary '**' factor | await_primary
mark = self._mark()
if (
(a := self.await_primary())
and
(literal := self.expect('**'))
and
(b := self.factor())
):
return _PyAST_BinOp ( a , Pow , b , EXTRA )
self._reset(mark)
if (
(await_primary := self.await_primary())
):
return await_primary
self._reset(mark)
return None
@memoize
def await_primary(self) -> Optional[expr_ty]:
# await_primary: AWAIT primary | primary
mark = self._mark()
if (
(_await := self.expect('AWAIT'))
and
(a := self.primary())
):
return CHECK_VERSION ( expr_ty , 5 , "Await expressions are" , _PyAST_Await ( a , EXTRA ) )
self._reset(mark)
if (
(primary := self.primary())
):
return primary
self._reset(mark)
return None
@memoize_left_rec
def primary(self) -> Optional[expr_ty]:
# primary: primary '.' NAME | primary genexp | primary '(' arguments? ')' | primary '[' slices ']' | atom
mark = self._mark()
if (
(a := self.primary())
and
(literal := self.expect('.'))
and
(b := self.name())
):
return _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA )
self._reset(mark)
if (
(a := self.primary())
and
(b := self.genexp())
):
return _PyAST_Call ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA )
self._reset(mark)
if (
(a := self.primary())
and
(literal := self.expect('('))
and
(b := self.arguments(),)
and
(literal_1 := self.expect(')'))
):
return _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA )
self._reset(mark)
if (
(a := self.primary())
and
(literal := self.expect('['))
and
(b := self.slices())
and
(literal_1 := self.expect(']'))
):
return _PyAST_Subscript ( a , b , Load , EXTRA )
self._reset(mark)
if (
(atom := self.atom())
):
return atom
self._reset(mark)
return None
@memoize
def slices(self) -> Optional[expr_ty]:
# slices: slice !',' | ','.(slice | starred_expression)+ ','?
mark = self._mark()
if (
(a := self.slice())
and
self.negative_lookahead(self.expect, ',')
):
return a
self._reset(mark)
if (
(a := self._gather_87())
and
(opt := self.expect(','),)
):
return _PyAST_Tuple ( a , Load , EXTRA )
self._reset(mark)
return None
@memoize
def slice(self) -> Optional[expr_ty]:
# slice: expression? ':' expression? [':' expression?] | named_expression
mark = self._mark()
if (
(a := self.expression(),)
and
(literal := self.expect(':'))
and
(b := self.expression(),)
and
(c := self._tmp_89(),)
):
return _PyAST_Slice ( a , b , c , EXTRA )
self._reset(mark)
if (
(a := self.named_expression())
):
return a
self._reset(mark)
return None
@memoize
def atom(self) -> Optional[expr_ty]:
# atom: NAME | 'True' | 'False' | 'None' | &STRING strings | NUMBER | &'(' (tuple | group | genexp) | &'[' (list | listcomp) | &'{' (dict | set | dictcomp | setcomp) | '...'
mark = self._mark()
if (
(name := self.name())
):
return name
self._reset(mark)
if (
(literal := self.expect('True'))
):
return _PyAST_Constant ( Py_True , NULL , EXTRA )
self._reset(mark)
if (
(literal := self.expect('False'))
):
return _PyAST_Constant ( Py_False , NULL , EXTRA )
self._reset(mark)
if (
(literal := self.expect('None'))
):
return _PyAST_Constant ( Py_None , NULL , EXTRA )
self._reset(mark)
if (
self.positive_lookahead(self.string, )
and
(strings := self.strings())
):
return strings
self._reset(mark)
if (
(number := self.number())
):
return number
self._reset(mark)
if (
self.positive_lookahead(self.expect, '(')
and
(_tmp_90 := self._tmp_90())
):
return _tmp_90
self._reset(mark)
if (
self.positive_lookahead(self.expect, '[')
and
(_tmp_91 := self._tmp_91())
):
return _tmp_91
self._reset(mark)
if (
self.positive_lookahead(self.expect, '{')
and
(_tmp_92 := self._tmp_92())
):
return _tmp_92
self._reset(mark)
if (
(literal := self.expect('...'))
):
return _PyAST_Constant ( Py_Ellipsis , NULL , EXTRA )
self._reset(mark)
return None
@memoize
def group(self) -> Optional[expr_ty]:
# group: '(' (yield_expr | named_expression) ')' | invalid_group
mark = self._mark()
if (
(literal := self.expect('('))
and
(a := self._tmp_93())
and
(literal_1 := self.expect(')'))
):
return a
self._reset(mark)
if (
(invalid_group := self.invalid_group())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def lambdef(self) -> Optional[expr_ty]:
# lambdef: 'lambda' lambda_params? ':' expression
mark = self._mark()
if (
(literal := self.expect('lambda'))
and
(a := self.lambda_params(),)
and
(literal_1 := self.expect(':'))
and
(b := self.expression())
):
return _PyAST_Lambda ( ( a ) ? a : CHECK ( arguments_ty , _PyPegen_empty_arguments ( p ) ) , b , EXTRA )
self._reset(mark)
return None
@memoize
def lambda_params(self) -> Optional[arguments_ty]:
# lambda_params: invalid_lambda_parameters | lambda_parameters
mark = self._mark()
if (
(invalid_lambda_parameters := self.invalid_lambda_parameters())
):
return None # pragma: no cover
self._reset(mark)
if (
(lambda_parameters := self.lambda_parameters())
):
return lambda_parameters
self._reset(mark)
return None
@memoize
def lambda_parameters(self) -> Optional[arguments_ty]:
# lambda_parameters: lambda_slash_no_default lambda_param_no_default* lambda_param_with_default* lambda_star_etc? | lambda_slash_with_default lambda_param_with_default* lambda_star_etc? | lambda_param_no_default+ lambda_param_with_default* lambda_star_etc? | lambda_param_with_default+ lambda_star_etc? | lambda_star_etc
mark = self._mark()
if (
(a := self.lambda_slash_no_default())
and
(b := self._loop0_94(),)
and
(c := self._loop0_95(),)
and
(d := self.lambda_star_etc(),)
):
return CHECK_VERSION ( arguments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , a , NULL , b , c , d ) )
self._reset(mark)
if (
(a := self.lambda_slash_with_default())
and
(b := self._loop0_96(),)
and
(c := self.lambda_star_etc(),)
):
return CHECK_VERSION ( arguments_ty , 8 , "Positional-only parameters are" , _PyPegen_make_arguments ( p , NULL , a , NULL , b , c ) )
self._reset(mark)
if (
(a := self._loop1_97())
and
(b := self._loop0_98(),)
and
(c := self.lambda_star_etc(),)
):
return _PyPegen_make_arguments ( p , NULL , NULL , a , b , c )
self._reset(mark)
if (
(a := self._loop1_99())
and
(b := self.lambda_star_etc(),)
):
return _PyPegen_make_arguments ( p , NULL , NULL , NULL , a , b )
self._reset(mark)
if (
(a := self.lambda_star_etc())
):
return _PyPegen_make_arguments ( p , NULL , NULL , NULL , NULL , a )
self._reset(mark)
return None
@memoize
def lambda_slash_no_default(self) -> Optional[asdl_arg_seq*]:
# lambda_slash_no_default: lambda_param_no_default+ '/' ',' | lambda_param_no_default+ '/' &':'
mark = self._mark()
if (
(a := self._loop1_100())
and
(literal := self.expect('/'))
and
(literal_1 := self.expect(','))
):
return a
self._reset(mark)
if (
(a := self._loop1_101())
and
(literal := self.expect('/'))
and
self.positive_lookahead(self.expect, ':')
):
return a
self._reset(mark)
return None
@memoize
def lambda_slash_with_default(self) -> Optional[SlashWithDefault*]:
# lambda_slash_with_default: lambda_param_no_default* lambda_param_with_default+ '/' ',' | lambda_param_no_default* lambda_param_with_default+ '/' &':'
mark = self._mark()
if (
(a := self._loop0_102(),)
and
(b := self._loop1_103())
and
(literal := self.expect('/'))
and
(literal_1 := self.expect(','))
):
return _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b )
self._reset(mark)
if (
(a := self._loop0_104(),)
and
(b := self._loop1_105())
and
(literal := self.expect('/'))
and
self.positive_lookahead(self.expect, ':')
):
return _PyPegen_slash_with_default ( p , ( asdl_arg_seq* ) a , b )
self._reset(mark)
return None
@memoize
def lambda_star_etc(self) -> Optional[StarEtc*]:
# lambda_star_etc: invalid_lambda_star_etc | '*' lambda_param_no_default lambda_param_maybe_default* lambda_kwds? | '*' ',' lambda_param_maybe_default+ lambda_kwds? | lambda_kwds
mark = self._mark()
if (
(invalid_lambda_star_etc := self.invalid_lambda_star_etc())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('*'))
and
(a := self.lambda_param_no_default())
and
(b := self._loop0_106(),)
and
(c := self.lambda_kwds(),)
):
return _PyPegen_star_etc ( p , a , b , c )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(literal_1 := self.expect(','))
and
(b := self._loop1_107())
and
(c := self.lambda_kwds(),)
):
return _PyPegen_star_etc ( p , NULL , b , c )
self._reset(mark)
if (
(a := self.lambda_kwds())
):
return _PyPegen_star_etc ( p , NULL , NULL , a )
self._reset(mark)
return None
@memoize
def lambda_kwds(self) -> Optional[arg_ty]:
# lambda_kwds: invalid_lambda_kwds | '**' lambda_param_no_default
mark = self._mark()
if (
(invalid_lambda_kwds := self.invalid_lambda_kwds())
):
return None # pragma: no cover
self._reset(mark)
if (
(literal := self.expect('**'))
and
(a := self.lambda_param_no_default())
):
return a
self._reset(mark)
return None
@memoize
def lambda_param_no_default(self) -> Optional[arg_ty]:
# lambda_param_no_default: lambda_param ',' | lambda_param &':'
mark = self._mark()
if (
(a := self.lambda_param())
and
(literal := self.expect(','))
):
return a
self._reset(mark)
if (
(a := self.lambda_param())
and
self.positive_lookahead(self.expect, ':')
):
return a
self._reset(mark)
return None
@memoize
def lambda_param_with_default(self) -> Optional[NameDefaultPair*]:
# lambda_param_with_default: lambda_param default ',' | lambda_param default &':'
mark = self._mark()
if (
(a := self.lambda_param())
and
(c := self.default())
and
(literal := self.expect(','))
):
return _PyPegen_name_default_pair ( p , a , c , NULL )
self._reset(mark)
if (
(a := self.lambda_param())
and
(c := self.default())
and
self.positive_lookahead(self.expect, ':')
):
return _PyPegen_name_default_pair ( p , a , c , NULL )
self._reset(mark)
return None
@memoize
def lambda_param_maybe_default(self) -> Optional[NameDefaultPair*]:
# lambda_param_maybe_default: lambda_param default? ',' | lambda_param default? &':'
mark = self._mark()
if (
(a := self.lambda_param())
and
(c := self.default(),)
and
(literal := self.expect(','))
):
return _PyPegen_name_default_pair ( p , a , c , NULL )
self._reset(mark)
if (
(a := self.lambda_param())
and
(c := self.default(),)
and
self.positive_lookahead(self.expect, ':')
):
return _PyPegen_name_default_pair ( p , a , c , NULL )
self._reset(mark)
return None
@memoize
def lambda_param(self) -> Optional[arg_ty]:
# lambda_param: NAME
mark = self._mark()
if (
(a := self.name())
):
return _PyAST_arg ( a -> v . Name . id , NULL , NULL , EXTRA )
self._reset(mark)
return None
@memoize
def strings(self) -> Optional[expr_ty]:
# strings: STRING+
mark = self._mark()
if (
(a := self._loop1_108())
):
return _PyPegen_concatenate_strings ( p , a )
self._reset(mark)
return None
@memoize
def list(self) -> Optional[expr_ty]:
# list: '[' star_named_expressions? ']'
mark = self._mark()
if (
(literal := self.expect('['))
and
(a := self.star_named_expressions(),)
and
(literal_1 := self.expect(']'))
):
return _PyAST_List ( a , Load , EXTRA )
self._reset(mark)
return None
@memoize
def tuple(self) -> Optional[expr_ty]:
# tuple: '(' [star_named_expression ',' star_named_expressions?] ')'
mark = self._mark()
if (
(literal := self.expect('('))
and
(a := self._tmp_109(),)
and
(literal_1 := self.expect(')'))
):
return _PyAST_Tuple ( a , Load , EXTRA )
self._reset(mark)
return None
@memoize
def set(self) -> Optional[expr_ty]:
# set: '{' star_named_expressions '}'
mark = self._mark()
if (
(literal := self.expect('{'))
and
(a := self.star_named_expressions())
and
(literal_1 := self.expect('}'))
):
return _PyAST_Set ( a , EXTRA )
self._reset(mark)
return None
@memoize
def dict(self) -> Optional[expr_ty]:
# dict: '{' double_starred_kvpairs? '}' | '{' invalid_double_starred_kvpairs '}'
mark = self._mark()
if (
(literal := self.expect('{'))
and
(a := self.double_starred_kvpairs(),)
and
(literal_1 := self.expect('}'))
):
return _PyAST_Dict ( CHECK ( asdl_expr_seq* , _PyPegen_get_keys ( p , a ) ) , CHECK ( asdl_expr_seq* , _PyPegen_get_values ( p , a ) ) , EXTRA )
self._reset(mark)
if (
(literal := self.expect('{'))
and
(invalid_double_starred_kvpairs := self.invalid_double_starred_kvpairs())
and
(literal_1 := self.expect('}'))
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def double_starred_kvpairs(self) -> Optional[asdl_seq*]:
# double_starred_kvpairs: ','.double_starred_kvpair+ ','?
mark = self._mark()
if (
(a := self._gather_110())
and
(opt := self.expect(','),)
):
return a
self._reset(mark)
return None
@memoize
def double_starred_kvpair(self) -> Optional[KeyValuePair*]:
# double_starred_kvpair: '**' bitwise_or | kvpair
mark = self._mark()
if (
(literal := self.expect('**'))
and
(a := self.bitwise_or())
):
return _PyPegen_key_value_pair ( p , NULL , a )
self._reset(mark)
if (
(kvpair := self.kvpair())
):
return kvpair
self._reset(mark)
return None
@memoize
def kvpair(self) -> Optional[KeyValuePair*]:
# kvpair: expression ':' expression
mark = self._mark()
if (
(a := self.expression())
and
(literal := self.expect(':'))
and
(b := self.expression())
):
return _PyPegen_key_value_pair ( p , a , b )
self._reset(mark)
return None
@memoize
def for_if_clauses(self) -> Optional[asdl_comprehension_seq*]:
# for_if_clauses: for_if_clause+
mark = self._mark()
if (
(a := self._loop1_112())
):
return a
self._reset(mark)
return None
@memoize
def for_if_clause(self) -> Optional[comprehension_ty]:
# for_if_clause: ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))* | 'for' star_targets 'in' ~ disjunction (('if' disjunction))* | invalid_for_target
mark = self._mark()
cut = False
if (
(_async := self.expect('ASYNC'))
and
(literal := self.expect('for'))
and
(a := self.star_targets())
and
(literal_1 := self.expect('in'))
and
(cut := True)
and
(b := self.disjunction())
and
(c := self._loop0_113(),)
):
return CHECK_VERSION ( comprehension_ty , 6 , "Async comprehensions are" , _PyAST_comprehension ( a , b , c , 1 , p -> arena ) )
self._reset(mark)
if cut: return None
cut = False
if (
(literal := self.expect('for'))
and
(a := self.star_targets())
and
(literal_1 := self.expect('in'))
and
(cut := True)
and
(b := self.disjunction())
and
(c := self._loop0_114(),)
):
return _PyAST_comprehension ( a , b , c , 0 , p -> arena )
self._reset(mark)
if cut: return None
if (
(invalid_for_target := self.invalid_for_target())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def listcomp(self) -> Optional[expr_ty]:
# listcomp: '[' named_expression for_if_clauses ']' | invalid_comprehension
mark = self._mark()
if (
(literal := self.expect('['))
and
(a := self.named_expression())
and
(b := self.for_if_clauses())
and
(literal_1 := self.expect(']'))
):
return _PyAST_ListComp ( a , b , EXTRA )
self._reset(mark)
if (
(invalid_comprehension := self.invalid_comprehension())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def setcomp(self) -> Optional[expr_ty]:
# setcomp: '{' named_expression for_if_clauses '}' | invalid_comprehension
mark = self._mark()
if (
(literal := self.expect('{'))
and
(a := self.named_expression())
and
(b := self.for_if_clauses())
and
(literal_1 := self.expect('}'))
):
return _PyAST_SetComp ( a , b , EXTRA )
self._reset(mark)
if (
(invalid_comprehension := self.invalid_comprehension())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def genexp(self) -> Optional[expr_ty]:
# genexp: '(' (assignment_expression | expression !':=') for_if_clauses ')' | invalid_comprehension
mark = self._mark()
if (
(literal := self.expect('('))
and
(a := self._tmp_115())
and
(b := self.for_if_clauses())
and
(literal_1 := self.expect(')'))
):
return _PyAST_GeneratorExp ( a , b , EXTRA )
self._reset(mark)
if (
(invalid_comprehension := self.invalid_comprehension())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def dictcomp(self) -> Optional[expr_ty]:
# dictcomp: '{' kvpair for_if_clauses '}' | invalid_dict_comprehension
mark = self._mark()
if (
(literal := self.expect('{'))
and
(a := self.kvpair())
and
(b := self.for_if_clauses())
and
(literal_1 := self.expect('}'))
):
return _PyAST_DictComp ( a -> key , a -> value , b , EXTRA )
self._reset(mark)
if (
(invalid_dict_comprehension := self.invalid_dict_comprehension())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def arguments(self) -> Optional[expr_ty]:
# arguments: args ','? &')' | invalid_arguments
mark = self._mark()
if (
(a := self.args())
and
(opt := self.expect(','),)
and
self.positive_lookahead(self.expect, ')')
):
return a
self._reset(mark)
if (
(invalid_arguments := self.invalid_arguments())
):
return None # pragma: no cover
self._reset(mark)
return None
@memoize
def args(self) -> Optional[expr_ty]:
# args: ','.(starred_expression | (assignment_expression | expression !':=') !'=')+ [',' kwargs] | kwargs
mark = self._mark()
if (
(a := self._gather_116())
and
(b := self._tmp_118(),)
):
return _PyPegen_collect_call_seqs ( p , a , b , EXTRA )
self._reset(mark)
if (
(a := self.kwargs())
):
return _PyAST_Call ( _PyPegen_dummy_name ( p ) , CHECK_NULL_ALLOWED ( asdl_expr_seq* , _PyPegen_seq_extract_starred_exprs ( p , a ) ) , CHECK_NULL_ALLOWED ( asdl_keyword_seq* , _PyPegen_seq_delete_starred_exprs ( p , a ) ) , EXTRA )
self._reset(mark)
return None
@memoize
def kwargs(self) -> Optional[asdl_seq*]:
# kwargs: ','.kwarg_or_starred+ ',' ','.kwarg_or_double_starred+ | ','.kwarg_or_starred+ | ','.kwarg_or_double_starred+
mark = self._mark()
if (
(a := self._gather_119())
and
(literal := self.expect(','))
and
(b := self._gather_121())
):
return _PyPegen_join_sequences ( p , a , b )
self._reset(mark)
if (
(_gather_123 := self._gather_123())
):
return _gather_123
self._reset(mark)
if (
(_gather_125 := self._gather_125())
):
return _gather_125
self._reset(mark)
return None
@memoize
def starred_expression(self) -> Optional[expr_ty]:
# starred_expression: '*' expression
mark = self._mark()
if (
(literal := self.expect('*'))
and
(a := self.expression())
):
return _PyAST_Starred ( a , Load , EXTRA )
self._reset(mark)
return None
@memoize
def kwarg_or_starred(self) -> Optional[KeywordOrStarred*]:
# kwarg_or_starred: invalid_kwarg | NAME '=' expression | starred_expression
mark = self._mark()
if (
(invalid_kwarg := self.invalid_kwarg())
):
return None # pragma: no cover
self._reset(mark)
if (
(a := self.name())
and
(literal := self.expect('='))
and
(b := self.expression())
):
return _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 )
self._reset(mark)
if (
(a := self.starred_expression())
):
return _PyPegen_keyword_or_starred ( p , a , 0 )
self._reset(mark)
return None
@memoize
def kwarg_or_double_starred(self) -> Optional[KeywordOrStarred*]:
# kwarg_or_double_starred: invalid_kwarg | NAME '=' expression | '**' expression
mark = self._mark()
if (
(invalid_kwarg := self.invalid_kwarg())
):
return None # pragma: no cover
self._reset(mark)
if (
(a := self.name())
and
(literal := self.expect('='))
and
(b := self.expression())
):
return _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( a -> v . Name . id , b , EXTRA ) ) , 1 )
self._reset(mark)
if (
(literal := self.expect('**'))
and
(a := self.expression())
):
return _PyPegen_keyword_or_starred ( p , CHECK ( keyword_ty , _PyAST_keyword ( NULL , a , EXTRA ) ) , 1 )
self._reset(mark)
return None
@memoize
def star_targets(self) -> Optional[expr_ty]:
# star_targets: star_target !',' | star_target ((',' star_target))* ','?
mark = self._mark()
if (
(a := self.star_target())
and
self.negative_lookahead(self.expect, ',')
):
return a
self._reset(mark)
if (
(a := self.star_target())
and
(b := self._loop0_127(),)
and
(opt := self.expect(','),)
):
return _PyAST_Tuple ( CHECK ( asdl_expr_seq* , _PyPegen_seq_insert_in_front ( p , a , b ) ) , Store , EXTRA )
self._reset(mark)
return None
@memoize
def star_targets_list_seq(self) -> Optional[asdl_expr_seq*]:
# star_targets_list_seq: ','.star_target+ ','?
mark = self._mark()
if (
(a := self._gather_128())
and
(opt := self.expect(','),)
):
return a
self._reset(mark)
return None
@memoize
def star_targets_tuple_seq(self) -> Optional[asdl_expr_seq*]:
# star_targets_tuple_seq: star_target ((',' star_target))+ ','? | star_target ','
mark = self._mark()
if (
(a := self.star_target())
and
(b := self._loop1_130())
and
(opt := self.expect(','),)
):
return ( asdl_expr_seq* ) _PyPegen_seq_insert_in_front ( p , a , b )
self._reset(mark)
if (
(a := self.star_target())
and
(literal := self.expect(','))
):
return ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a )
self._reset(mark)
return None
@memoize
def star_target(self) -> Optional[expr_ty]:
# star_target: '*' (!'*' star_target) | target_with_star_atom
mark = self._mark()
if (
(literal := self.expect('*'))
and
(a := self._tmp_131())
):
return _PyAST_Starred ( CHECK ( expr_ty , _PyPegen_set_expr_context ( p , a , Store ) ) , Store , EXTRA )
self._reset(mark)
if (
(target_with_star_atom := self.target_with_star_atom())
):
return target_with_star_atom
self._reset(mark)
return None
@memoize
def target_with_star_atom(self) -> Optional[expr_ty]:
# target_with_star_atom: t_primary '.' NAME !t_lookahead | t_primary '[' slices ']' !t_lookahead | star_atom
mark = self._mark()
if (
(a := self.t_primary())
and
(literal := self.expect('.'))
and
(b := self.name())
and
self.negative_lookahead(self.t_lookahead, )
):
return _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA )
self._reset(mark)
if (
(a := self.t_primary())
and
(literal := self.expect('['))
and
(b := self.slices())
and
(literal_1 := self.expect(']'))
and
self.negative_lookahead(self.t_lookahead, )
):
return _PyAST_Subscript ( a , b , Store , EXTRA )
self._reset(mark)
if (
(star_atom := self.star_atom())
):
return star_atom
self._reset(mark)
return None
@memoize
def star_atom(self) -> Optional[expr_ty]:
# star_atom: NAME | '(' target_with_star_atom ')' | '(' star_targets_tuple_seq? ')' | '[' star_targets_list_seq? ']'
mark = self._mark()
if (
(a := self.name())
):
return _PyPegen_set_expr_context ( p , a , Store )
self._reset(mark)
if (
(literal := self.expect('('))
and
(a := self.target_with_star_atom())
and
(literal_1 := self.expect(')'))
):
return _PyPegen_set_expr_context ( p , a , Store )
self._reset(mark)
if (
(literal := self.expect('('))
and
(a := self.star_targets_tuple_seq(),)
and
(literal_1 := self.expect(')'))
):
return _PyAST_Tuple ( a , Store , EXTRA )
self._reset(mark)
if (
(literal := self.expect('['))
and
(a := self.star_targets_list_seq(),)
and
(literal_1 := self.expect(']'))
):
return _PyAST_List ( a , Store , EXTRA )
self._reset(mark)
return None
@memoize
def single_target(self) -> Optional[expr_ty]:
# single_target: single_subscript_attribute_target | NAME | '(' single_target ')'
mark = self._mark()
if (
(single_subscript_attribute_target := self.single_subscript_attribute_target())
):
return single_subscript_attribute_target
self._reset(mark)
if (
(a := self.name())
):
return _PyPegen_set_expr_context ( p , a , Store )
self._reset(mark)
if (
(literal := self.expect('('))
and
(a := self.single_target())
and
(literal_1 := self.expect(')'))
):
return a
self._reset(mark)
return None
@memoize
def single_subscript_attribute_target(self) -> Optional[expr_ty]:
# single_subscript_attribute_target: t_primary '.' NAME !t_lookahead | t_primary '[' slices ']' !t_lookahead
mark = self._mark()
if (
(a := self.t_primary())
and
(literal := self.expect('.'))
and
(b := self.name())
and
self.negative_lookahead(self.t_lookahead, )
):
return _PyAST_Attribute ( a , b -> v . Name . id , Store , EXTRA )
self._reset(mark)
if (
(a := self.t_primary())
and
(literal := self.expect('['))
and
(b := self.slices())
and
(literal_1 := self.expect(']'))
and
self.negative_lookahead(self.t_lookahead, )
):
return _PyAST_Subscript ( a , b , Store , EXTRA )
self._reset(mark)
return None
@memoize_left_rec
def t_primary(self) -> Optional[expr_ty]:
# t_primary: t_primary '.' NAME &t_lookahead | t_primary '[' slices ']' &t_lookahead | t_primary genexp &t_lookahead | t_primary '(' arguments? ')' &t_lookahead | atom &t_lookahead
mark = self._mark()
if (
(a := self.t_primary())
and
(literal := self.expect('.'))
and
(b := self.name())
and
self.positive_lookahead(self.t_lookahead, )
):
return _PyAST_Attribute ( a , b -> v . Name . id , Load , EXTRA )
self._reset(mark)
if (
(a := self.t_primary())
and
(literal := self.expect('['))
and
(b := self.slices())
and
(literal_1 := self.expect(']'))
and
self.positive_lookahead(self.t_lookahead, )
):
return _PyAST_Subscript ( a , b , Load , EXTRA )
self._reset(mark)
if (
(a := self.t_primary())
and
(b := self.genexp())
and
self.positive_lookahead(self.t_lookahead, )
):
return _PyAST_Call ( a , CHECK ( asdl_expr_seq* , ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , b ) ) , NULL , EXTRA )
self._reset(mark)
if (
(a := self.t_primary())
and
(literal := self.expect('('))
and
(b := self.arguments(),)
and
(literal_1 := self.expect(')'))
and
self.positive_lookahead(self.t_lookahead, )
):
return _PyAST_Call ( a , ( b ) ? ( ( expr_ty ) b ) -> v . Call . args : NULL , ( b ) ? ( ( expr_ty ) b ) -> v . Call . keywords : NULL , EXTRA )
self._reset(mark)
if (
(a := self.atom())
and
self.positive_lookahead(self.t_lookahead, )
):
return a
self._reset(mark)
return None
@memoize
def t_lookahead(self) -> Optional[Any]:
# t_lookahead: '(' | '[' | '.'
mark = self._mark()
if (
(literal := self.expect('('))
):
return literal
self._reset(mark)
if (
(literal := self.expect('['))
):
return literal
self._reset(mark)
if (
(literal := self.expect('.'))
):
return literal
self._reset(mark)
return None
@memoize
def del_targets(self) -> Optional[asdl_expr_seq*]:
# del_targets: ','.del_target+ ','?
mark = self._mark()
if (
(a := self._gather_132())
and
(opt := self.expect(','),)
):
return a
self._reset(mark)
return None
@memoize
def del_target(self) -> Optional[expr_ty]:
# del_target: t_primary '.' NAME !t_lookahead | t_primary '[' slices ']' !t_lookahead | del_t_atom
mark = self._mark()
if (
(a := self.t_primary())
and
(literal := self.expect('.'))
and
(b := self.name())
and
self.negative_lookahead(self.t_lookahead, )
):
return _PyAST_Attribute ( a , b -> v . Name . id , Del , EXTRA )
self._reset(mark)
if (
(a := self.t_primary())
and
(literal := self.expect('['))
and
(b := self.slices())
and
(literal_1 := self.expect(']'))
and
self.negative_lookahead(self.t_lookahead, )
):
return _PyAST_Subscript ( a , b , Del , EXTRA )
self._reset(mark)
if (
(del_t_atom := self.del_t_atom())
):
return del_t_atom
self._reset(mark)
return None
@memoize
def del_t_atom(self) -> Optional[expr_ty]:
# del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']'
mark = self._mark()
if (
(a := self.name())
):
return _PyPegen_set_expr_context ( p , a , Del )
self._reset(mark)
if (
(literal := self.expect('('))
and
(a := self.del_target())
and
(literal_1 := self.expect(')'))
):
return _PyPegen_set_expr_context ( p , a , Del )
self._reset(mark)
if (
(literal := self.expect('('))
and
(a := self.del_targets(),)
and
(literal_1 := self.expect(')'))
):
return _PyAST_Tuple ( a , Del , EXTRA )
self._reset(mark)
if (
(literal := self.expect('['))
and
(a := self.del_targets(),)
and
(literal_1 := self.expect(']'))
):
return _PyAST_List ( a , Del , EXTRA )
self._reset(mark)
return None
@memoize
def type_expressions(self) -> Optional[asdl_expr_seq*]:
# type_expressions: ','.expression+ ',' '*' expression ',' '**' expression | ','.expression+ ',' '*' expression | ','.expression+ ',' '**' expression | '*' expression ',' '**' expression | '*' expression | '**' expression | ','.expression+
mark = self._mark()
if (
(a := self._gather_134())
and
(literal := self.expect(','))
and
(literal_1 := self.expect('*'))
and
(b := self.expression())
and
(literal_2 := self.expect(','))
and
(literal_3 := self.expect('**'))
and
(c := self.expression())
):
return ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq* , _PyPegen_seq_append_to_end ( p , a , b ) ) , c )
self._reset(mark)
if (
(a := self._gather_136())
and
(literal := self.expect(','))
and
(literal_1 := self.expect('*'))
and
(b := self.expression())
):
return ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , a , b )
self._reset(mark)
if (
(a := self._gather_138())
and
(literal := self.expect(','))
and
(literal_1 := self.expect('**'))
and
(b := self.expression())
):
return ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , a , b )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(a := self.expression())
and
(literal_1 := self.expect(','))
and
(literal_2 := self.expect('**'))
and
(b := self.expression())
):
return ( asdl_expr_seq* ) _PyPegen_seq_append_to_end ( p , CHECK ( asdl_seq* , _PyPegen_singleton_seq ( p , a ) ) , b )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(a := self.expression())
):
return ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a )
self._reset(mark)
if (
(literal := self.expect('**'))
and
(a := self.expression())
):
return ( asdl_expr_seq* ) _PyPegen_singleton_seq ( p , a )
self._reset(mark)
if (
(a := self._gather_140())
):
return a
self._reset(mark)
return None
@memoize
def func_type_comment(self) -> Optional[Token*]:
# func_type_comment: NEWLINE TYPE_COMMENT &(NEWLINE INDENT) | invalid_double_type_comments | TYPE_COMMENT
mark = self._mark()
if (
(_newline := self.expect('NEWLINE'))
and
(t := self.type_comment())
and
self.positive_lookahead(self._tmp_142, )
):
return t
self._reset(mark)
if (
(invalid_double_type_comments := self.invalid_double_type_comments())
):
return None # pragma: no cover
self._reset(mark)
if (
(type_comment := self.type_comment())
):
return type_comment
self._reset(mark)
return None
@memoize
def invalid_arguments(self) -> Optional[Any]:
# invalid_arguments: args ',' '*' | expression for_if_clauses ',' [args | expression for_if_clauses] | NAME '=' expression for_if_clauses | args for_if_clauses | args ',' expression for_if_clauses | args ',' args
mark = self._mark()
if (
(a := self.args())
and
(literal := self.expect(','))
and
(literal_1 := self.expect('*'))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable argument unpacking follows keyword argument unpacking" )
self._reset(mark)
if (
(a := self.expression())
and
(b := self.for_if_clauses())
and
(literal := self.expect(','))
and
(opt := self._tmp_143(),)
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , _PyPegen_get_last_comprehension_item ( PyPegen_last_item ( b , comprehension_ty ) ) , "Generator expression must be parenthesized" )
self._reset(mark)
if (
(a := self.name())
and
(b := self.expect('='))
and
(expression := self.expression())
and
(for_if_clauses := self.for_if_clauses())
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" )
self._reset(mark)
if (
(a := self.args())
and
(b := self.for_if_clauses())
):
return _PyPegen_nonparen_genexp_in_call ( p , a , b )
self._reset(mark)
if (
(args := self.args())
and
(literal := self.expect(','))
and
(a := self.expression())
and
(b := self.for_if_clauses())
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , _PyPegen_get_last_comprehension_item ( PyPegen_last_item ( b , comprehension_ty ) ) , "Generator expression must be parenthesized" )
self._reset(mark)
if (
(a := self.args())
and
(literal := self.expect(','))
and
(args := self.args())
):
return _PyPegen_arguments_parsing_error ( p , a )
self._reset(mark)
return None
@memoize
def invalid_kwarg(self) -> Optional[Any]:
# invalid_kwarg: ('True' | 'False' | 'None') '=' | NAME '=' expression for_if_clauses | !(NAME '=') expression '='
mark = self._mark()
if (
(a := self._tmp_144())
and
(b := self.expect('='))
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "cannot assign to %s" , PyBytes_AS_STRING ( a -> bytes ) )
self._reset(mark)
if (
(a := self.name())
and
(b := self.expect('='))
and
(expression := self.expression())
and
(for_if_clauses := self.for_if_clauses())
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" )
self._reset(mark)
if (
self.negative_lookahead(self._tmp_145, )
and
(a := self.expression())
and
(b := self.expect('='))
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expression cannot contain assignment, perhaps you meant \"==\"?" )
self._reset(mark)
return None
@memoize
def expression_without_invalid(self) -> Optional[expr_ty]:
# expression_without_invalid: disjunction 'if' disjunction 'else' expression | disjunction | lambdef
mark = self._mark()
if (
(a := self.disjunction())
and
(literal := self.expect('if'))
and
(b := self.disjunction())
and
(literal_1 := self.expect('else'))
and
(c := self.expression())
):
return _PyAST_IfExp ( b , a , c , EXTRA )
self._reset(mark)
if (
(disjunction := self.disjunction())
):
return disjunction
self._reset(mark)
if (
(lambdef := self.lambdef())
):
return lambdef
self._reset(mark)
return None
@memoize
def invalid_legacy_expression(self) -> Optional[Any]:
# invalid_legacy_expression: NAME !'(' star_expressions
mark = self._mark()
if (
(a := self.name())
and
self.negative_lookahead(self.expect, '(')
and
(b := self.star_expressions())
):
return _PyPegen_check_legacy_stmt ( p , a ) ? RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Missing parentheses in call to '%U'. Did you mean %U(...)?" , a -> v . Name . id , a -> v . Name . id ) : NULL
self._reset(mark)
return None
@memoize
def invalid_expression(self) -> Optional[Any]:
# invalid_expression: !(NAME STRING | SOFT_KEYWORD) disjunction expression_without_invalid | disjunction 'if' disjunction !('else' | ':')
mark = self._mark()
if (
self.negative_lookahead(self._tmp_146, )
and
(a := self.disjunction())
and
(b := self.expression_without_invalid())
):
return _PyPegen_check_legacy_stmt ( p , a ) ? NULL : p -> tokens [p -> mark - 1] -> level == 0 ? NULL : RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Perhaps you forgot a comma?" )
self._reset(mark)
if (
(a := self.disjunction())
and
(literal := self.expect('if'))
and
(b := self.disjunction())
and
self.negative_lookahead(self._tmp_147, )
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "expected 'else' after 'if' expression" )
self._reset(mark)
return None
@memoize
def invalid_named_expression(self) -> Optional[Any]:
# invalid_named_expression: expression ':=' expression | NAME '=' bitwise_or !('=' | ':=') | !(list | tuple | genexp | 'True' | 'None' | 'False') bitwise_or '=' bitwise_or !('=' | ':=')
mark = self._mark()
if (
(a := self.expression())
and
(literal := self.expect(':='))
and
(expression := self.expression())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use assignment expressions with %s" , _PyPegen_get_expr_name ( a ) )
self._reset(mark)
if (
(a := self.name())
and
(literal := self.expect('='))
and
(b := self.bitwise_or())
and
self.negative_lookahead(self._tmp_148, )
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "invalid syntax. Maybe you meant '==' or ':=' instead of '='?" )
self._reset(mark)
if (
self.negative_lookahead(self._tmp_149, )
and
(a := self.bitwise_or())
and
(b := self.expect('='))
and
(bitwise_or := self.bitwise_or())
and
self.negative_lookahead(self._tmp_150, )
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot assign to %s here. Maybe you meant '==' instead of '='?" , _PyPegen_get_expr_name ( a ) )
self._reset(mark)
return None
@memoize
def invalid_assignment(self) -> Optional[Any]:
# invalid_assignment: invalid_ann_assign_target ':' expression | star_named_expression ',' star_named_expressions* ':' expression | expression ':' expression | ((star_targets '='))* star_expressions '=' | ((star_targets '='))* yield_expr '=' | star_expressions augassign (yield_expr | star_expressions)
mark = self._mark()
if (
(a := self.invalid_ann_assign_target())
and
(literal := self.expect(':'))
and
(expression := self.expression())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not %s) can be annotated" , _PyPegen_get_expr_name ( a ) )
self._reset(mark)
if (
(a := self.star_named_expression())
and
(literal := self.expect(','))
and
(_loop0_151 := self._loop0_151(),)
and
(literal_1 := self.expect(':'))
and
(expression := self.expression())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "only single target (not tuple) can be annotated" )
self._reset(mark)
if (
(a := self.expression())
and
(literal := self.expect(':'))
and
(expression := self.expression())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "illegal target for annotation" )
self._reset(mark)
if (
(_loop0_152 := self._loop0_152(),)
and
(a := self.star_expressions())
and
(literal := self.expect('='))
):
return RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a )
self._reset(mark)
if (
(_loop0_153 := self._loop0_153(),)
and
(a := self.yield_expr())
and
(literal := self.expect('='))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "assignment to yield expression not possible" )
self._reset(mark)
if (
(a := self.star_expressions())
and
(augassign := self.augassign())
and
(_tmp_154 := self._tmp_154())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "'%s' is an illegal expression for augmented assignment" , _PyPegen_get_expr_name ( a ) )
self._reset(mark)
return None
@memoize
def invalid_ann_assign_target(self) -> Optional[expr_ty]:
# invalid_ann_assign_target: list | tuple | '(' invalid_ann_assign_target ')'
mark = self._mark()
if (
(list := self.list())
):
return list
self._reset(mark)
if (
(tuple := self.tuple())
):
return tuple
self._reset(mark)
if (
(literal := self.expect('('))
and
(a := self.invalid_ann_assign_target())
and
(literal_1 := self.expect(')'))
):
return a
self._reset(mark)
return None
@memoize
def invalid_del_stmt(self) -> Optional[Any]:
# invalid_del_stmt: 'del' star_expressions
mark = self._mark()
if (
(literal := self.expect('del'))
and
(a := self.star_expressions())
):
return RAISE_SYNTAX_ERROR_INVALID_TARGET ( DEL_TARGETS , a )
self._reset(mark)
return None
@memoize
def invalid_block(self) -> Optional[Any]:
# invalid_block: NEWLINE !INDENT
mark = self._mark()
if (
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block" )
self._reset(mark)
return None
@memoize
def invalid_comprehension(self) -> Optional[Any]:
# invalid_comprehension: ('[' | '(' | '{') starred_expression for_if_clauses | ('[' | '{') star_named_expression ',' star_named_expressions for_if_clauses | ('[' | '{') star_named_expression ',' for_if_clauses
mark = self._mark()
if (
(_tmp_155 := self._tmp_155())
and
(a := self.starred_expression())
and
(for_if_clauses := self.for_if_clauses())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "iterable unpacking cannot be used in comprehension" )
self._reset(mark)
if (
(_tmp_156 := self._tmp_156())
and
(a := self.star_named_expression())
and
(literal := self.expect(','))
and
(b := self.star_named_expressions())
and
(for_if_clauses := self.for_if_clauses())
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , PyPegen_last_item ( b , expr_ty ) , "did you forget parentheses around the comprehension target?" )
self._reset(mark)
if (
(_tmp_157 := self._tmp_157())
and
(a := self.star_named_expression())
and
(b := self.expect(','))
and
(for_if_clauses := self.for_if_clauses())
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "did you forget parentheses around the comprehension target?" )
self._reset(mark)
return None
@memoize
def invalid_dict_comprehension(self) -> Optional[Any]:
# invalid_dict_comprehension: '{' '**' bitwise_or for_if_clauses '}'
mark = self._mark()
if (
(literal := self.expect('{'))
and
(a := self.expect('**'))
and
(bitwise_or := self.bitwise_or())
and
(for_if_clauses := self.for_if_clauses())
and
(literal_1 := self.expect('}'))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "dict unpacking cannot be used in dict comprehension" )
self._reset(mark)
return None
@memoize
def invalid_parameters(self) -> Optional[Any]:
# invalid_parameters: param_no_default* invalid_parameters_helper param_no_default | param_no_default* '(' param_no_default+ ','? ')' | "/" ',' | (slash_no_default | slash_with_default) param_maybe_default* '/' | [(slash_no_default | slash_with_default)] param_maybe_default* '*' (',' | param_no_default) param_maybe_default* '/' | param_maybe_default+ '/' '*'
mark = self._mark()
if (
(_loop0_158 := self._loop0_158(),)
and
(invalid_parameters_helper := self.invalid_parameters_helper())
and
(a := self.param_no_default())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "non-default argument follows default argument" )
self._reset(mark)
if (
(_loop0_159 := self._loop0_159(),)
and
(a := self.expect('('))
and
(_loop1_160 := self._loop1_160())
and
(opt := self.expect(','),)
and
(b := self.expect(')'))
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Function parameters cannot be parenthesized" )
self._reset(mark)
if (
(a := self.expect("/"))
and
(literal := self.expect(','))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "at least one argument must precede /" )
self._reset(mark)
if (
(_tmp_161 := self._tmp_161())
and
(_loop0_162 := self._loop0_162(),)
and
(a := self.expect('/'))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ may appear only once" )
self._reset(mark)
if (
(opt := self._tmp_163(),)
and
(_loop0_164 := self._loop0_164(),)
and
(literal := self.expect('*'))
and
(_tmp_165 := self._tmp_165())
and
(_loop0_166 := self._loop0_166(),)
and
(a := self.expect('/'))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ must be ahead of *" )
self._reset(mark)
if (
(_loop1_167 := self._loop1_167())
and
(literal := self.expect('/'))
and
(a := self.expect('*'))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected comma between / and *" )
self._reset(mark)
return None
@memoize
def invalid_default(self) -> Optional[Any]:
# invalid_default: '=' &(')' | ',')
mark = self._mark()
if (
(a := self.expect('='))
and
self.positive_lookahead(self._tmp_168, )
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected default value expression" )
self._reset(mark)
return None
@memoize
def invalid_star_etc(self) -> Optional[Any]:
# invalid_star_etc: '*' (')' | ',' (')' | '**')) | '*' ',' TYPE_COMMENT | '*' param '=' | '*' (param_no_default | ',') param_maybe_default* '*' (param_no_default | ',')
mark = self._mark()
if (
(a := self.expect('*'))
and
(_tmp_169 := self._tmp_169())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "named arguments must follow bare *" )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(literal_1 := self.expect(','))
and
(type_comment := self.type_comment())
):
return RAISE_SYNTAX_ERROR ( "bare * has associated type comment" )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(param := self.param())
and
(a := self.expect('='))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-positional argument cannot have default value" )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(_tmp_170 := self._tmp_170())
and
(_loop0_171 := self._loop0_171(),)
and
(a := self.expect('*'))
and
(_tmp_172 := self._tmp_172())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "* argument may appear only once" )
self._reset(mark)
return None
@memoize
def invalid_kwds(self) -> Optional[Any]:
# invalid_kwds: '**' param '=' | '**' param ',' param | '**' param ',' ('*' | '**' | '/')
mark = self._mark()
if (
(literal := self.expect('**'))
and
(param := self.param())
and
(a := self.expect('='))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-keyword argument cannot have default value" )
self._reset(mark)
if (
(literal := self.expect('**'))
and
(param := self.param())
and
(literal_1 := self.expect(','))
and
(a := self.param())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" )
self._reset(mark)
if (
(literal := self.expect('**'))
and
(param := self.param())
and
(literal_1 := self.expect(','))
and
(a := self._tmp_173())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" )
self._reset(mark)
return None
@memoize
def invalid_parameters_helper(self) -> Optional[Any]:
# invalid_parameters_helper: slash_with_default | param_with_default+
mark = self._mark()
if (
(a := self.slash_with_default())
):
return _PyPegen_singleton_seq ( p , a )
self._reset(mark)
if (
(_loop1_174 := self._loop1_174())
):
return _loop1_174
self._reset(mark)
return None
@memoize
def invalid_lambda_parameters(self) -> Optional[Any]:
# invalid_lambda_parameters: lambda_param_no_default* invalid_lambda_parameters_helper lambda_param_no_default | lambda_param_no_default* '(' ','.lambda_param+ ','? ')' | "/" ',' | (lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* '/' | [(lambda_slash_no_default | lambda_slash_with_default)] lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* '/' | lambda_param_maybe_default+ '/' '*'
mark = self._mark()
if (
(_loop0_175 := self._loop0_175(),)
and
(invalid_lambda_parameters_helper := self.invalid_lambda_parameters_helper())
and
(a := self.lambda_param_no_default())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "non-default argument follows default argument" )
self._reset(mark)
if (
(_loop0_176 := self._loop0_176(),)
and
(a := self.expect('('))
and
(_gather_177 := self._gather_177())
and
(opt := self.expect(','),)
and
(b := self.expect(')'))
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( a , b , "Lambda expression parameters cannot be parenthesized" )
self._reset(mark)
if (
(a := self.expect("/"))
and
(literal := self.expect(','))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "at least one argument must precede /" )
self._reset(mark)
if (
(_tmp_179 := self._tmp_179())
and
(_loop0_180 := self._loop0_180(),)
and
(a := self.expect('/'))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ may appear only once" )
self._reset(mark)
if (
(opt := self._tmp_181(),)
and
(_loop0_182 := self._loop0_182(),)
and
(literal := self.expect('*'))
and
(_tmp_183 := self._tmp_183())
and
(_loop0_184 := self._loop0_184(),)
and
(a := self.expect('/'))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "/ must be ahead of *" )
self._reset(mark)
if (
(_loop1_185 := self._loop1_185())
and
(literal := self.expect('/'))
and
(a := self.expect('*'))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expected comma between / and *" )
self._reset(mark)
return None
@memoize
def invalid_lambda_parameters_helper(self) -> Optional[Any]:
# invalid_lambda_parameters_helper: lambda_slash_with_default | lambda_param_with_default+
mark = self._mark()
if (
(a := self.lambda_slash_with_default())
):
return _PyPegen_singleton_seq ( p , a )
self._reset(mark)
if (
(_loop1_186 := self._loop1_186())
):
return _loop1_186
self._reset(mark)
return None
@memoize
def invalid_lambda_star_etc(self) -> Optional[Any]:
# invalid_lambda_star_etc: '*' (':' | ',' (':' | '**')) | '*' lambda_param '=' | '*' (lambda_param_no_default | ',') lambda_param_maybe_default* '*' (lambda_param_no_default | ',')
mark = self._mark()
if (
(literal := self.expect('*'))
and
(_tmp_187 := self._tmp_187())
):
return RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(lambda_param := self.lambda_param())
and
(a := self.expect('='))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-positional argument cannot have default value" )
self._reset(mark)
if (
(literal := self.expect('*'))
and
(_tmp_188 := self._tmp_188())
and
(_loop0_189 := self._loop0_189(),)
and
(a := self.expect('*'))
and
(_tmp_190 := self._tmp_190())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "* argument may appear only once" )
self._reset(mark)
return None
@memoize
def invalid_lambda_kwds(self) -> Optional[Any]:
# invalid_lambda_kwds: '**' lambda_param '=' | '**' lambda_param ',' lambda_param | '**' lambda_param ',' ('*' | '**' | '/')
mark = self._mark()
if (
(literal := self.expect('**'))
and
(lambda_param := self.lambda_param())
and
(a := self.expect('='))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "var-keyword argument cannot have default value" )
self._reset(mark)
if (
(literal := self.expect('**'))
and
(lambda_param := self.lambda_param())
and
(literal_1 := self.expect(','))
and
(a := self.lambda_param())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" )
self._reset(mark)
if (
(literal := self.expect('**'))
and
(lambda_param := self.lambda_param())
and
(literal_1 := self.expect(','))
and
(a := self._tmp_191())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "arguments cannot follow var-keyword argument" )
self._reset(mark)
return None
@memoize
def invalid_double_type_comments(self) -> Optional[Any]:
# invalid_double_type_comments: TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT
mark = self._mark()
if (
(type_comment := self.type_comment())
and
(_newline := self.expect('NEWLINE'))
and
(type_comment_1 := self.type_comment())
and
(_newline_1 := self.expect('NEWLINE'))
and
(_indent := self.expect('INDENT'))
):
return RAISE_SYNTAX_ERROR ( "Cannot have two type comments on def" )
self._reset(mark)
return None
@memoize
def invalid_with_item(self) -> Optional[Any]:
# invalid_with_item: expression 'as' expression &(',' | ')' | ':')
mark = self._mark()
if (
(expression := self.expression())
and
(literal := self.expect('as'))
and
(a := self.expression())
and
self.positive_lookahead(self._tmp_192, )
):
return RAISE_SYNTAX_ERROR_INVALID_TARGET ( STAR_TARGETS , a )
self._reset(mark)
return None
@memoize
def invalid_for_target(self) -> Optional[Any]:
# invalid_for_target: ASYNC? 'for' star_expressions
mark = self._mark()
if (
(opt := self.expect('ASYNC'),)
and
(literal := self.expect('for'))
and
(a := self.star_expressions())
):
return RAISE_SYNTAX_ERROR_INVALID_TARGET ( FOR_TARGETS , a )
self._reset(mark)
return None
@memoize
def invalid_group(self) -> Optional[Any]:
# invalid_group: '(' starred_expression ')' | '(' '**' expression ')'
mark = self._mark()
if (
(literal := self.expect('('))
and
(a := self.starred_expression())
and
(literal_1 := self.expect(')'))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use starred expression here" )
self._reset(mark)
if (
(literal := self.expect('('))
and
(a := self.expect('**'))
and
(expression := self.expression())
and
(literal_1 := self.expect(')'))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use double starred expression here" )
self._reset(mark)
return None
@memoize
def invalid_import_from_targets(self) -> Optional[Any]:
# invalid_import_from_targets: import_from_as_names ',' NEWLINE
mark = self._mark()
if (
(import_from_as_names := self.import_from_as_names())
and
(literal := self.expect(','))
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "trailing comma not allowed without surrounding parentheses" )
self._reset(mark)
return None
@memoize
def invalid_with_stmt(self) -> Optional[Any]:
# invalid_with_stmt: ASYNC? 'with' ','.(expression ['as' star_target])+ NEWLINE | ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE
mark = self._mark()
if (
(opt := self.expect('ASYNC'),)
and
(literal := self.expect('with'))
and
(_gather_193 := self._gather_193())
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "expected ':'" )
self._reset(mark)
if (
(opt := self.expect('ASYNC'),)
and
(literal := self.expect('with'))
and
(literal_1 := self.expect('('))
and
(_gather_195 := self._gather_195())
and
(opt_1 := self.expect(','),)
and
(literal_2 := self.expect(')'))
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "expected ':'" )
self._reset(mark)
return None
@memoize
def invalid_with_stmt_indent(self) -> Optional[Any]:
# invalid_with_stmt_indent: ASYNC? 'with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT | ASYNC? 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT
mark = self._mark()
if (
(opt := self.expect('ASYNC'),)
and
(a := self.expect('with'))
and
(_gather_197 := self._gather_197())
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'with' statement on line %d" , a -> lineno )
self._reset(mark)
if (
(opt := self.expect('ASYNC'),)
and
(a := self.expect('with'))
and
(literal := self.expect('('))
and
(_gather_199 := self._gather_199())
and
(opt_1 := self.expect(','),)
and
(literal_1 := self.expect(')'))
and
(literal_2 := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'with' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_try_stmt(self) -> Optional[Any]:
# invalid_try_stmt: 'try' ':' NEWLINE !INDENT | 'try' ':' block !('except' | 'finally') | 'try' ':' block* ((except_block+ except_star_block) | (except_star_block+ except_block)) block*
mark = self._mark()
if (
(a := self.expect('try'))
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'try' statement on line %d" , a -> lineno )
self._reset(mark)
if (
(literal := self.expect('try'))
and
(literal_1 := self.expect(':'))
and
(block := self.block())
and
self.negative_lookahead(self._tmp_201, )
):
return RAISE_SYNTAX_ERROR ( "expected 'except' or 'finally' block" )
self._reset(mark)
if (
(literal := self.expect('try'))
and
(literal_1 := self.expect(':'))
and
(_loop0_202 := self._loop0_202(),)
and
(_tmp_203 := self._tmp_203())
and
(_loop0_204 := self._loop0_204(),)
):
return RAISE_SYNTAX_ERROR ( "cannot have both 'except' and 'except*' on the same 'try'" )
self._reset(mark)
return None
@memoize
def invalid_except_stmt(self) -> Optional[Any]:
# invalid_except_stmt: 'except' '*'? expression ',' expressions ['as' NAME] ':' | 'except' '*'? expression ['as' NAME] NEWLINE | 'except' NEWLINE | 'except' '*' (NEWLINE | ':')
mark = self._mark()
if (
(literal := self.expect('except'))
and
(opt := self.expect('*'),)
and
(a := self.expression())
and
(literal_1 := self.expect(','))
and
(expressions := self.expressions())
and
(opt_1 := self._tmp_205(),)
and
(literal_2 := self.expect(':'))
):
return RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "multiple exception types must be parenthesized" )
self._reset(mark)
if (
(a := self.expect('except'))
and
(opt := self.expect('*'),)
and
(expression := self.expression())
and
(opt_1 := self._tmp_206(),)
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "expected ':'" )
self._reset(mark)
if (
(a := self.expect('except'))
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "expected ':'" )
self._reset(mark)
if (
(a := self.expect('except'))
and
(literal := self.expect('*'))
and
(_tmp_207 := self._tmp_207())
):
return RAISE_SYNTAX_ERROR ( "expected one or more exception types" )
self._reset(mark)
return None
@memoize
def invalid_finally_stmt(self) -> Optional[Any]:
# invalid_finally_stmt: 'finally' ':' NEWLINE !INDENT
mark = self._mark()
if (
(a := self.expect('finally'))
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'finally' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_except_stmt_indent(self) -> Optional[Any]:
# invalid_except_stmt_indent: 'except' expression ['as' NAME] ':' NEWLINE !INDENT | 'except' ':' NEWLINE !INDENT
mark = self._mark()
if (
(a := self.expect('except'))
and
(expression := self.expression())
and
(opt := self._tmp_208(),)
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'except' statement on line %d" , a -> lineno )
self._reset(mark)
if (
(a := self.expect('except'))
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'except' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_except_star_stmt_indent(self) -> Optional[Any]:
# invalid_except_star_stmt_indent: 'except' '*' expression ['as' NAME] ':' NEWLINE !INDENT
mark = self._mark()
if (
(a := self.expect('except'))
and
(literal := self.expect('*'))
and
(expression := self.expression())
and
(opt := self._tmp_209(),)
and
(literal_1 := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'except*' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_match_stmt(self) -> Optional[Any]:
# invalid_match_stmt: "match" subject_expr NEWLINE | "match" subject_expr ':' NEWLINE !INDENT
mark = self._mark()
if (
(literal := self.expect("match"))
and
(subject_expr := self.subject_expr())
and
(_newline := self.expect('NEWLINE'))
):
return CHECK_VERSION ( void* , 10 , "Pattern matching is" , RAISE_SYNTAX_ERROR ( "expected ':'" ) )
self._reset(mark)
if (
(a := self.expect("match"))
and
(subject := self.subject_expr())
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'match' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_case_block(self) -> Optional[Any]:
# invalid_case_block: "case" patterns guard? NEWLINE | "case" patterns guard? ':' NEWLINE !INDENT
mark = self._mark()
if (
(literal := self.expect("case"))
and
(patterns := self.patterns())
and
(opt := self.guard(),)
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "expected ':'" )
self._reset(mark)
if (
(a := self.expect("case"))
and
(patterns := self.patterns())
and
(opt := self.guard(),)
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'case' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_as_pattern(self) -> Optional[Any]:
# invalid_as_pattern: or_pattern 'as' "_" | or_pattern 'as' !NAME expression
mark = self._mark()
if (
(or_pattern := self.or_pattern())
and
(literal := self.expect('as'))
and
(a := self.expect("_"))
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot use '_' as a target" )
self._reset(mark)
if (
(or_pattern := self.or_pattern())
and
(literal := self.expect('as'))
and
self.negative_lookahead(self.name, )
and
(a := self.expression())
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "invalid pattern target" )
self._reset(mark)
return None
@memoize
def invalid_class_pattern(self) -> Optional[Any]:
# invalid_class_pattern: name_or_attr '(' invalid_class_argument_pattern
mark = self._mark()
if (
(name_or_attr := self.name_or_attr())
and
(literal := self.expect('('))
and
(a := self.invalid_class_argument_pattern())
):
return RAISE_SYNTAX_ERROR_KNOWN_RANGE ( PyPegen_first_item ( a , pattern_ty ) , PyPegen_last_item ( a , pattern_ty ) , "positional patterns follow keyword patterns" )
self._reset(mark)
return None
@memoize
def invalid_class_argument_pattern(self) -> Optional[asdl_pattern_seq*]:
# invalid_class_argument_pattern: [positional_patterns ','] keyword_patterns ',' positional_patterns
mark = self._mark()
if (
(opt := self._tmp_210(),)
and
(keyword_patterns := self.keyword_patterns())
and
(literal := self.expect(','))
and
(a := self.positional_patterns())
):
return a
self._reset(mark)
return None
@memoize
def invalid_if_stmt(self) -> Optional[Any]:
# invalid_if_stmt: 'if' named_expression NEWLINE | 'if' named_expression ':' NEWLINE !INDENT
mark = self._mark()
if (
(literal := self.expect('if'))
and
(named_expression := self.named_expression())
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "expected ':'" )
self._reset(mark)
if (
(a := self.expect('if'))
and
(a_1 := self.named_expression())
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'if' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_elif_stmt(self) -> Optional[Any]:
# invalid_elif_stmt: 'elif' named_expression NEWLINE | 'elif' named_expression ':' NEWLINE !INDENT
mark = self._mark()
if (
(literal := self.expect('elif'))
and
(named_expression := self.named_expression())
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "expected ':'" )
self._reset(mark)
if (
(a := self.expect('elif'))
and
(named_expression := self.named_expression())
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'elif' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_else_stmt(self) -> Optional[Any]:
# invalid_else_stmt: 'else' ':' NEWLINE !INDENT
mark = self._mark()
if (
(a := self.expect('else'))
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'else' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_while_stmt(self) -> Optional[Any]:
# invalid_while_stmt: 'while' named_expression NEWLINE | 'while' named_expression ':' NEWLINE !INDENT
mark = self._mark()
if (
(literal := self.expect('while'))
and
(named_expression := self.named_expression())
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "expected ':'" )
self._reset(mark)
if (
(a := self.expect('while'))
and
(named_expression := self.named_expression())
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'while' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_for_stmt(self) -> Optional[Any]:
# invalid_for_stmt: ASYNC? 'for' star_targets 'in' star_expressions NEWLINE | ASYNC? 'for' star_targets 'in' star_expressions ':' NEWLINE !INDENT
mark = self._mark()
if (
(opt := self.expect('ASYNC'),)
and
(literal := self.expect('for'))
and
(star_targets := self.star_targets())
and
(literal_1 := self.expect('in'))
and
(star_expressions := self.star_expressions())
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "expected ':'" )
self._reset(mark)
if (
(opt := self.expect('ASYNC'),)
and
(a := self.expect('for'))
and
(star_targets := self.star_targets())
and
(literal := self.expect('in'))
and
(star_expressions := self.star_expressions())
and
(literal_1 := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after 'for' statement on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_def_raw(self) -> Optional[Any]:
# invalid_def_raw: ASYNC? 'def' NAME '(' params? ')' ['->' expression] ':' NEWLINE !INDENT
mark = self._mark()
if (
(opt := self.expect('ASYNC'),)
and
(a := self.expect('def'))
and
(name := self.name())
and
(literal := self.expect('('))
and
(opt_1 := self.params(),)
and
(literal_1 := self.expect(')'))
and
(opt_2 := self._tmp_211(),)
and
(literal_2 := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after function definition on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_class_def_raw(self) -> Optional[Any]:
# invalid_class_def_raw: 'class' NAME ['(' arguments? ')'] NEWLINE | 'class' NAME ['(' arguments? ')'] ':' NEWLINE !INDENT
mark = self._mark()
if (
(literal := self.expect('class'))
and
(name := self.name())
and
(opt := self._tmp_212(),)
and
(_newline := self.expect('NEWLINE'))
):
return RAISE_SYNTAX_ERROR ( "expected ':'" )
self._reset(mark)
if (
(a := self.expect('class'))
and
(name := self.name())
and
(opt := self._tmp_213(),)
and
(literal := self.expect(':'))
and
(_newline := self.expect('NEWLINE'))
and
self.negative_lookahead(self.expect, 'INDENT')
):
return RAISE_INDENTATION_ERROR ( "expected an indented block after class definition on line %d" , a -> lineno )
self._reset(mark)
return None
@memoize
def invalid_double_starred_kvpairs(self) -> Optional[Any]:
# invalid_double_starred_kvpairs: ','.double_starred_kvpair+ ',' invalid_kvpair | expression ':' '*' bitwise_or | expression ':' &('}' | ',')
mark = self._mark()
if (
(_gather_214 := self._gather_214())
and
(literal := self.expect(','))
and
(invalid_kvpair := self.invalid_kvpair())
):
return None # pragma: no cover
self._reset(mark)
if (
(expression := self.expression())
and
(literal := self.expect(':'))
and
(a := self.expect('*'))
and
(bitwise_or := self.bitwise_or())
):
return RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "cannot use a starred expression in a dictionary value" )
self._reset(mark)
if (
(expression := self.expression())
and
(a := self.expect(':'))
and
self.positive_lookahead(self._tmp_216, )
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression expected after dictionary key and ':'" )
self._reset(mark)
return None
@memoize
def invalid_kvpair(self) -> Optional[Any]:
# invalid_kvpair: expression !(':') | expression ':' '*' bitwise_or | expression ':' &('}' | ',')
mark = self._mark()
if (
(a := self.expression())
and
self.negative_lookahead(self.expect, ':')
):
return RAISE_ERROR_KNOWN_LOCATION ( p , PyExc_SyntaxError , a -> lineno , a -> end_col_offset - 1 , a -> end_lineno , - 1 , "':' expected after dictionary key" )
self._reset(mark)
if (
(expression := self.expression())
and
(literal := self.expect(':'))
and
(a := self.expect('*'))
and
(bitwise_or := self.bitwise_or())
):
return RAISE_SYNTAX_ERROR_STARTING_FROM ( a , "cannot use a starred expression in a dictionary value" )
self._reset(mark)
if (
(expression := self.expression())
and
(a := self.expect(':'))
and
self.positive_lookahead(self._tmp_217, )
):
return RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "expression expected after dictionary key and ':'" )
self._reset(mark)
return None
@memoize
def _loop0_1(self) -> Optional[Any]:
# _loop0_1: NEWLINE
mark = self._mark()
children = []
while (
(_newline := self.expect('NEWLINE'))
):
children.append(_newline)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_2(self) -> Optional[Any]:
# _loop0_2: NEWLINE
mark = self._mark()
children = []
while (
(_newline := self.expect('NEWLINE'))
):
children.append(_newline)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_3(self) -> Optional[Any]:
# _loop1_3: statement
mark = self._mark()
children = []
while (
(statement := self.statement())
):
children.append(statement)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_5(self) -> Optional[Any]:
# _loop0_5: ';' simple_stmt
mark = self._mark()
children = []
while (
(literal := self.expect(';'))
and
(elem := self.simple_stmt())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_4(self) -> Optional[Any]:
# _gather_4: simple_stmt _loop0_5
mark = self._mark()
if (
(elem := self.simple_stmt())
is not None
and
(seq := self._loop0_5())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_6(self) -> Optional[Any]:
# _tmp_6: 'import' | 'from'
mark = self._mark()
if (
(literal := self.expect('import'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('from'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_7(self) -> Optional[Any]:
# _tmp_7: 'def' | '@' | ASYNC
mark = self._mark()
if (
(literal := self.expect('def'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('@'))
):
return literal
self._reset(mark)
if (
(_async := self.expect('ASYNC'))
):
return _async
self._reset(mark)
return None
@memoize
def _tmp_8(self) -> Optional[Any]:
# _tmp_8: 'class' | '@'
mark = self._mark()
if (
(literal := self.expect('class'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('@'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_9(self) -> Optional[Any]:
# _tmp_9: 'with' | ASYNC
mark = self._mark()
if (
(literal := self.expect('with'))
):
return literal
self._reset(mark)
if (
(_async := self.expect('ASYNC'))
):
return _async
self._reset(mark)
return None
@memoize
def _tmp_10(self) -> Optional[Any]:
# _tmp_10: 'for' | ASYNC
mark = self._mark()
if (
(literal := self.expect('for'))
):
return literal
self._reset(mark)
if (
(_async := self.expect('ASYNC'))
):
return _async
self._reset(mark)
return None
@memoize
def _tmp_11(self) -> Optional[Any]:
# _tmp_11: '=' annotated_rhs
mark = self._mark()
if (
(literal := self.expect('='))
and
(d := self.annotated_rhs())
):
return d
self._reset(mark)
return None
@memoize
def _tmp_12(self) -> Optional[Any]:
# _tmp_12: '(' single_target ')' | single_subscript_attribute_target
mark = self._mark()
if (
(literal := self.expect('('))
and
(b := self.single_target())
and
(literal_1 := self.expect(')'))
):
return b
self._reset(mark)
if (
(single_subscript_attribute_target := self.single_subscript_attribute_target())
):
return single_subscript_attribute_target
self._reset(mark)
return None
@memoize
def _tmp_13(self) -> Optional[Any]:
# _tmp_13: '=' annotated_rhs
mark = self._mark()
if (
(literal := self.expect('='))
and
(d := self.annotated_rhs())
):
return d
self._reset(mark)
return None
@memoize
def _loop1_14(self) -> Optional[Any]:
# _loop1_14: (star_targets '=')
mark = self._mark()
children = []
while (
(_tmp_218 := self._tmp_218())
):
children.append(_tmp_218)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_15(self) -> Optional[Any]:
# _tmp_15: yield_expr | star_expressions
mark = self._mark()
if (
(yield_expr := self.yield_expr())
):
return yield_expr
self._reset(mark)
if (
(star_expressions := self.star_expressions())
):
return star_expressions
self._reset(mark)
return None
@memoize
def _tmp_16(self) -> Optional[Any]:
# _tmp_16: yield_expr | star_expressions
mark = self._mark()
if (
(yield_expr := self.yield_expr())
):
return yield_expr
self._reset(mark)
if (
(star_expressions := self.star_expressions())
):
return star_expressions
self._reset(mark)
return None
@memoize
def _tmp_17(self) -> Optional[Any]:
# _tmp_17: 'from' expression
mark = self._mark()
if (
(literal := self.expect('from'))
and
(z := self.expression())
):
return z
self._reset(mark)
return None
@memoize
def _loop0_19(self) -> Optional[Any]:
# _loop0_19: ',' NAME
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.name())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_18(self) -> Optional[Any]:
# _gather_18: NAME _loop0_19
mark = self._mark()
if (
(elem := self.name())
is not None
and
(seq := self._loop0_19())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_21(self) -> Optional[Any]:
# _loop0_21: ',' NAME
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.name())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_20(self) -> Optional[Any]:
# _gather_20: NAME _loop0_21
mark = self._mark()
if (
(elem := self.name())
is not None
and
(seq := self._loop0_21())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_22(self) -> Optional[Any]:
# _tmp_22: ';' | NEWLINE
mark = self._mark()
if (
(literal := self.expect(';'))
):
return literal
self._reset(mark)
if (
(_newline := self.expect('NEWLINE'))
):
return _newline
self._reset(mark)
return None
@memoize
def _tmp_23(self) -> Optional[Any]:
# _tmp_23: ',' expression
mark = self._mark()
if (
(literal := self.expect(','))
and
(z := self.expression())
):
return z
self._reset(mark)
return None
@memoize
def _loop0_24(self) -> Optional[Any]:
# _loop0_24: ('.' | '...')
mark = self._mark()
children = []
while (
(_tmp_219 := self._tmp_219())
):
children.append(_tmp_219)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_25(self) -> Optional[Any]:
# _loop1_25: ('.' | '...')
mark = self._mark()
children = []
while (
(_tmp_220 := self._tmp_220())
):
children.append(_tmp_220)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_27(self) -> Optional[Any]:
# _loop0_27: ',' import_from_as_name
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.import_from_as_name())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_26(self) -> Optional[Any]:
# _gather_26: import_from_as_name _loop0_27
mark = self._mark()
if (
(elem := self.import_from_as_name())
is not None
and
(seq := self._loop0_27())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_28(self) -> Optional[Any]:
# _tmp_28: 'as' NAME
mark = self._mark()
if (
(literal := self.expect('as'))
and
(z := self.name())
):
return z
self._reset(mark)
return None
@memoize
def _loop0_30(self) -> Optional[Any]:
# _loop0_30: ',' dotted_as_name
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.dotted_as_name())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_29(self) -> Optional[Any]:
# _gather_29: dotted_as_name _loop0_30
mark = self._mark()
if (
(elem := self.dotted_as_name())
is not None
and
(seq := self._loop0_30())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_31(self) -> Optional[Any]:
# _tmp_31: 'as' NAME
mark = self._mark()
if (
(literal := self.expect('as'))
and
(z := self.name())
):
return z
self._reset(mark)
return None
@memoize
def _loop1_32(self) -> Optional[Any]:
# _loop1_32: ('@' named_expression NEWLINE)
mark = self._mark()
children = []
while (
(_tmp_221 := self._tmp_221())
):
children.append(_tmp_221)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_33(self) -> Optional[Any]:
# _tmp_33: '(' arguments? ')'
mark = self._mark()
if (
(literal := self.expect('('))
and
(z := self.arguments(),)
and
(literal_1 := self.expect(')'))
):
return z
self._reset(mark)
return None
@memoize
def _tmp_34(self) -> Optional[Any]:
# _tmp_34: '->' expression
mark = self._mark()
if (
(literal := self.expect('->'))
and
(z := self.expression())
):
return z
self._reset(mark)
return None
@memoize
def _tmp_35(self) -> Optional[Any]:
# _tmp_35: '->' expression
mark = self._mark()
if (
(literal := self.expect('->'))
and
(z := self.expression())
):
return z
self._reset(mark)
return None
@memoize
def _loop0_36(self) -> Optional[Any]:
# _loop0_36: param_no_default
mark = self._mark()
children = []
while (
(param_no_default := self.param_no_default())
):
children.append(param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_37(self) -> Optional[Any]:
# _loop0_37: param_with_default
mark = self._mark()
children = []
while (
(param_with_default := self.param_with_default())
):
children.append(param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_38(self) -> Optional[Any]:
# _loop0_38: param_with_default
mark = self._mark()
children = []
while (
(param_with_default := self.param_with_default())
):
children.append(param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_39(self) -> Optional[Any]:
# _loop1_39: param_no_default
mark = self._mark()
children = []
while (
(param_no_default := self.param_no_default())
):
children.append(param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_40(self) -> Optional[Any]:
# _loop0_40: param_with_default
mark = self._mark()
children = []
while (
(param_with_default := self.param_with_default())
):
children.append(param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_41(self) -> Optional[Any]:
# _loop1_41: param_with_default
mark = self._mark()
children = []
while (
(param_with_default := self.param_with_default())
):
children.append(param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_42(self) -> Optional[Any]:
# _loop1_42: param_no_default
mark = self._mark()
children = []
while (
(param_no_default := self.param_no_default())
):
children.append(param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_43(self) -> Optional[Any]:
# _loop1_43: param_no_default
mark = self._mark()
children = []
while (
(param_no_default := self.param_no_default())
):
children.append(param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_44(self) -> Optional[Any]:
# _loop0_44: param_no_default
mark = self._mark()
children = []
while (
(param_no_default := self.param_no_default())
):
children.append(param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_45(self) -> Optional[Any]:
# _loop1_45: param_with_default
mark = self._mark()
children = []
while (
(param_with_default := self.param_with_default())
):
children.append(param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_46(self) -> Optional[Any]:
# _loop0_46: param_no_default
mark = self._mark()
children = []
while (
(param_no_default := self.param_no_default())
):
children.append(param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_47(self) -> Optional[Any]:
# _loop1_47: param_with_default
mark = self._mark()
children = []
while (
(param_with_default := self.param_with_default())
):
children.append(param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_48(self) -> Optional[Any]:
# _loop0_48: param_maybe_default
mark = self._mark()
children = []
while (
(param_maybe_default := self.param_maybe_default())
):
children.append(param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_49(self) -> Optional[Any]:
# _loop0_49: param_maybe_default
mark = self._mark()
children = []
while (
(param_maybe_default := self.param_maybe_default())
):
children.append(param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_50(self) -> Optional[Any]:
# _loop1_50: param_maybe_default
mark = self._mark()
children = []
while (
(param_maybe_default := self.param_maybe_default())
):
children.append(param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_52(self) -> Optional[Any]:
# _loop0_52: ',' with_item
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.with_item())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_51(self) -> Optional[Any]:
# _gather_51: with_item _loop0_52
mark = self._mark()
if (
(elem := self.with_item())
is not None
and
(seq := self._loop0_52())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_54(self) -> Optional[Any]:
# _loop0_54: ',' with_item
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.with_item())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_53(self) -> Optional[Any]:
# _gather_53: with_item _loop0_54
mark = self._mark()
if (
(elem := self.with_item())
is not None
and
(seq := self._loop0_54())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_56(self) -> Optional[Any]:
# _loop0_56: ',' with_item
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.with_item())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_55(self) -> Optional[Any]:
# _gather_55: with_item _loop0_56
mark = self._mark()
if (
(elem := self.with_item())
is not None
and
(seq := self._loop0_56())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_58(self) -> Optional[Any]:
# _loop0_58: ',' with_item
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.with_item())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_57(self) -> Optional[Any]:
# _gather_57: with_item _loop0_58
mark = self._mark()
if (
(elem := self.with_item())
is not None
and
(seq := self._loop0_58())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_59(self) -> Optional[Any]:
# _tmp_59: ',' | ')' | ':'
mark = self._mark()
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
if (
(literal := self.expect(')'))
):
return literal
self._reset(mark)
if (
(literal := self.expect(':'))
):
return literal
self._reset(mark)
return None
@memoize
def _loop1_60(self) -> Optional[Any]:
# _loop1_60: except_block
mark = self._mark()
children = []
while (
(except_block := self.except_block())
):
children.append(except_block)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_61(self) -> Optional[Any]:
# _loop1_61: except_star_block
mark = self._mark()
children = []
while (
(except_star_block := self.except_star_block())
):
children.append(except_star_block)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_62(self) -> Optional[Any]:
# _tmp_62: 'as' NAME
mark = self._mark()
if (
(literal := self.expect('as'))
and
(z := self.name())
):
return z
self._reset(mark)
return None
@memoize
def _tmp_63(self) -> Optional[Any]:
# _tmp_63: 'as' NAME
mark = self._mark()
if (
(literal := self.expect('as'))
and
(z := self.name())
):
return z
self._reset(mark)
return None
@memoize
def _loop1_64(self) -> Optional[Any]:
# _loop1_64: case_block
mark = self._mark()
children = []
while (
(case_block := self.case_block())
):
children.append(case_block)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_66(self) -> Optional[Any]:
# _loop0_66: '|' closed_pattern
mark = self._mark()
children = []
while (
(literal := self.expect('|'))
and
(elem := self.closed_pattern())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_65(self) -> Optional[Any]:
# _gather_65: closed_pattern _loop0_66
mark = self._mark()
if (
(elem := self.closed_pattern())
is not None
and
(seq := self._loop0_66())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_67(self) -> Optional[Any]:
# _tmp_67: '+' | '-'
mark = self._mark()
if (
(literal := self.expect('+'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('-'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_68(self) -> Optional[Any]:
# _tmp_68: '+' | '-'
mark = self._mark()
if (
(literal := self.expect('+'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('-'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_69(self) -> Optional[Any]:
# _tmp_69: '.' | '(' | '='
mark = self._mark()
if (
(literal := self.expect('.'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('('))
):
return literal
self._reset(mark)
if (
(literal := self.expect('='))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_70(self) -> Optional[Any]:
# _tmp_70: '.' | '(' | '='
mark = self._mark()
if (
(literal := self.expect('.'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('('))
):
return literal
self._reset(mark)
if (
(literal := self.expect('='))
):
return literal
self._reset(mark)
return None
@memoize
def _loop0_72(self) -> Optional[Any]:
# _loop0_72: ',' maybe_star_pattern
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.maybe_star_pattern())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_71(self) -> Optional[Any]:
# _gather_71: maybe_star_pattern _loop0_72
mark = self._mark()
if (
(elem := self.maybe_star_pattern())
is not None
and
(seq := self._loop0_72())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_74(self) -> Optional[Any]:
# _loop0_74: ',' key_value_pattern
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.key_value_pattern())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_73(self) -> Optional[Any]:
# _gather_73: key_value_pattern _loop0_74
mark = self._mark()
if (
(elem := self.key_value_pattern())
is not None
and
(seq := self._loop0_74())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_75(self) -> Optional[Any]:
# _tmp_75: literal_expr | attr
mark = self._mark()
if (
(literal_expr := self.literal_expr())
):
return literal_expr
self._reset(mark)
if (
(attr := self.attr())
):
return attr
self._reset(mark)
return None
@memoize
def _loop0_77(self) -> Optional[Any]:
# _loop0_77: ',' pattern
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.pattern())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_76(self) -> Optional[Any]:
# _gather_76: pattern _loop0_77
mark = self._mark()
if (
(elem := self.pattern())
is not None
and
(seq := self._loop0_77())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_79(self) -> Optional[Any]:
# _loop0_79: ',' keyword_pattern
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.keyword_pattern())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_78(self) -> Optional[Any]:
# _gather_78: keyword_pattern _loop0_79
mark = self._mark()
if (
(elem := self.keyword_pattern())
is not None
and
(seq := self._loop0_79())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop1_80(self) -> Optional[Any]:
# _loop1_80: (',' expression)
mark = self._mark()
children = []
while (
(_tmp_222 := self._tmp_222())
):
children.append(_tmp_222)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_81(self) -> Optional[Any]:
# _loop1_81: (',' star_expression)
mark = self._mark()
children = []
while (
(_tmp_223 := self._tmp_223())
):
children.append(_tmp_223)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_83(self) -> Optional[Any]:
# _loop0_83: ',' star_named_expression
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.star_named_expression())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_82(self) -> Optional[Any]:
# _gather_82: star_named_expression _loop0_83
mark = self._mark()
if (
(elem := self.star_named_expression())
is not None
and
(seq := self._loop0_83())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop1_84(self) -> Optional[Any]:
# _loop1_84: ('or' conjunction)
mark = self._mark()
children = []
while (
(_tmp_224 := self._tmp_224())
):
children.append(_tmp_224)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_85(self) -> Optional[Any]:
# _loop1_85: ('and' inversion)
mark = self._mark()
children = []
while (
(_tmp_225 := self._tmp_225())
):
children.append(_tmp_225)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_86(self) -> Optional[Any]:
# _loop1_86: compare_op_bitwise_or_pair
mark = self._mark()
children = []
while (
(compare_op_bitwise_or_pair := self.compare_op_bitwise_or_pair())
):
children.append(compare_op_bitwise_or_pair)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_88(self) -> Optional[Any]:
# _loop0_88: ',' (slice | starred_expression)
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self._tmp_226())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_87(self) -> Optional[Any]:
# _gather_87: (slice | starred_expression) _loop0_88
mark = self._mark()
if (
(elem := self._tmp_226())
is not None
and
(seq := self._loop0_88())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_89(self) -> Optional[Any]:
# _tmp_89: ':' expression?
mark = self._mark()
if (
(literal := self.expect(':'))
and
(d := self.expression(),)
):
return d
self._reset(mark)
return None
@memoize
def _tmp_90(self) -> Optional[Any]:
# _tmp_90: tuple | group | genexp
mark = self._mark()
if (
(tuple := self.tuple())
):
return tuple
self._reset(mark)
if (
(group := self.group())
):
return group
self._reset(mark)
if (
(genexp := self.genexp())
):
return genexp
self._reset(mark)
return None
@memoize
def _tmp_91(self) -> Optional[Any]:
# _tmp_91: list | listcomp
mark = self._mark()
if (
(list := self.list())
):
return list
self._reset(mark)
if (
(listcomp := self.listcomp())
):
return listcomp
self._reset(mark)
return None
@memoize
def _tmp_92(self) -> Optional[Any]:
# _tmp_92: dict | set | dictcomp | setcomp
mark = self._mark()
if (
(dict := self.dict())
):
return dict
self._reset(mark)
if (
(set := self.set())
):
return set
self._reset(mark)
if (
(dictcomp := self.dictcomp())
):
return dictcomp
self._reset(mark)
if (
(setcomp := self.setcomp())
):
return setcomp
self._reset(mark)
return None
@memoize
def _tmp_93(self) -> Optional[Any]:
# _tmp_93: yield_expr | named_expression
mark = self._mark()
if (
(yield_expr := self.yield_expr())
):
return yield_expr
self._reset(mark)
if (
(named_expression := self.named_expression())
):
return named_expression
self._reset(mark)
return None
@memoize
def _loop0_94(self) -> Optional[Any]:
# _loop0_94: lambda_param_no_default
mark = self._mark()
children = []
while (
(lambda_param_no_default := self.lambda_param_no_default())
):
children.append(lambda_param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_95(self) -> Optional[Any]:
# _loop0_95: lambda_param_with_default
mark = self._mark()
children = []
while (
(lambda_param_with_default := self.lambda_param_with_default())
):
children.append(lambda_param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_96(self) -> Optional[Any]:
# _loop0_96: lambda_param_with_default
mark = self._mark()
children = []
while (
(lambda_param_with_default := self.lambda_param_with_default())
):
children.append(lambda_param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_97(self) -> Optional[Any]:
# _loop1_97: lambda_param_no_default
mark = self._mark()
children = []
while (
(lambda_param_no_default := self.lambda_param_no_default())
):
children.append(lambda_param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_98(self) -> Optional[Any]:
# _loop0_98: lambda_param_with_default
mark = self._mark()
children = []
while (
(lambda_param_with_default := self.lambda_param_with_default())
):
children.append(lambda_param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_99(self) -> Optional[Any]:
# _loop1_99: lambda_param_with_default
mark = self._mark()
children = []
while (
(lambda_param_with_default := self.lambda_param_with_default())
):
children.append(lambda_param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_100(self) -> Optional[Any]:
# _loop1_100: lambda_param_no_default
mark = self._mark()
children = []
while (
(lambda_param_no_default := self.lambda_param_no_default())
):
children.append(lambda_param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_101(self) -> Optional[Any]:
# _loop1_101: lambda_param_no_default
mark = self._mark()
children = []
while (
(lambda_param_no_default := self.lambda_param_no_default())
):
children.append(lambda_param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_102(self) -> Optional[Any]:
# _loop0_102: lambda_param_no_default
mark = self._mark()
children = []
while (
(lambda_param_no_default := self.lambda_param_no_default())
):
children.append(lambda_param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_103(self) -> Optional[Any]:
# _loop1_103: lambda_param_with_default
mark = self._mark()
children = []
while (
(lambda_param_with_default := self.lambda_param_with_default())
):
children.append(lambda_param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_104(self) -> Optional[Any]:
# _loop0_104: lambda_param_no_default
mark = self._mark()
children = []
while (
(lambda_param_no_default := self.lambda_param_no_default())
):
children.append(lambda_param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_105(self) -> Optional[Any]:
# _loop1_105: lambda_param_with_default
mark = self._mark()
children = []
while (
(lambda_param_with_default := self.lambda_param_with_default())
):
children.append(lambda_param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_106(self) -> Optional[Any]:
# _loop0_106: lambda_param_maybe_default
mark = self._mark()
children = []
while (
(lambda_param_maybe_default := self.lambda_param_maybe_default())
):
children.append(lambda_param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_107(self) -> Optional[Any]:
# _loop1_107: lambda_param_maybe_default
mark = self._mark()
children = []
while (
(lambda_param_maybe_default := self.lambda_param_maybe_default())
):
children.append(lambda_param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_108(self) -> Optional[Any]:
# _loop1_108: STRING
mark = self._mark()
children = []
while (
(string := self.string())
):
children.append(string)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_109(self) -> Optional[Any]:
# _tmp_109: star_named_expression ',' star_named_expressions?
mark = self._mark()
if (
(y := self.star_named_expression())
and
(literal := self.expect(','))
and
(z := self.star_named_expressions(),)
):
return _PyPegen_seq_insert_in_front ( p , y , z )
self._reset(mark)
return None
@memoize
def _loop0_111(self) -> Optional[Any]:
# _loop0_111: ',' double_starred_kvpair
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.double_starred_kvpair())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_110(self) -> Optional[Any]:
# _gather_110: double_starred_kvpair _loop0_111
mark = self._mark()
if (
(elem := self.double_starred_kvpair())
is not None
and
(seq := self._loop0_111())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop1_112(self) -> Optional[Any]:
# _loop1_112: for_if_clause
mark = self._mark()
children = []
while (
(for_if_clause := self.for_if_clause())
):
children.append(for_if_clause)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_113(self) -> Optional[Any]:
# _loop0_113: ('if' disjunction)
mark = self._mark()
children = []
while (
(_tmp_227 := self._tmp_227())
):
children.append(_tmp_227)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_114(self) -> Optional[Any]:
# _loop0_114: ('if' disjunction)
mark = self._mark()
children = []
while (
(_tmp_228 := self._tmp_228())
):
children.append(_tmp_228)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_115(self) -> Optional[Any]:
# _tmp_115: assignment_expression | expression !':='
mark = self._mark()
if (
(assignment_expression := self.assignment_expression())
):
return assignment_expression
self._reset(mark)
if (
(expression := self.expression())
and
self.negative_lookahead(self.expect, ':=')
):
return expression
self._reset(mark)
return None
@memoize
def _loop0_117(self) -> Optional[Any]:
# _loop0_117: ',' (starred_expression | (assignment_expression | expression !':=') !'=')
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self._tmp_229())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_116(self) -> Optional[Any]:
# _gather_116: (starred_expression | (assignment_expression | expression !':=') !'=') _loop0_117
mark = self._mark()
if (
(elem := self._tmp_229())
is not None
and
(seq := self._loop0_117())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_118(self) -> Optional[Any]:
# _tmp_118: ',' kwargs
mark = self._mark()
if (
(literal := self.expect(','))
and
(k := self.kwargs())
):
return k
self._reset(mark)
return None
@memoize
def _loop0_120(self) -> Optional[Any]:
# _loop0_120: ',' kwarg_or_starred
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.kwarg_or_starred())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_119(self) -> Optional[Any]:
# _gather_119: kwarg_or_starred _loop0_120
mark = self._mark()
if (
(elem := self.kwarg_or_starred())
is not None
and
(seq := self._loop0_120())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_122(self) -> Optional[Any]:
# _loop0_122: ',' kwarg_or_double_starred
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.kwarg_or_double_starred())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_121(self) -> Optional[Any]:
# _gather_121: kwarg_or_double_starred _loop0_122
mark = self._mark()
if (
(elem := self.kwarg_or_double_starred())
is not None
and
(seq := self._loop0_122())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_124(self) -> Optional[Any]:
# _loop0_124: ',' kwarg_or_starred
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.kwarg_or_starred())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_123(self) -> Optional[Any]:
# _gather_123: kwarg_or_starred _loop0_124
mark = self._mark()
if (
(elem := self.kwarg_or_starred())
is not None
and
(seq := self._loop0_124())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_126(self) -> Optional[Any]:
# _loop0_126: ',' kwarg_or_double_starred
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.kwarg_or_double_starred())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_125(self) -> Optional[Any]:
# _gather_125: kwarg_or_double_starred _loop0_126
mark = self._mark()
if (
(elem := self.kwarg_or_double_starred())
is not None
and
(seq := self._loop0_126())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_127(self) -> Optional[Any]:
# _loop0_127: (',' star_target)
mark = self._mark()
children = []
while (
(_tmp_230 := self._tmp_230())
):
children.append(_tmp_230)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_129(self) -> Optional[Any]:
# _loop0_129: ',' star_target
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.star_target())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_128(self) -> Optional[Any]:
# _gather_128: star_target _loop0_129
mark = self._mark()
if (
(elem := self.star_target())
is not None
and
(seq := self._loop0_129())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop1_130(self) -> Optional[Any]:
# _loop1_130: (',' star_target)
mark = self._mark()
children = []
while (
(_tmp_231 := self._tmp_231())
):
children.append(_tmp_231)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_131(self) -> Optional[Any]:
# _tmp_131: !'*' star_target
mark = self._mark()
if (
self.negative_lookahead(self.expect, '*')
and
(star_target := self.star_target())
):
return star_target
self._reset(mark)
return None
@memoize
def _loop0_133(self) -> Optional[Any]:
# _loop0_133: ',' del_target
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.del_target())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_132(self) -> Optional[Any]:
# _gather_132: del_target _loop0_133
mark = self._mark()
if (
(elem := self.del_target())
is not None
and
(seq := self._loop0_133())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_135(self) -> Optional[Any]:
# _loop0_135: ',' expression
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.expression())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_134(self) -> Optional[Any]:
# _gather_134: expression _loop0_135
mark = self._mark()
if (
(elem := self.expression())
is not None
and
(seq := self._loop0_135())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_137(self) -> Optional[Any]:
# _loop0_137: ',' expression
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.expression())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_136(self) -> Optional[Any]:
# _gather_136: expression _loop0_137
mark = self._mark()
if (
(elem := self.expression())
is not None
and
(seq := self._loop0_137())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_139(self) -> Optional[Any]:
# _loop0_139: ',' expression
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.expression())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_138(self) -> Optional[Any]:
# _gather_138: expression _loop0_139
mark = self._mark()
if (
(elem := self.expression())
is not None
and
(seq := self._loop0_139())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_141(self) -> Optional[Any]:
# _loop0_141: ',' expression
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.expression())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_140(self) -> Optional[Any]:
# _gather_140: expression _loop0_141
mark = self._mark()
if (
(elem := self.expression())
is not None
and
(seq := self._loop0_141())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_142(self) -> Optional[Any]:
# _tmp_142: NEWLINE INDENT
mark = self._mark()
if (
(_newline := self.expect('NEWLINE'))
and
(_indent := self.expect('INDENT'))
):
return [_newline, _indent]
self._reset(mark)
return None
@memoize
def _tmp_143(self) -> Optional[Any]:
# _tmp_143: args | expression for_if_clauses
mark = self._mark()
if (
(args := self.args())
):
return args
self._reset(mark)
if (
(expression := self.expression())
and
(for_if_clauses := self.for_if_clauses())
):
return [expression, for_if_clauses]
self._reset(mark)
return None
@memoize
def _tmp_144(self) -> Optional[Any]:
# _tmp_144: 'True' | 'False' | 'None'
mark = self._mark()
if (
(literal := self.expect('True'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('False'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('None'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_145(self) -> Optional[Any]:
# _tmp_145: NAME '='
mark = self._mark()
if (
(name := self.name())
and
(literal := self.expect('='))
):
return [name, literal]
self._reset(mark)
return None
@memoize
def _tmp_146(self) -> Optional[Any]:
# _tmp_146: NAME STRING | SOFT_KEYWORD
mark = self._mark()
if (
(name := self.name())
and
(string := self.string())
):
return [name, string]
self._reset(mark)
if (
(soft_keyword := self.soft_keyword())
):
return soft_keyword
self._reset(mark)
return None
@memoize
def _tmp_147(self) -> Optional[Any]:
# _tmp_147: 'else' | ':'
mark = self._mark()
if (
(literal := self.expect('else'))
):
return literal
self._reset(mark)
if (
(literal := self.expect(':'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_148(self) -> Optional[Any]:
# _tmp_148: '=' | ':='
mark = self._mark()
if (
(literal := self.expect('='))
):
return literal
self._reset(mark)
if (
(literal := self.expect(':='))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_149(self) -> Optional[Any]:
# _tmp_149: list | tuple | genexp | 'True' | 'None' | 'False'
mark = self._mark()
if (
(list := self.list())
):
return list
self._reset(mark)
if (
(tuple := self.tuple())
):
return tuple
self._reset(mark)
if (
(genexp := self.genexp())
):
return genexp
self._reset(mark)
if (
(literal := self.expect('True'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('None'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('False'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_150(self) -> Optional[Any]:
# _tmp_150: '=' | ':='
mark = self._mark()
if (
(literal := self.expect('='))
):
return literal
self._reset(mark)
if (
(literal := self.expect(':='))
):
return literal
self._reset(mark)
return None
@memoize
def _loop0_151(self) -> Optional[Any]:
# _loop0_151: star_named_expressions
mark = self._mark()
children = []
while (
(star_named_expressions := self.star_named_expressions())
):
children.append(star_named_expressions)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_152(self) -> Optional[Any]:
# _loop0_152: (star_targets '=')
mark = self._mark()
children = []
while (
(_tmp_232 := self._tmp_232())
):
children.append(_tmp_232)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_153(self) -> Optional[Any]:
# _loop0_153: (star_targets '=')
mark = self._mark()
children = []
while (
(_tmp_233 := self._tmp_233())
):
children.append(_tmp_233)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_154(self) -> Optional[Any]:
# _tmp_154: yield_expr | star_expressions
mark = self._mark()
if (
(yield_expr := self.yield_expr())
):
return yield_expr
self._reset(mark)
if (
(star_expressions := self.star_expressions())
):
return star_expressions
self._reset(mark)
return None
@memoize
def _tmp_155(self) -> Optional[Any]:
# _tmp_155: '[' | '(' | '{'
mark = self._mark()
if (
(literal := self.expect('['))
):
return literal
self._reset(mark)
if (
(literal := self.expect('('))
):
return literal
self._reset(mark)
if (
(literal := self.expect('{'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_156(self) -> Optional[Any]:
# _tmp_156: '[' | '{'
mark = self._mark()
if (
(literal := self.expect('['))
):
return literal
self._reset(mark)
if (
(literal := self.expect('{'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_157(self) -> Optional[Any]:
# _tmp_157: '[' | '{'
mark = self._mark()
if (
(literal := self.expect('['))
):
return literal
self._reset(mark)
if (
(literal := self.expect('{'))
):
return literal
self._reset(mark)
return None
@memoize
def _loop0_158(self) -> Optional[Any]:
# _loop0_158: param_no_default
mark = self._mark()
children = []
while (
(param_no_default := self.param_no_default())
):
children.append(param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_159(self) -> Optional[Any]:
# _loop0_159: param_no_default
mark = self._mark()
children = []
while (
(param_no_default := self.param_no_default())
):
children.append(param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_160(self) -> Optional[Any]:
# _loop1_160: param_no_default
mark = self._mark()
children = []
while (
(param_no_default := self.param_no_default())
):
children.append(param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_161(self) -> Optional[Any]:
# _tmp_161: slash_no_default | slash_with_default
mark = self._mark()
if (
(slash_no_default := self.slash_no_default())
):
return slash_no_default
self._reset(mark)
if (
(slash_with_default := self.slash_with_default())
):
return slash_with_default
self._reset(mark)
return None
@memoize
def _loop0_162(self) -> Optional[Any]:
# _loop0_162: param_maybe_default
mark = self._mark()
children = []
while (
(param_maybe_default := self.param_maybe_default())
):
children.append(param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_163(self) -> Optional[Any]:
# _tmp_163: slash_no_default | slash_with_default
mark = self._mark()
if (
(slash_no_default := self.slash_no_default())
):
return slash_no_default
self._reset(mark)
if (
(slash_with_default := self.slash_with_default())
):
return slash_with_default
self._reset(mark)
return None
@memoize
def _loop0_164(self) -> Optional[Any]:
# _loop0_164: param_maybe_default
mark = self._mark()
children = []
while (
(param_maybe_default := self.param_maybe_default())
):
children.append(param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_165(self) -> Optional[Any]:
# _tmp_165: ',' | param_no_default
mark = self._mark()
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
if (
(param_no_default := self.param_no_default())
):
return param_no_default
self._reset(mark)
return None
@memoize
def _loop0_166(self) -> Optional[Any]:
# _loop0_166: param_maybe_default
mark = self._mark()
children = []
while (
(param_maybe_default := self.param_maybe_default())
):
children.append(param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_167(self) -> Optional[Any]:
# _loop1_167: param_maybe_default
mark = self._mark()
children = []
while (
(param_maybe_default := self.param_maybe_default())
):
children.append(param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_168(self) -> Optional[Any]:
# _tmp_168: ')' | ','
mark = self._mark()
if (
(literal := self.expect(')'))
):
return literal
self._reset(mark)
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_169(self) -> Optional[Any]:
# _tmp_169: ')' | ',' (')' | '**')
mark = self._mark()
if (
(literal := self.expect(')'))
):
return literal
self._reset(mark)
if (
(literal := self.expect(','))
and
(_tmp_234 := self._tmp_234())
):
return [literal, _tmp_234]
self._reset(mark)
return None
@memoize
def _tmp_170(self) -> Optional[Any]:
# _tmp_170: param_no_default | ','
mark = self._mark()
if (
(param_no_default := self.param_no_default())
):
return param_no_default
self._reset(mark)
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
return None
@memoize
def _loop0_171(self) -> Optional[Any]:
# _loop0_171: param_maybe_default
mark = self._mark()
children = []
while (
(param_maybe_default := self.param_maybe_default())
):
children.append(param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_172(self) -> Optional[Any]:
# _tmp_172: param_no_default | ','
mark = self._mark()
if (
(param_no_default := self.param_no_default())
):
return param_no_default
self._reset(mark)
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_173(self) -> Optional[Any]:
# _tmp_173: '*' | '**' | '/'
mark = self._mark()
if (
(literal := self.expect('*'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('**'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('/'))
):
return literal
self._reset(mark)
return None
@memoize
def _loop1_174(self) -> Optional[Any]:
# _loop1_174: param_with_default
mark = self._mark()
children = []
while (
(param_with_default := self.param_with_default())
):
children.append(param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_175(self) -> Optional[Any]:
# _loop0_175: lambda_param_no_default
mark = self._mark()
children = []
while (
(lambda_param_no_default := self.lambda_param_no_default())
):
children.append(lambda_param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_176(self) -> Optional[Any]:
# _loop0_176: lambda_param_no_default
mark = self._mark()
children = []
while (
(lambda_param_no_default := self.lambda_param_no_default())
):
children.append(lambda_param_no_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop0_178(self) -> Optional[Any]:
# _loop0_178: ',' lambda_param
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.lambda_param())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_177(self) -> Optional[Any]:
# _gather_177: lambda_param _loop0_178
mark = self._mark()
if (
(elem := self.lambda_param())
is not None
and
(seq := self._loop0_178())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_179(self) -> Optional[Any]:
# _tmp_179: lambda_slash_no_default | lambda_slash_with_default
mark = self._mark()
if (
(lambda_slash_no_default := self.lambda_slash_no_default())
):
return lambda_slash_no_default
self._reset(mark)
if (
(lambda_slash_with_default := self.lambda_slash_with_default())
):
return lambda_slash_with_default
self._reset(mark)
return None
@memoize
def _loop0_180(self) -> Optional[Any]:
# _loop0_180: lambda_param_maybe_default
mark = self._mark()
children = []
while (
(lambda_param_maybe_default := self.lambda_param_maybe_default())
):
children.append(lambda_param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_181(self) -> Optional[Any]:
# _tmp_181: lambda_slash_no_default | lambda_slash_with_default
mark = self._mark()
if (
(lambda_slash_no_default := self.lambda_slash_no_default())
):
return lambda_slash_no_default
self._reset(mark)
if (
(lambda_slash_with_default := self.lambda_slash_with_default())
):
return lambda_slash_with_default
self._reset(mark)
return None
@memoize
def _loop0_182(self) -> Optional[Any]:
# _loop0_182: lambda_param_maybe_default
mark = self._mark()
children = []
while (
(lambda_param_maybe_default := self.lambda_param_maybe_default())
):
children.append(lambda_param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_183(self) -> Optional[Any]:
# _tmp_183: ',' | lambda_param_no_default
mark = self._mark()
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
if (
(lambda_param_no_default := self.lambda_param_no_default())
):
return lambda_param_no_default
self._reset(mark)
return None
@memoize
def _loop0_184(self) -> Optional[Any]:
# _loop0_184: lambda_param_maybe_default
mark = self._mark()
children = []
while (
(lambda_param_maybe_default := self.lambda_param_maybe_default())
):
children.append(lambda_param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_185(self) -> Optional[Any]:
# _loop1_185: lambda_param_maybe_default
mark = self._mark()
children = []
while (
(lambda_param_maybe_default := self.lambda_param_maybe_default())
):
children.append(lambda_param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_186(self) -> Optional[Any]:
# _loop1_186: lambda_param_with_default
mark = self._mark()
children = []
while (
(lambda_param_with_default := self.lambda_param_with_default())
):
children.append(lambda_param_with_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_187(self) -> Optional[Any]:
# _tmp_187: ':' | ',' (':' | '**')
mark = self._mark()
if (
(literal := self.expect(':'))
):
return literal
self._reset(mark)
if (
(literal := self.expect(','))
and
(_tmp_235 := self._tmp_235())
):
return [literal, _tmp_235]
self._reset(mark)
return None
@memoize
def _tmp_188(self) -> Optional[Any]:
# _tmp_188: lambda_param_no_default | ','
mark = self._mark()
if (
(lambda_param_no_default := self.lambda_param_no_default())
):
return lambda_param_no_default
self._reset(mark)
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
return None
@memoize
def _loop0_189(self) -> Optional[Any]:
# _loop0_189: lambda_param_maybe_default
mark = self._mark()
children = []
while (
(lambda_param_maybe_default := self.lambda_param_maybe_default())
):
children.append(lambda_param_maybe_default)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_190(self) -> Optional[Any]:
# _tmp_190: lambda_param_no_default | ','
mark = self._mark()
if (
(lambda_param_no_default := self.lambda_param_no_default())
):
return lambda_param_no_default
self._reset(mark)
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_191(self) -> Optional[Any]:
# _tmp_191: '*' | '**' | '/'
mark = self._mark()
if (
(literal := self.expect('*'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('**'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('/'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_192(self) -> Optional[Any]:
# _tmp_192: ',' | ')' | ':'
mark = self._mark()
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
if (
(literal := self.expect(')'))
):
return literal
self._reset(mark)
if (
(literal := self.expect(':'))
):
return literal
self._reset(mark)
return None
@memoize
def _loop0_194(self) -> Optional[Any]:
# _loop0_194: ',' (expression ['as' star_target])
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self._tmp_236())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_193(self) -> Optional[Any]:
# _gather_193: (expression ['as' star_target]) _loop0_194
mark = self._mark()
if (
(elem := self._tmp_236())
is not None
and
(seq := self._loop0_194())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_196(self) -> Optional[Any]:
# _loop0_196: ',' (expressions ['as' star_target])
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self._tmp_237())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_195(self) -> Optional[Any]:
# _gather_195: (expressions ['as' star_target]) _loop0_196
mark = self._mark()
if (
(elem := self._tmp_237())
is not None
and
(seq := self._loop0_196())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_198(self) -> Optional[Any]:
# _loop0_198: ',' (expression ['as' star_target])
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self._tmp_238())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_197(self) -> Optional[Any]:
# _gather_197: (expression ['as' star_target]) _loop0_198
mark = self._mark()
if (
(elem := self._tmp_238())
is not None
and
(seq := self._loop0_198())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _loop0_200(self) -> Optional[Any]:
# _loop0_200: ',' (expressions ['as' star_target])
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self._tmp_239())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_199(self) -> Optional[Any]:
# _gather_199: (expressions ['as' star_target]) _loop0_200
mark = self._mark()
if (
(elem := self._tmp_239())
is not None
and
(seq := self._loop0_200())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_201(self) -> Optional[Any]:
# _tmp_201: 'except' | 'finally'
mark = self._mark()
if (
(literal := self.expect('except'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('finally'))
):
return literal
self._reset(mark)
return None
@memoize
def _loop0_202(self) -> Optional[Any]:
# _loop0_202: block
mark = self._mark()
children = []
while (
(block := self.block())
):
children.append(block)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_203(self) -> Optional[Any]:
# _tmp_203: (except_block+ except_star_block) | (except_star_block+ except_block)
mark = self._mark()
if (
(_tmp_240 := self._tmp_240())
):
return _tmp_240
self._reset(mark)
if (
(_tmp_241 := self._tmp_241())
):
return _tmp_241
self._reset(mark)
return None
@memoize
def _loop0_204(self) -> Optional[Any]:
# _loop0_204: block
mark = self._mark()
children = []
while (
(block := self.block())
):
children.append(block)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _tmp_205(self) -> Optional[Any]:
# _tmp_205: 'as' NAME
mark = self._mark()
if (
(literal := self.expect('as'))
and
(name := self.name())
):
return [literal, name]
self._reset(mark)
return None
@memoize
def _tmp_206(self) -> Optional[Any]:
# _tmp_206: 'as' NAME
mark = self._mark()
if (
(literal := self.expect('as'))
and
(name := self.name())
):
return [literal, name]
self._reset(mark)
return None
@memoize
def _tmp_207(self) -> Optional[Any]:
# _tmp_207: NEWLINE | ':'
mark = self._mark()
if (
(_newline := self.expect('NEWLINE'))
):
return _newline
self._reset(mark)
if (
(literal := self.expect(':'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_208(self) -> Optional[Any]:
# _tmp_208: 'as' NAME
mark = self._mark()
if (
(literal := self.expect('as'))
and
(name := self.name())
):
return [literal, name]
self._reset(mark)
return None
@memoize
def _tmp_209(self) -> Optional[Any]:
# _tmp_209: 'as' NAME
mark = self._mark()
if (
(literal := self.expect('as'))
and
(name := self.name())
):
return [literal, name]
self._reset(mark)
return None
@memoize
def _tmp_210(self) -> Optional[Any]:
# _tmp_210: positional_patterns ','
mark = self._mark()
if (
(positional_patterns := self.positional_patterns())
and
(literal := self.expect(','))
):
return [positional_patterns, literal]
self._reset(mark)
return None
@memoize
def _tmp_211(self) -> Optional[Any]:
# _tmp_211: '->' expression
mark = self._mark()
if (
(literal := self.expect('->'))
and
(expression := self.expression())
):
return [literal, expression]
self._reset(mark)
return None
@memoize
def _tmp_212(self) -> Optional[Any]:
# _tmp_212: '(' arguments? ')'
mark = self._mark()
if (
(literal := self.expect('('))
and
(opt := self.arguments(),)
and
(literal_1 := self.expect(')'))
):
return [literal, opt, literal_1]
self._reset(mark)
return None
@memoize
def _tmp_213(self) -> Optional[Any]:
# _tmp_213: '(' arguments? ')'
mark = self._mark()
if (
(literal := self.expect('('))
and
(opt := self.arguments(),)
and
(literal_1 := self.expect(')'))
):
return [literal, opt, literal_1]
self._reset(mark)
return None
@memoize
def _loop0_215(self) -> Optional[Any]:
# _loop0_215: ',' double_starred_kvpair
mark = self._mark()
children = []
while (
(literal := self.expect(','))
and
(elem := self.double_starred_kvpair())
):
children.append(elem)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _gather_214(self) -> Optional[Any]:
# _gather_214: double_starred_kvpair _loop0_215
mark = self._mark()
if (
(elem := self.double_starred_kvpair())
is not None
and
(seq := self._loop0_215())
is not None
):
return [elem] + seq
self._reset(mark)
return None
@memoize
def _tmp_216(self) -> Optional[Any]:
# _tmp_216: '}' | ','
mark = self._mark()
if (
(literal := self.expect('}'))
):
return literal
self._reset(mark)
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_217(self) -> Optional[Any]:
# _tmp_217: '}' | ','
mark = self._mark()
if (
(literal := self.expect('}'))
):
return literal
self._reset(mark)
if (
(literal := self.expect(','))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_218(self) -> Optional[Any]:
# _tmp_218: star_targets '='
mark = self._mark()
if (
(z := self.star_targets())
and
(literal := self.expect('='))
):
return z
self._reset(mark)
return None
@memoize
def _tmp_219(self) -> Optional[Any]:
# _tmp_219: '.' | '...'
mark = self._mark()
if (
(literal := self.expect('.'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('...'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_220(self) -> Optional[Any]:
# _tmp_220: '.' | '...'
mark = self._mark()
if (
(literal := self.expect('.'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('...'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_221(self) -> Optional[Any]:
# _tmp_221: '@' named_expression NEWLINE
mark = self._mark()
if (
(literal := self.expect('@'))
and
(f := self.named_expression())
and
(_newline := self.expect('NEWLINE'))
):
return f
self._reset(mark)
return None
@memoize
def _tmp_222(self) -> Optional[Any]:
# _tmp_222: ',' expression
mark = self._mark()
if (
(literal := self.expect(','))
and
(c := self.expression())
):
return c
self._reset(mark)
return None
@memoize
def _tmp_223(self) -> Optional[Any]:
# _tmp_223: ',' star_expression
mark = self._mark()
if (
(literal := self.expect(','))
and
(c := self.star_expression())
):
return c
self._reset(mark)
return None
@memoize
def _tmp_224(self) -> Optional[Any]:
# _tmp_224: 'or' conjunction
mark = self._mark()
if (
(literal := self.expect('or'))
and
(c := self.conjunction())
):
return c
self._reset(mark)
return None
@memoize
def _tmp_225(self) -> Optional[Any]:
# _tmp_225: 'and' inversion
mark = self._mark()
if (
(literal := self.expect('and'))
and
(c := self.inversion())
):
return c
self._reset(mark)
return None
@memoize
def _tmp_226(self) -> Optional[Any]:
# _tmp_226: slice | starred_expression
mark = self._mark()
if (
(slice := self.slice())
):
return slice
self._reset(mark)
if (
(starred_expression := self.starred_expression())
):
return starred_expression
self._reset(mark)
return None
@memoize
def _tmp_227(self) -> Optional[Any]:
# _tmp_227: 'if' disjunction
mark = self._mark()
if (
(literal := self.expect('if'))
and
(z := self.disjunction())
):
return z
self._reset(mark)
return None
@memoize
def _tmp_228(self) -> Optional[Any]:
# _tmp_228: 'if' disjunction
mark = self._mark()
if (
(literal := self.expect('if'))
and
(z := self.disjunction())
):
return z
self._reset(mark)
return None
@memoize
def _tmp_229(self) -> Optional[Any]:
# _tmp_229: starred_expression | (assignment_expression | expression !':=') !'='
mark = self._mark()
if (
(starred_expression := self.starred_expression())
):
return starred_expression
self._reset(mark)
if (
(_tmp_242 := self._tmp_242())
and
self.negative_lookahead(self.expect, '=')
):
return _tmp_242
self._reset(mark)
return None
@memoize
def _tmp_230(self) -> Optional[Any]:
# _tmp_230: ',' star_target
mark = self._mark()
if (
(literal := self.expect(','))
and
(c := self.star_target())
):
return c
self._reset(mark)
return None
@memoize
def _tmp_231(self) -> Optional[Any]:
# _tmp_231: ',' star_target
mark = self._mark()
if (
(literal := self.expect(','))
and
(c := self.star_target())
):
return c
self._reset(mark)
return None
@memoize
def _tmp_232(self) -> Optional[Any]:
# _tmp_232: star_targets '='
mark = self._mark()
if (
(star_targets := self.star_targets())
and
(literal := self.expect('='))
):
return [star_targets, literal]
self._reset(mark)
return None
@memoize
def _tmp_233(self) -> Optional[Any]:
# _tmp_233: star_targets '='
mark = self._mark()
if (
(star_targets := self.star_targets())
and
(literal := self.expect('='))
):
return [star_targets, literal]
self._reset(mark)
return None
@memoize
def _tmp_234(self) -> Optional[Any]:
# _tmp_234: ')' | '**'
mark = self._mark()
if (
(literal := self.expect(')'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('**'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_235(self) -> Optional[Any]:
# _tmp_235: ':' | '**'
mark = self._mark()
if (
(literal := self.expect(':'))
):
return literal
self._reset(mark)
if (
(literal := self.expect('**'))
):
return literal
self._reset(mark)
return None
@memoize
def _tmp_236(self) -> Optional[Any]:
# _tmp_236: expression ['as' star_target]
mark = self._mark()
if (
(expression := self.expression())
and
(opt := self._tmp_243(),)
):
return [expression, opt]
self._reset(mark)
return None
@memoize
def _tmp_237(self) -> Optional[Any]:
# _tmp_237: expressions ['as' star_target]
mark = self._mark()
if (
(expressions := self.expressions())
and
(opt := self._tmp_244(),)
):
return [expressions, opt]
self._reset(mark)
return None
@memoize
def _tmp_238(self) -> Optional[Any]:
# _tmp_238: expression ['as' star_target]
mark = self._mark()
if (
(expression := self.expression())
and
(opt := self._tmp_245(),)
):
return [expression, opt]
self._reset(mark)
return None
@memoize
def _tmp_239(self) -> Optional[Any]:
# _tmp_239: expressions ['as' star_target]
mark = self._mark()
if (
(expressions := self.expressions())
and
(opt := self._tmp_246(),)
):
return [expressions, opt]
self._reset(mark)
return None
@memoize
def _tmp_240(self) -> Optional[Any]:
# _tmp_240: except_block+ except_star_block
mark = self._mark()
if (
(_loop1_247 := self._loop1_247())
and
(except_star_block := self.except_star_block())
):
return [_loop1_247, except_star_block]
self._reset(mark)
return None
@memoize
def _tmp_241(self) -> Optional[Any]:
# _tmp_241: except_star_block+ except_block
mark = self._mark()
if (
(_loop1_248 := self._loop1_248())
and
(except_block := self.except_block())
):
return [_loop1_248, except_block]
self._reset(mark)
return None
@memoize
def _tmp_242(self) -> Optional[Any]:
# _tmp_242: assignment_expression | expression !':='
mark = self._mark()
if (
(assignment_expression := self.assignment_expression())
):
return assignment_expression
self._reset(mark)
if (
(expression := self.expression())
and
self.negative_lookahead(self.expect, ':=')
):
return expression
self._reset(mark)
return None
@memoize
def _tmp_243(self) -> Optional[Any]:
# _tmp_243: 'as' star_target
mark = self._mark()
if (
(literal := self.expect('as'))
and
(star_target := self.star_target())
):
return [literal, star_target]
self._reset(mark)
return None
@memoize
def _tmp_244(self) -> Optional[Any]:
# _tmp_244: 'as' star_target
mark = self._mark()
if (
(literal := self.expect('as'))
and
(star_target := self.star_target())
):
return [literal, star_target]
self._reset(mark)
return None
@memoize
def _tmp_245(self) -> Optional[Any]:
# _tmp_245: 'as' star_target
mark = self._mark()
if (
(literal := self.expect('as'))
and
(star_target := self.star_target())
):
return [literal, star_target]
self._reset(mark)
return None
@memoize
def _tmp_246(self) -> Optional[Any]:
# _tmp_246: 'as' star_target
mark = self._mark()
if (
(literal := self.expect('as'))
and
(star_target := self.star_target())
):
return [literal, star_target]
self._reset(mark)
return None
@memoize
def _loop1_247(self) -> Optional[Any]:
# _loop1_247: except_block
mark = self._mark()
children = []
while (
(except_block := self.except_block())
):
children.append(except_block)
mark = self._mark()
self._reset(mark)
return children
@memoize
def _loop1_248(self) -> Optional[Any]:
# _loop1_248: except_star_block
mark = self._mark()
children = []
while (
(except_star_block := self.except_star_block())
):
children.append(except_star_block)
mark = self._mark()
self._reset(mark)
return children
KEYWORDS = ('return', 'import', 'from', 'raise', 'pass', 'del', 'yield', 'assert', 'break', 'continue', 'global', 'nonlocal', 'def', 'if', 'class', 'with', 'for', 'try', 'while', 'as', 'elif', 'else', 'in', 'except', 'finally', 'None', 'True', 'False', 'or', 'and', 'not', 'is', 'lambda')
SOFT_KEYWORDS = ('case', '_', 'match')
void *
_PyPegen_parse(Parser *p)
{
// Initialize keywords
p->keywords = reserved_keywords;
p->n_keyword_lists = n_keyword_lists;
p->soft_keywords = soft_keywords;
// Run parser
void *result = NULL;
if (p->start_rule == Py_file_input) {
result = file_rule(p);
} else if (p->start_rule == Py_single_input) {
result = interactive_rule(p);
} else if (p->start_rule == Py_eval_input) {
result = eval_rule(p);
} else if (p->start_rule == Py_func_type_input) {
result = func_type_rule(p);
} else if (p->start_rule == Py_fstring_input) {
result = fstring_rule(p);
}
return result;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment