Debian Codegraph @

Grammar/python.gram

raw
1 # PEG grammar for Python
2
3 @trailer '''
4 void *
5 _PyPegen_parse(Parser *p)
6 {
7 // Initialize keywords
8 p->keywords = reserved_keywords;
9 p->n_keyword_lists = n_keyword_lists;
10 p->soft_keywords = soft_keywords;
11
12 // Run parser
13 void *result = NULL;
14 if (p->start_rule == Py_file_input) {
15 result = file_rule(p);
16 } else if (p->start_rule == Py_single_input) {
17 result = interactive_rule(p);
18 } else if (p->start_rule == Py_eval_input) {
19 result = eval_rule(p);
20 } else if (p->start_rule == Py_func_type_input) {
21 result = func_type_rule(p);
22 }
23
24 return result;
25 }
26 '''
27
28 # ========================= START OF THE GRAMMAR =========================
29
30 # General grammatical elements and rules:
31 #
32 # * Strings with double quotes (") denote SOFT KEYWORDS
33 # * Strings with single quotes (') denote KEYWORDS
34 # * Upper case names (NAME) denote tokens in the Grammar/Tokens file
35 # * Rule names starting with "invalid_" are used for specialized syntax errors
36 # - These rules are NOT used in the first pass of the parser.
37 # - Only if the first pass fails to parse, a second pass including the invalid
38 # rules will be executed.
39 # - If the parser fails in the second phase with a generic syntax error, the
40 # location of the generic failure of the first pass will be used (this avoids
41 # reporting incorrect locations due to the invalid rules).
42 # - The order of the alternatives involving invalid rules matter
43 # (like any rule in PEG).
44 #
45 # Grammar Syntax (see PEP 617 for more information):
46 #
47 # rule_name: expression
48 # Optionally, a type can be included right after the rule name, which
49 # specifies the return type of the C or Python function corresponding to the
50 # rule:
51 # rule_name[return_type]: expression
52 # If the return type is omitted, then a void * is returned in C and an Any in
53 # Python.
54 # e1 e2
55 # Match e1, then match e2.
56 # e1 | e2
57 # Match e1 or e2.
58 # The first alternative can also appear on the line after the rule name for
59 # formatting purposes. In that case, a | must be used before the first
60 # alternative, like so:
61 # rule_name[return_type]:
62 # | first_alt
63 # | second_alt
64 # ( e )
65 # Match e (allows also to use other operators in the group like '(e)*')
66 # [ e ] or e?
67 # Optionally match e.
68 # e*
69 # Match zero or more occurrences of e.
70 # e+
71 # Match one or more occurrences of e.
72 # s.e+
73 # Match one or more occurrences of e, separated by s. The generated parse tree
74 # does not include the separator. This is otherwise identical to (e (s e)*).
75 # &e
76 # Succeed if e can be parsed, without consuming any input.
77 # !e
78 # Fail if e can be parsed, without consuming any input.
79 # ~
80 # Commit to the current alternative, even if it fails to parse.
81 # &&e
82 # Eager parse e. The parser will not backtrack and will immediately
83 # fail with SyntaxError if e cannot be parsed.
84 #
85
86 # STARTING RULES
87 # ==============
88
89 file[mod_ty]: a=[statements] ENDMARKER { _PyPegen_make_module(p, a) }
90 interactive[mod_ty]: a=statement_newline { _PyAST_Interactive(a, p->arena) }
91 eval[mod_ty]: a=expressions NEWLINE* ENDMARKER { _PyAST_Expression(a, p->arena) }
92 func_type[mod_ty]: '(' a=[type_expressions] ')' '->' b=expression NEWLINE* ENDMARKER { _PyAST_FunctionType(a, b, p->arena) }
93
94 # GENERAL STATEMENTS
95 # ==================
96
97 statements[asdl_stmt_seq*]: a=statement+ { (asdl_stmt_seq*)_PyPegen_seq_flatten(p, a) }
98
99 statement[asdl_stmt_seq*]: a=compound_stmt { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, a) } | a[asdl_stmt_seq*]=simple_stmts { a }
100
101 statement_newline[asdl_stmt_seq*]:
102 | a=compound_stmt NEWLINE { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, a) }
103 | simple_stmts
104 | NEWLINE { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, CHECK(stmt_ty, _PyAST_Pass(EXTRA))) }
105 | ENDMARKER { _PyPegen_interactive_exit(p) }
106
107 simple_stmts[asdl_stmt_seq*]:
108 | a=simple_stmt !';' NEWLINE { (asdl_stmt_seq*)_PyPegen_singleton_seq(p, a) } # Not needed, there for speedup
109 | a[asdl_stmt_seq*]=';'.simple_stmt+ [';'] NEWLINE { a }
110
111 # NOTE: assignment MUST precede expression, else parsing a simple assignment
112 # will throw a SyntaxError.
113 simple_stmt[stmt_ty] (memo):
114 | assignment
115 | &"type" type_alias
116 | e=star_expressions { _PyAST_Expr(e, EXTRA) }
117 | &'return' return_stmt
118 | &('import' | 'from') import_stmt
119 | &'raise' raise_stmt
120 | 'pass' { _PyAST_Pass(EXTRA) }
121 | &'del' del_stmt
122 | &'yield' yield_stmt
123 | &'assert' assert_stmt
124 | 'break' { _PyAST_Break(EXTRA) }
125 | 'continue' { _PyAST_Continue(EXTRA) }
126 | &'global' global_stmt
127 | &'nonlocal' nonlocal_stmt
128
129 compound_stmt[stmt_ty]:
130 | &('def' | '@' | 'async') function_def
131 | &'if' if_stmt
132 | &('class' | '@') class_def
133 | &('with' | 'async') with_stmt
134 | &('for' | 'async') for_stmt
135 | &'try' try_stmt
136 | &'while' while_stmt
137 | match_stmt
138
139 # SIMPLE STATEMENTS
140 # =================
141
142 # NOTE: annotated_rhs may start with 'yield'; yield_expr must start with 'yield'
143 assignment[stmt_ty]:
144 | a=NAME ':' b=expression c=['=' d=annotated_rhs { d }] {
145 CHECK_VERSION(
146 stmt_ty,
147 6,
148 "Variable annotation syntax is",
149 _PyAST_AnnAssign(CHECK(expr_ty, _PyPegen_set_expr_context(p, a, Store)), b, c, 1, EXTRA)
150 ) }
151 | a=('(' b=single_target ')' { b }
152 | single_subscript_attribute_target) ':' b=expression c=['=' d=annotated_rhs { d }] {
153 CHECK_VERSION(stmt_ty, 6, "Variable annotations syntax is", _PyAST_AnnAssign(a, b, c, 0, EXTRA)) }
154 | a[asdl_expr_seq*]=(z=star_targets '=' { z })+ b=(yield_expr | star_expressions) !'=' tc=[TYPE_COMMENT] {
155 _PyAST_Assign(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA) }
156 | a=single_target b=augassign ~ c=(yield_expr | star_expressions) {
157 _PyAST_AugAssign(a, b->kind, c, EXTRA) }
158 | invalid_assignment
159
160 annotated_rhs[expr_ty]: yield_expr | star_expressions
161
162 augassign[AugOperator*]:
163 | '+=' { _PyPegen_augoperator(p, Add) }
164 | '-=' { _PyPegen_augoperator(p, Sub) }
165 | '*=' { _PyPegen_augoperator(p, Mult) }
166 | '@=' { CHECK_VERSION(AugOperator*, 5, "The '@' operator is", _PyPegen_augoperator(p, MatMult)) }
167 | '/=' { _PyPegen_augoperator(p, Div) }
168 | '%=' { _PyPegen_augoperator(p, Mod) }
169 | '&=' { _PyPegen_augoperator(p, BitAnd) }
170 | '|=' { _PyPegen_augoperator(p, BitOr) }
171 | '^=' { _PyPegen_augoperator(p, BitXor) }
172 | '<<=' { _PyPegen_augoperator(p, LShift) }
173 | '>>=' { _PyPegen_augoperator(p, RShift) }
174 | '**=' { _PyPegen_augoperator(p, Pow) }
175 | '//=' { _PyPegen_augoperator(p, FloorDiv) }
176
177 return_stmt[stmt_ty]:
178 | 'return' a=[star_expressions] { _PyAST_Return(a, EXTRA) }
179
180 raise_stmt[stmt_ty]:
181 | 'raise' a=expression b=['from' z=expression { z }] { _PyAST_Raise(a, b, EXTRA) }
182 | 'raise' { _PyAST_Raise(NULL, NULL, EXTRA) }
183
184 global_stmt[stmt_ty]: 'global' a[asdl_expr_seq*]=','.NAME+ {
185 _PyAST_Global(CHECK(asdl_identifier_seq*, _PyPegen_map_names_to_ids(p, a)), EXTRA) }
186
187 nonlocal_stmt[stmt_ty]: 'nonlocal' a[asdl_expr_seq*]=','.NAME+ {
188 _PyAST_Nonlocal(CHECK(asdl_identifier_seq*, _PyPegen_map_names_to_ids(p, a)), EXTRA) }
189
190 del_stmt[stmt_ty]:
191 | 'del' a=del_targets &(';' | NEWLINE) { _PyAST_Delete(a, EXTRA) }
192 | invalid_del_stmt
193
194 yield_stmt[stmt_ty]: y=yield_expr { _PyAST_Expr(y, EXTRA) }
195
196 assert_stmt[stmt_ty]: 'assert' a=expression b=[',' z=expression { z }] { _PyAST_Assert(a, b, EXTRA) }
197
198 import_stmt[stmt_ty]:
199 | invalid_import
200 | import_name
201 | import_from
202
203 # Import statements
204 # -----------------
205
206 import_name[stmt_ty]: 'import' a=dotted_as_names { _PyAST_Import(a, EXTRA) }
207 # note below: the ('.' | '...') is necessary because '...' is tokenized as ELLIPSIS
208 import_from[stmt_ty]:
209 | 'from' a=('.' | '...')* b=dotted_name 'import' c=import_from_targets {
210 _PyPegen_checked_future_import(p, b->v.Name.id, c, _PyPegen_seq_count_dots(a), EXTRA) }
211 | 'from' a=('.' | '...')+ 'import' b=import_from_targets {
212 _PyAST_ImportFrom(NULL, b, _PyPegen_seq_count_dots(a), EXTRA) }
213 import_from_targets[asdl_alias_seq*]:
214 | '(' a=import_from_as_names [','] ')' { a }
215 | import_from_as_names !','
216 | '*' { (asdl_alias_seq*)_PyPegen_singleton_seq(p, CHECK(alias_ty, _PyPegen_alias_for_star(p, EXTRA))) }
217 | invalid_import_from_targets
218 import_from_as_names[asdl_alias_seq*]:
219 | a[asdl_alias_seq*]=','.import_from_as_name+ { a }
220 import_from_as_name[alias_ty]:
221 | a=NAME b=['as' z=NAME { z }] { _PyAST_alias(a->v.Name.id,
222 (b) ? ((expr_ty) b)->v.Name.id : NULL,
223 EXTRA) }
224 dotted_as_names[asdl_alias_seq*]:
225 | a[asdl_alias_seq*]=','.dotted_as_name+ { a }
226 dotted_as_name[alias_ty]:
227 | a=dotted_name b=['as' z=NAME { z }] { _PyAST_alias(a->v.Name.id,
228 (b) ? ((expr_ty) b)->v.Name.id : NULL,
229 EXTRA) }
230 dotted_name[expr_ty]:
231 | a=dotted_name '.' b=NAME { _PyPegen_join_names_with_dot(p, a, b) }
232 | NAME
233
234 # COMPOUND STATEMENTS
235 # ===================
236
237 # Common elements
238 # ---------------
239
240 block[asdl_stmt_seq*] (memo):
241 | NEWLINE INDENT a=statements DEDENT { a }
242 | simple_stmts
243 | invalid_block
244
245 decorators[asdl_expr_seq*]: a[asdl_expr_seq*]=('@' f=named_expression NEWLINE { f })+ { a }
246
247 # Class definitions
248 # -----------------
249
250 class_def[stmt_ty]:
251 | a=decorators b=class_def_raw { _PyPegen_class_def_decorators(p, a, b) }
252 | class_def_raw
253
254 class_def_raw[stmt_ty]:
255 | invalid_class_def_raw
256 | 'class' a=NAME t=[type_params] b=['(' z=[arguments] ')' { z }] ':' c=block {
257 _PyAST_ClassDef(a->v.Name.id,
258 (b) ? ((expr_ty) b)->v.Call.args : NULL,
259 (b) ? ((expr_ty) b)->v.Call.keywords : NULL,
260 c, NULL, t, EXTRA) }
261
262 # Function definitions
263 # --------------------
264
265 function_def[stmt_ty]:
266 | d=decorators f=function_def_raw { _PyPegen_function_def_decorators(p, d, f) }
267 | function_def_raw
268
269 function_def_raw[stmt_ty]:
270 | invalid_def_raw
271 | 'def' n=NAME t=[type_params] '(' params=[params] ')' a=['->' z=expression { z }] ':' tc=[func_type_comment] b=block {
272 _PyAST_FunctionDef(n->v.Name.id,
273 (params) ? params : CHECK(arguments_ty, _PyPegen_empty_arguments(p)),
274 b, NULL, a, NEW_TYPE_COMMENT(p, tc), t, EXTRA) }
275 | 'async' 'def' n=NAME t=[type_params] '(' params=[params] ')' a=['->' z=expression { z }] ':' tc=[func_type_comment] b=block {
276 CHECK_VERSION(
277 stmt_ty,
278 5,
279 "Async functions are",
280 _PyAST_AsyncFunctionDef(n->v.Name.id,
281 (params) ? params : CHECK(arguments_ty, _PyPegen_empty_arguments(p)),
282 b, NULL, a, NEW_TYPE_COMMENT(p, tc), t, EXTRA)
283 ) }
284
285 # Function parameters
286 # -------------------
287
288 params[arguments_ty]:
289 | invalid_parameters
290 | parameters
291
292 parameters[arguments_ty]:
293 | a=slash_no_default b[asdl_arg_seq*]=param_no_default* c=param_with_default* d=[star_etc] {
294 CHECK_VERSION(arguments_ty, 8, "Positional-only parameters are", _PyPegen_make_arguments(p, a, NULL, b, c, d)) }
295 | a=slash_with_default b=param_with_default* c=[star_etc] {
296 CHECK_VERSION(arguments_ty, 8, "Positional-only parameters are", _PyPegen_make_arguments(p, NULL, a, NULL, b, c)) }
297 | a[asdl_arg_seq*]=param_no_default+ b=param_with_default* c=[star_etc] {
298 _PyPegen_make_arguments(p, NULL, NULL, a, b, c) }
299 | a=param_with_default+ b=[star_etc] { _PyPegen_make_arguments(p, NULL, NULL, NULL, a, b)}
300 | a=star_etc { _PyPegen_make_arguments(p, NULL, NULL, NULL, NULL, a) }
301
302 # Some duplication here because we can't write (',' | &')'),
303 # which is because we don't support empty alternatives (yet).
304
305 slash_no_default[asdl_arg_seq*]:
306 | a[asdl_arg_seq*]=param_no_default+ '/' ',' { a }
307 | a[asdl_arg_seq*]=param_no_default+ '/' &')' { a }
308 slash_with_default[SlashWithDefault*]:
309 | a=param_no_default* b=param_with_default+ '/' ',' { _PyPegen_slash_with_default(p, (asdl_arg_seq *)a, b) }
310 | a=param_no_default* b=param_with_default+ '/' &')' { _PyPegen_slash_with_default(p, (asdl_arg_seq *)a, b) }
311
312 star_etc[StarEtc*]:
313 | invalid_star_etc
314 | '*' a=param_no_default b=param_maybe_default* c=[kwds] {
315 _PyPegen_star_etc(p, a, b, c) }
316 | '*' a=param_no_default_star_annotation b=param_maybe_default* c=[kwds] {
317 _PyPegen_star_etc(p, a, b, c) }
318 | '*' ',' b=param_maybe_default+ c=[kwds] {
319 _PyPegen_star_etc(p, NULL, b, c) }
320 | a=kwds { _PyPegen_star_etc(p, NULL, NULL, a) }
321
322 kwds[arg_ty]:
323 | invalid_kwds
324 | '**' a=param_no_default { a }
325
326 # One parameter. This *includes* a following comma and type comment.
327 #
328 # There are three styles:
329 # - No default
330 # - With default
331 # - Maybe with default
332 #
333 # There are two alternative forms of each, to deal with type comments:
334 # - Ends in a comma followed by an optional type comment
335 # - No comma, optional type comment, must be followed by close paren
336 # The latter form is for a final parameter without trailing comma.
337 #
338
339 param_no_default[arg_ty]:
340 | a=param ',' tc=TYPE_COMMENT? { _PyPegen_add_type_comment_to_arg(p, a, tc) }
341 | a=param tc=TYPE_COMMENT? &')' { _PyPegen_add_type_comment_to_arg(p, a, tc) }
342 param_no_default_star_annotation[arg_ty]:
343 | a=param_star_annotation ',' tc=TYPE_COMMENT? { _PyPegen_add_type_comment_to_arg(p, a, tc) }
344 | a=param_star_annotation tc=TYPE_COMMENT? &')' { _PyPegen_add_type_comment_to_arg(p, a, tc) }
345 param_with_default[NameDefaultPair*]:
346 | a=param c=default ',' tc=TYPE_COMMENT? { _PyPegen_name_default_pair(p, a, c, tc) }
347 | a=param c=default tc=TYPE_COMMENT? &')' { _PyPegen_name_default_pair(p, a, c, tc) }
348 param_maybe_default[NameDefaultPair*]:
349 | a=param c=default? ',' tc=TYPE_COMMENT? { _PyPegen_name_default_pair(p, a, c, tc) }
350 | a=param c=default? tc=TYPE_COMMENT? &')' { _PyPegen_name_default_pair(p, a, c, tc) }
351 param[arg_ty]: a=NAME b=annotation? { _PyAST_arg(a->v.Name.id, b, NULL, EXTRA) }
352 param_star_annotation[arg_ty]: a=NAME b=star_annotation { _PyAST_arg(a->v.Name.id, b, NULL, EXTRA) }
353 annotation[expr_ty]: ':' a=expression { a }
354 star_annotation[expr_ty]: ':' a=star_expression { a }
355 default[expr_ty]: '=' a=expression { a } | invalid_default
356
357 # If statement
358 # ------------
359
360 if_stmt[stmt_ty]:
361 | invalid_if_stmt
362 | 'if' a=named_expression ':' b=block c=elif_stmt {
363 _PyAST_If(a, b, CHECK(asdl_stmt_seq*, _PyPegen_singleton_seq(p, c)), EXTRA) }
364 | 'if' a=named_expression ':' b=block c=[else_block] { _PyAST_If(a, b, c, EXTRA) }
365 elif_stmt[stmt_ty]:
366 | invalid_elif_stmt
367 | 'elif' a=named_expression ':' b=block c=elif_stmt {
368 _PyAST_If(a, b, CHECK(asdl_stmt_seq*, _PyPegen_singleton_seq(p, c)), EXTRA) }
369 | 'elif' a=named_expression ':' b=block c=[else_block] { _PyAST_If(a, b, c, EXTRA) }
370 else_block[asdl_stmt_seq*]:
371 | invalid_else_stmt
372 | 'else' &&':' b=block { b }
373
374 # While statement
375 # ---------------
376
377 while_stmt[stmt_ty]:
378 | invalid_while_stmt
379 | 'while' a=named_expression ':' b=block c=[else_block] { _PyAST_While(a, b, c, EXTRA) }
380
381 # For statement
382 # -------------
383
384 for_stmt[stmt_ty]:
385 | invalid_for_stmt
386 | 'for' t=star_targets 'in' ~ ex=star_expressions ':' tc=[TYPE_COMMENT] b=block el=[else_block] {
387 _PyAST_For(t, ex, b, el, NEW_TYPE_COMMENT(p, tc), EXTRA) }
388 | 'async' 'for' t=star_targets 'in' ~ ex=star_expressions ':' tc=[TYPE_COMMENT] b=block el=[else_block] {
389 CHECK_VERSION(stmt_ty, 5, "Async for loops are", _PyAST_AsyncFor(t, ex, b, el, NEW_TYPE_COMMENT(p, tc), EXTRA)) }
390 | invalid_for_target
391
392 # With statement
393 # --------------
394
395 with_stmt[stmt_ty]:
396 | invalid_with_stmt_indent
397 | 'with' '(' a[asdl_withitem_seq*]=','.with_item+ ','? ')' ':' tc=[TYPE_COMMENT] b=block {
398 _PyAST_With(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA) }
399 | 'with' a[asdl_withitem_seq*]=','.with_item+ ':' tc=[TYPE_COMMENT] b=block {
400 _PyAST_With(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA) }
401 | 'async' 'with' '(' a[asdl_withitem_seq*]=','.with_item+ ','? ')' ':' b=block {
402 CHECK_VERSION(stmt_ty, 5, "Async with statements are", _PyAST_AsyncWith(a, b, NULL, EXTRA)) }
403 | 'async' 'with' a[asdl_withitem_seq*]=','.with_item+ ':' tc=[TYPE_COMMENT] b=block {
404 CHECK_VERSION(stmt_ty, 5, "Async with statements are", _PyAST_AsyncWith(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA)) }
405 | invalid_with_stmt
406
407 with_item[withitem_ty]:
408 | e=expression 'as' t=star_target &(',' | ')' | ':') { _PyAST_withitem(e, t, p->arena) }
409 | invalid_with_item
410 | e=expression { _PyAST_withitem(e, NULL, p->arena) }
411
412 # Try statement
413 # -------------
414
415 try_stmt[stmt_ty]:
416 | invalid_try_stmt
417 | 'try' &&':' b=block f=finally_block { _PyAST_Try(b, NULL, NULL, f, EXTRA) }
418 | 'try' &&':' b=block ex[asdl_excepthandler_seq*]=except_block+ el=[else_block] f=[finally_block] { _PyAST_Try(b, ex, el, f, EXTRA) }
419 | 'try' &&':' b=block ex[asdl_excepthandler_seq*]=except_star_block+ el=[else_block] f=[finally_block] {
420 CHECK_VERSION(stmt_ty, 11, "Exception groups are",
421 _PyAST_TryStar(b, ex, el, f, EXTRA)) }
422
423
424 # Except statement
425 # ----------------
426
427 except_block[excepthandler_ty]:
428 | invalid_except_stmt_indent
429 | 'except' e=expression t=['as' z=NAME { z }] ':' b=block {
430 _PyAST_ExceptHandler(e, (t) ? ((expr_ty) t)->v.Name.id : NULL, b, EXTRA) }
431 | 'except' ':' b=block { _PyAST_ExceptHandler(NULL, NULL, b, EXTRA) }
432 | invalid_except_stmt
433 except_star_block[excepthandler_ty]:
434 | invalid_except_star_stmt_indent
435 | 'except' '*' e=expression t=['as' z=NAME { z }] ':' b=block {
436 _PyAST_ExceptHandler(e, (t) ? ((expr_ty) t)->v.Name.id : NULL, b, EXTRA) }
437 | invalid_except_stmt
438 finally_block[asdl_stmt_seq*]:
439 | invalid_finally_stmt
440 | 'finally' &&':' a=block { a }
441
442 # Match statement
443 # ---------------
444
445 match_stmt[stmt_ty]:
446 | "match" subject=subject_expr ':' NEWLINE INDENT cases[asdl_match_case_seq*]=case_block+ DEDENT {
447 CHECK_VERSION(stmt_ty, 10, "Pattern matching is", _PyAST_Match(subject, cases, EXTRA)) }
448 | invalid_match_stmt
449
450 subject_expr[expr_ty]:
451 | value=star_named_expression ',' values=star_named_expressions? {
452 _PyAST_Tuple(CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, value, values)), Load, EXTRA) }
453 | named_expression
454
455 case_block[match_case_ty]:
456 | invalid_case_block
457 | "case" pattern=patterns guard=guard? ':' body=block {
458 _PyAST_match_case(pattern, guard, body, p->arena) }
459
460 guard[expr_ty]: 'if' guard=named_expression { guard }
461
462 patterns[pattern_ty]:
463 | patterns[asdl_pattern_seq*]=open_sequence_pattern {
464 _PyAST_MatchSequence(patterns, EXTRA) }
465 | pattern
466
467 pattern[pattern_ty]:
468 | as_pattern
469 | or_pattern
470
471 as_pattern[pattern_ty]:
472 | pattern=or_pattern 'as' target=pattern_capture_target {
473 _PyAST_MatchAs(pattern, target->v.Name.id, EXTRA) }
474 | invalid_as_pattern
475
476 or_pattern[pattern_ty]:
477 | patterns[asdl_pattern_seq*]='|'.closed_pattern+ {
478 asdl_seq_LEN(patterns) == 1 ? asdl_seq_GET(patterns, 0) : _PyAST_MatchOr(patterns, EXTRA) }
479
480 closed_pattern[pattern_ty] (memo):
481 | literal_pattern
482 | capture_pattern
483 | wildcard_pattern
484 | value_pattern
485 | group_pattern
486 | sequence_pattern
487 | mapping_pattern
488 | class_pattern
489
490 # Literal patterns are used for equality and identity constraints
491 literal_pattern[pattern_ty]:
492 | value=signed_number !('+' | '-') { _PyAST_MatchValue(value, EXTRA) }
493 | value=complex_number { _PyAST_MatchValue(value, EXTRA) }
494 | value=strings { _PyAST_MatchValue(value, EXTRA) }
495 | 'None' { _PyAST_MatchSingleton(Py_None, EXTRA) }
496 | 'True' { _PyAST_MatchSingleton(Py_True, EXTRA) }
497 | 'False' { _PyAST_MatchSingleton(Py_False, EXTRA) }
498
499 # Literal expressions are used to restrict permitted mapping pattern keys
500 literal_expr[expr_ty]:
501 | signed_number !('+' | '-')
502 | complex_number
503 | strings
504 | 'None' { _PyAST_Constant(Py_None, NULL, EXTRA) }
505 | 'True' { _PyAST_Constant(Py_True, NULL, EXTRA) }
506 | 'False' { _PyAST_Constant(Py_False, NULL, EXTRA) }
507
508 complex_number[expr_ty]:
509 | real=signed_real_number '+' imag=imaginary_number {
510 _PyAST_BinOp(real, Add, imag, EXTRA) }
511 | real=signed_real_number '-' imag=imaginary_number {
512 _PyAST_BinOp(real, Sub, imag, EXTRA) }
513
514 signed_number[expr_ty]:
515 | NUMBER
516 | '-' number=NUMBER { _PyAST_UnaryOp(USub, number, EXTRA) }
517
518 signed_real_number[expr_ty]:
519 | real_number
520 | '-' real=real_number { _PyAST_UnaryOp(USub, real, EXTRA) }
521
522 real_number[expr_ty]:
523 | real=NUMBER { _PyPegen_ensure_real(p, real) }
524
525 imaginary_number[expr_ty]:
526 | imag=NUMBER { _PyPegen_ensure_imaginary(p, imag) }
527
528 capture_pattern[pattern_ty]:
529 | target=pattern_capture_target { _PyAST_MatchAs(NULL, target->v.Name.id, EXTRA) }
530
531 pattern_capture_target[expr_ty]:
532 | !"_" name=NAME !('.' | '(' | '=') {
533 _PyPegen_set_expr_context(p, name, Store) }
534
535 wildcard_pattern[pattern_ty]:
536 | "_" { _PyAST_MatchAs(NULL, NULL, EXTRA) }
537
538 value_pattern[pattern_ty]:
539 | attr=attr !('.' | '(' | '=') { _PyAST_MatchValue(attr, EXTRA) }
540
541 attr[expr_ty]:
542 | value=name_or_attr '.' attr=NAME {
543 _PyAST_Attribute(value, attr->v.Name.id, Load, EXTRA) }
544
545 name_or_attr[expr_ty]:
546 | attr
547 | NAME
548
549 group_pattern[pattern_ty]:
550 | '(' pattern=pattern ')' { pattern }
551
552 sequence_pattern[pattern_ty]:
553 | '[' patterns=maybe_sequence_pattern? ']' { _PyAST_MatchSequence(patterns, EXTRA) }
554 | '(' patterns=open_sequence_pattern? ')' { _PyAST_MatchSequence(patterns, EXTRA) }
555
556 open_sequence_pattern[asdl_seq*]:
557 | pattern=maybe_star_pattern ',' patterns=maybe_sequence_pattern? {
558 _PyPegen_seq_insert_in_front(p, pattern, patterns) }
559
560 maybe_sequence_pattern[asdl_seq*]:
561 | patterns=','.maybe_star_pattern+ ','? { patterns }
562
563 maybe_star_pattern[pattern_ty]:
564 | star_pattern
565 | pattern
566
567 star_pattern[pattern_ty] (memo):
568 | '*' target=pattern_capture_target {
569 _PyAST_MatchStar(target->v.Name.id, EXTRA) }
570 | '*' wildcard_pattern {
571 _PyAST_MatchStar(NULL, EXTRA) }
572
573 mapping_pattern[pattern_ty]:
574 | '{' '}' {
575 _PyAST_MatchMapping(NULL, NULL, NULL, EXTRA) }
576 | '{' rest=double_star_pattern ','? '}' {
577 _PyAST_MatchMapping(NULL, NULL, rest->v.Name.id, EXTRA) }
578 | '{' items=items_pattern ',' rest=double_star_pattern ','? '}' {
579 _PyAST_MatchMapping(
580 CHECK(asdl_expr_seq*, _PyPegen_get_pattern_keys(p, items)),
581 CHECK(asdl_pattern_seq*, _PyPegen_get_patterns(p, items)),
582 rest->v.Name.id,
583 EXTRA) }
584 | '{' items=items_pattern ','? '}' {
585 _PyAST_MatchMapping(
586 CHECK(asdl_expr_seq*, _PyPegen_get_pattern_keys(p, items)),
587 CHECK(asdl_pattern_seq*, _PyPegen_get_patterns(p, items)),
588 NULL,
589 EXTRA) }
590
591 items_pattern[asdl_seq*]:
592 | ','.key_value_pattern+
593
594 key_value_pattern[KeyPatternPair*]:
595 | key=(literal_expr | attr) ':' pattern=pattern {
596 _PyPegen_key_pattern_pair(p, key, pattern) }
597
598 double_star_pattern[expr_ty]:
599 | '**' target=pattern_capture_target { target }
600
601 class_pattern[pattern_ty]:
602 | cls=name_or_attr '(' ')' {
603 _PyAST_MatchClass(cls, NULL, NULL, NULL, EXTRA) }
604 | cls=name_or_attr '(' patterns=positional_patterns ','? ')' {
605 _PyAST_MatchClass(cls, patterns, NULL, NULL, EXTRA) }
606 | cls=name_or_attr '(' keywords=keyword_patterns ','? ')' {
607 _PyAST_MatchClass(
608 cls, NULL,
609 CHECK(asdl_identifier_seq*, _PyPegen_map_names_to_ids(p,
610 CHECK(asdl_expr_seq*, _PyPegen_get_pattern_keys(p, keywords)))),
611 CHECK(asdl_pattern_seq*, _PyPegen_get_patterns(p, keywords)),
612 EXTRA) }
613 | cls=name_or_attr '(' patterns=positional_patterns ',' keywords=keyword_patterns ','? ')' {
614 _PyAST_MatchClass(
615 cls,
616 patterns,
617 CHECK(asdl_identifier_seq*, _PyPegen_map_names_to_ids(p,
618 CHECK(asdl_expr_seq*, _PyPegen_get_pattern_keys(p, keywords)))),
619 CHECK(asdl_pattern_seq*, _PyPegen_get_patterns(p, keywords)),
620 EXTRA) }
621 | invalid_class_pattern
622
623 positional_patterns[asdl_pattern_seq*]:
624 | args[asdl_pattern_seq*]=','.pattern+ { args }
625
626 keyword_patterns[asdl_seq*]:
627 | ','.keyword_pattern+
628
629 keyword_pattern[KeyPatternPair*]:
630 | arg=NAME '=' value=pattern { _PyPegen_key_pattern_pair(p, arg, value) }
631
632 # Type statement
633 # ---------------
634
635 type_alias[stmt_ty]:
636 | "type" n=NAME t=[type_params] '=' b=expression {
637 CHECK_VERSION(stmt_ty, 12, "Type statement is",
638 _PyAST_TypeAlias(CHECK(expr_ty, _PyPegen_set_expr_context(p, n, Store)), t, b, EXTRA)) }
639
640 # Type parameter declaration
641 # --------------------------
642
643 type_params[asdl_type_param_seq*]:
644 | invalid_type_params
645 | '[' t=type_param_seq ']' {
646 CHECK_VERSION(asdl_type_param_seq *, 12, "Type parameter lists are", t) }
647
648 type_param_seq[asdl_type_param_seq*]: a[asdl_type_param_seq*]=','.type_param+ [','] { a }
649
650 type_param[type_param_ty] (memo):
651 | a=NAME b=[type_param_bound] c=[type_param_default] { _PyAST_TypeVar(a->v.Name.id, b, c, EXTRA) }
652 | '*' a=NAME colon=':' e=expression {
653 RAISE_SYNTAX_ERROR_STARTING_FROM(colon, e->kind == Tuple_kind
654 ? "cannot use constraints with TypeVarTuple"
655 : "cannot use bound with TypeVarTuple")
656 }
657 | '*' a=NAME b=[type_param_starred_default] { _PyAST_TypeVarTuple(a->v.Name.id, b, EXTRA) }
658 | '**' a=NAME colon=':' e=expression {
659 RAISE_SYNTAX_ERROR_STARTING_FROM(colon, e->kind == Tuple_kind
660 ? "cannot use constraints with ParamSpec"
661 : "cannot use bound with ParamSpec")
662 }
663 | '**' a=NAME b=[type_param_default] { _PyAST_ParamSpec(a->v.Name.id, b, EXTRA) }
664
665 type_param_bound[expr_ty]: ':' e=expression { e }
666 type_param_default[expr_ty]: '=' e=expression {
667 CHECK_VERSION(expr_ty, 13, "Type parameter defaults are", e) }
668 type_param_starred_default[expr_ty]: '=' e=star_expression {
669 CHECK_VERSION(expr_ty, 13, "Type parameter defaults are", e) }
670
671 # EXPRESSIONS
672 # -----------
673
674 expressions[expr_ty]:
675 | a=expression b=(',' c=expression { c })+ [','] {
676 _PyAST_Tuple(CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, a, b)), Load, EXTRA) }
677 | a=expression ',' { _PyAST_Tuple(CHECK(asdl_expr_seq*, _PyPegen_singleton_seq(p, a)), Load, EXTRA) }
678 | expression
679
680 expression[expr_ty] (memo):
681 | invalid_expression
682 | invalid_legacy_expression
683 | a=disjunction 'if' b=disjunction 'else' c=expression { _PyAST_IfExp(b, a, c, EXTRA) }
684 | disjunction
685 | lambdef
686
687 yield_expr[expr_ty]:
688 | 'yield' 'from' a=expression { _PyAST_YieldFrom(a, EXTRA) }
689 | 'yield' a=[star_expressions] { _PyAST_Yield(a, EXTRA) }
690
691 star_expressions[expr_ty]:
692 | a=star_expression b=(',' c=star_expression { c })+ [','] {
693 _PyAST_Tuple(CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, a, b)), Load, EXTRA) }
694 | a=star_expression ',' { _PyAST_Tuple(CHECK(asdl_expr_seq*, _PyPegen_singleton_seq(p, a)), Load, EXTRA) }
695 | star_expression
696
697 star_expression[expr_ty] (memo):
698 | '*' a=bitwise_or { _PyAST_Starred(a, Load, EXTRA) }
699 | expression
700
701 star_named_expressions[asdl_expr_seq*]: a[asdl_expr_seq*]=','.star_named_expression+ [','] { a }
702
703 star_named_expression[expr_ty]:
704 | '*' a=bitwise_or { _PyAST_Starred(a, Load, EXTRA) }
705 | named_expression
706
707 assignment_expression[expr_ty]:
708 | a=NAME ':=' ~ b=expression {
709 CHECK_VERSION(expr_ty, 8, "Assignment expressions are",
710 _PyAST_NamedExpr(CHECK(expr_ty, _PyPegen_set_expr_context(p, a, Store)), b, EXTRA)) }
711
712 named_expression[expr_ty]:
713 | assignment_expression
714 | invalid_named_expression
715 | expression !':='
716
717 disjunction[expr_ty] (memo):
718 | a=conjunction b=('or' c=conjunction { c })+ { _PyAST_BoolOp(
719 Or,
720 CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, a, b)),
721 EXTRA) }
722 | conjunction
723
724 conjunction[expr_ty] (memo):
725 | a=inversion b=('and' c=inversion { c })+ { _PyAST_BoolOp(
726 And,
727 CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, a, b)),
728 EXTRA) }
729 | inversion
730
731 inversion[expr_ty] (memo):
732 | 'not' a=inversion { _PyAST_UnaryOp(Not, a, EXTRA) }
733 | comparison
734
735 # Comparison operators
736 # --------------------
737
738 comparison[expr_ty]:
739 | a=bitwise_or b=compare_op_bitwise_or_pair+ {
740 _PyAST_Compare(
741 a,
742 CHECK(asdl_int_seq*, _PyPegen_get_cmpops(p, b)),
743 CHECK(asdl_expr_seq*, _PyPegen_get_exprs(p, b)),
744 EXTRA) }
745 | bitwise_or
746
747 compare_op_bitwise_or_pair[CmpopExprPair*]:
748 | eq_bitwise_or
749 | noteq_bitwise_or
750 | lte_bitwise_or
751 | lt_bitwise_or
752 | gte_bitwise_or
753 | gt_bitwise_or
754 | notin_bitwise_or
755 | in_bitwise_or
756 | isnot_bitwise_or
757 | is_bitwise_or
758
759 eq_bitwise_or[CmpopExprPair*]: '==' a=bitwise_or { _PyPegen_cmpop_expr_pair(p, Eq, a) }
760 noteq_bitwise_or[CmpopExprPair*]:
761 | (tok='!=' { _PyPegen_check_barry_as_flufl(p, tok) ? NULL : tok}) a=bitwise_or {_PyPegen_cmpop_expr_pair(p, NotEq, a) }
762 lte_bitwise_or[CmpopExprPair*]: '<=' a=bitwise_or { _PyPegen_cmpop_expr_pair(p, LtE, a) }
763 lt_bitwise_or[CmpopExprPair*]: '<' a=bitwise_or { _PyPegen_cmpop_expr_pair(p, Lt, a) }
764 gte_bitwise_or[CmpopExprPair*]: '>=' a=bitwise_or { _PyPegen_cmpop_expr_pair(p, GtE, a) }
765 gt_bitwise_or[CmpopExprPair*]: '>' a=bitwise_or { _PyPegen_cmpop_expr_pair(p, Gt, a) }
766 notin_bitwise_or[CmpopExprPair*]: 'not' 'in' a=bitwise_or { _PyPegen_cmpop_expr_pair(p, NotIn, a) }
767 in_bitwise_or[CmpopExprPair*]: 'in' a=bitwise_or { _PyPegen_cmpop_expr_pair(p, In, a) }
768 isnot_bitwise_or[CmpopExprPair*]: 'is' 'not' a=bitwise_or { _PyPegen_cmpop_expr_pair(p, IsNot, a) }
769 is_bitwise_or[CmpopExprPair*]: 'is' a=bitwise_or { _PyPegen_cmpop_expr_pair(p, Is, a) }
770
771 # Bitwise operators
772 # -----------------
773
774 bitwise_or[expr_ty]:
775 | a=bitwise_or '|' b=bitwise_xor { _PyAST_BinOp(a, BitOr, b, EXTRA) }
776 | bitwise_xor
777
778 bitwise_xor[expr_ty]:
779 | a=bitwise_xor '^' b=bitwise_and { _PyAST_BinOp(a, BitXor, b, EXTRA) }
780 | bitwise_and
781
782 bitwise_and[expr_ty]:
783 | a=bitwise_and '&' b=shift_expr { _PyAST_BinOp(a, BitAnd, b, EXTRA) }
784 | shift_expr
785
786 shift_expr[expr_ty]:
787 | a=shift_expr '<<' b=sum { _PyAST_BinOp(a, LShift, b, EXTRA) }
788 | a=shift_expr '>>' b=sum { _PyAST_BinOp(a, RShift, b, EXTRA) }
789 | invalid_arithmetic
790 | sum
791
792 # Arithmetic operators
793 # --------------------
794
795 sum[expr_ty]:
796 | a=sum '+' b=term { _PyAST_BinOp(a, Add, b, EXTRA) }
797 | a=sum '-' b=term { _PyAST_BinOp(a, Sub, b, EXTRA) }
798 | term
799
800 term[expr_ty]:
801 | a=term '*' b=factor { _PyAST_BinOp(a, Mult, b, EXTRA) }
802 | a=term '/' b=factor { _PyAST_BinOp(a, Div, b, EXTRA) }
803 | a=term '//' b=factor { _PyAST_BinOp(a, FloorDiv, b, EXTRA) }
804 | a=term '%' b=factor { _PyAST_BinOp(a, Mod, b, EXTRA) }
805 | a=term '@' b=factor { CHECK_VERSION(expr_ty, 5, "The '@' operator is", _PyAST_BinOp(a, MatMult, b, EXTRA)) }
806 | invalid_factor
807 | factor
808
809 factor[expr_ty] (memo):
810 | '+' a=factor { _PyAST_UnaryOp(UAdd, a, EXTRA) }
811 | '-' a=factor { _PyAST_UnaryOp(USub, a, EXTRA) }
812 | '~' a=factor { _PyAST_UnaryOp(Invert, a, EXTRA) }
813 | power
814
815 power[expr_ty]:
816 | a=await_primary '**' b=factor { _PyAST_BinOp(a, Pow, b, EXTRA) }
817 | await_primary
818
819 # Primary elements
820 # ----------------
821
822 # Primary elements are things like "obj.something.something", "obj[something]", "obj(something)", "obj" ...
823
824 await_primary[expr_ty] (memo):
825 | 'await' a=primary { CHECK_VERSION(expr_ty, 5, "Await expressions are", _PyAST_Await(a, EXTRA)) }
826 | primary
827
828 primary[expr_ty]:
829 | a=primary '.' b=NAME { _PyAST_Attribute(a, b->v.Name.id, Load, EXTRA) }
830 | a=primary b=genexp { _PyAST_Call(a, CHECK(asdl_expr_seq*, (asdl_expr_seq*)_PyPegen_singleton_seq(p, b)), NULL, EXTRA) }
831 | a=primary '(' b=[arguments] ')' {
832 _PyAST_Call(a,
833 (b) ? ((expr_ty) b)->v.Call.args : NULL,
834 (b) ? ((expr_ty) b)->v.Call.keywords : NULL,
835 EXTRA) }
836 | a=primary '[' b=slices ']' { _PyAST_Subscript(a, b, Load, EXTRA) }
837 | atom
838
839 slices[expr_ty]:
840 | a=slice !',' { a }
841 | a[asdl_expr_seq*]=','.(slice | starred_expression)+ [','] { _PyAST_Tuple(a, Load, EXTRA) }
842
843 slice[expr_ty]:
844 | a=[expression] ':' b=[expression] c=[':' d=[expression] { d }] { _PyAST_Slice(a, b, c, EXTRA) }
845 | a=named_expression { a }
846
847 atom[expr_ty]:
848 | NAME
849 | 'True' { _PyAST_Constant(Py_True, NULL, EXTRA) }
850 | 'False' { _PyAST_Constant(Py_False, NULL, EXTRA) }
851 | 'None' { _PyAST_Constant(Py_None, NULL, EXTRA) }
852 | &(STRING|FSTRING_START) strings
853 | NUMBER
854 | &'(' (tuple | group | genexp)
855 | &'[' (list | listcomp)
856 | &'{' (dict | set | dictcomp | setcomp)
857 | '...' { _PyAST_Constant(Py_Ellipsis, NULL, EXTRA) }
858
859 group[expr_ty]:
860 | '(' a=(yield_expr | named_expression) ')' { a }
861 | invalid_group
862
863 # Lambda functions
864 # ----------------
865
866 lambdef[expr_ty]:
867 | 'lambda' a=[lambda_params] ':' b=expression {
868 _PyAST_Lambda((a) ? a : CHECK(arguments_ty, _PyPegen_empty_arguments(p)), b, EXTRA) }
869
870 lambda_params[arguments_ty]:
871 | invalid_lambda_parameters
872 | lambda_parameters
873
874 # lambda_parameters etc. duplicates parameters but without annotations
875 # or type comments, and if there's no comma after a parameter, we expect
876 # a colon, not a close parenthesis. (For more, see parameters above.)
877 #
878 lambda_parameters[arguments_ty]:
879 | a=lambda_slash_no_default b[asdl_arg_seq*]=lambda_param_no_default* c=lambda_param_with_default* d=[lambda_star_etc] {
880 CHECK_VERSION(arguments_ty, 8, "Positional-only parameters are", _PyPegen_make_arguments(p, a, NULL, b, c, d)) }
881 | a=lambda_slash_with_default b=lambda_param_with_default* c=[lambda_star_etc] {
882 CHECK_VERSION(arguments_ty, 8, "Positional-only parameters are", _PyPegen_make_arguments(p, NULL, a, NULL, b, c)) }
883 | a[asdl_arg_seq*]=lambda_param_no_default+ b=lambda_param_with_default* c=[lambda_star_etc] {
884 _PyPegen_make_arguments(p, NULL, NULL, a, b, c) }
885 | a=lambda_param_with_default+ b=[lambda_star_etc] { _PyPegen_make_arguments(p, NULL, NULL, NULL, a, b)}
886 | a=lambda_star_etc { _PyPegen_make_arguments(p, NULL, NULL, NULL, NULL, a) }
887
888 lambda_slash_no_default[asdl_arg_seq*]:
889 | a[asdl_arg_seq*]=lambda_param_no_default+ '/' ',' { a }
890 | a[asdl_arg_seq*]=lambda_param_no_default+ '/' &':' { a }
891
892 lambda_slash_with_default[SlashWithDefault*]:
893 | a=lambda_param_no_default* b=lambda_param_with_default+ '/' ',' { _PyPegen_slash_with_default(p, (asdl_arg_seq *)a, b) }
894 | a=lambda_param_no_default* b=lambda_param_with_default+ '/' &':' { _PyPegen_slash_with_default(p, (asdl_arg_seq *)a, b) }
895
896 lambda_star_etc[StarEtc*]:
897 | invalid_lambda_star_etc
898 | '*' a=lambda_param_no_default b=lambda_param_maybe_default* c=[lambda_kwds] {
899 _PyPegen_star_etc(p, a, b, c) }
900 | '*' ',' b=lambda_param_maybe_default+ c=[lambda_kwds] {
901 _PyPegen_star_etc(p, NULL, b, c) }
902 | a=lambda_kwds { _PyPegen_star_etc(p, NULL, NULL, a) }
903
904 lambda_kwds[arg_ty]:
905 | invalid_lambda_kwds
906 | '**' a=lambda_param_no_default { a }
907
908 lambda_param_no_default[arg_ty]:
909 | a=lambda_param ',' { a }
910 | a=lambda_param &':' { a }
911 lambda_param_with_default[NameDefaultPair*]:
912 | a=lambda_param c=default ',' { _PyPegen_name_default_pair(p, a, c, NULL) }
913 | a=lambda_param c=default &':' { _PyPegen_name_default_pair(p, a, c, NULL) }
914 lambda_param_maybe_default[NameDefaultPair*]:
915 | a=lambda_param c=default? ',' { _PyPegen_name_default_pair(p, a, c, NULL) }
916 | a=lambda_param c=default? &':' { _PyPegen_name_default_pair(p, a, c, NULL) }
917 lambda_param[arg_ty]: a=NAME { _PyAST_arg(a->v.Name.id, NULL, NULL, EXTRA) }
918
919 # LITERALS
920 # ========
921
922 fstring_middle[expr_ty]:
923 | fstring_replacement_field
924 | t=FSTRING_MIDDLE { _PyPegen_constant_from_token(p, t) }
925 fstring_replacement_field[expr_ty]:
926 | '{' a=annotated_rhs debug_expr='='? conversion=[fstring_conversion] format=[fstring_full_format_spec] rbrace='}' {
927 _PyPegen_formatted_value(p, a, debug_expr, conversion, format, rbrace, EXTRA) }
928 | invalid_replacement_field
929 fstring_conversion[ResultTokenWithMetadata*]:
930 | conv_token="!" conv=NAME { _PyPegen_check_fstring_conversion(p, conv_token, conv) }
931 fstring_full_format_spec[ResultTokenWithMetadata*]:
932 | colon=':' spec=fstring_format_spec* { _PyPegen_setup_full_format_spec(p, colon, (asdl_expr_seq *) spec, EXTRA) }
933 fstring_format_spec[expr_ty]:
934 | t=FSTRING_MIDDLE { _PyPegen_decoded_constant_from_token(p, t) }
935 | fstring_replacement_field
936 fstring[expr_ty]:
937 | a=FSTRING_START b=fstring_middle* c=FSTRING_END { _PyPegen_joined_str(p, a, (asdl_expr_seq*)b, c) }
938
939 string[expr_ty]: s[Token*]=STRING { _PyPegen_constant_from_string(p, s) }
940 strings[expr_ty] (memo): a[asdl_expr_seq*]=(fstring|string)+ { _PyPegen_concatenate_strings(p, a, EXTRA) }
941
942 list[expr_ty]:
943 | '[' a=[star_named_expressions] ']' { _PyAST_List(a, Load, EXTRA) }
944
945 tuple[expr_ty]:
946 | '(' a=[y=star_named_expression ',' z=[star_named_expressions] { _PyPegen_seq_insert_in_front(p, y, z) } ] ')' {
947 _PyAST_Tuple(a, Load, EXTRA) }
948
949 set[expr_ty]: '{' a=star_named_expressions '}' { _PyAST_Set(a, EXTRA) }
950
951 # Dicts
952 # -----
953
954 dict[expr_ty]:
955 | '{' a=[double_starred_kvpairs] '}' {
956 _PyAST_Dict(
957 CHECK(asdl_expr_seq*, _PyPegen_get_keys(p, a)),
958 CHECK(asdl_expr_seq*, _PyPegen_get_values(p, a)),
959 EXTRA) }
960 | '{' invalid_double_starred_kvpairs '}'
961
962 double_starred_kvpairs[asdl_seq*]: a=','.double_starred_kvpair+ [','] { a }
963
964 double_starred_kvpair[KeyValuePair*]:
965 | '**' a=bitwise_or { _PyPegen_key_value_pair(p, NULL, a) }
966 | kvpair
967
968 kvpair[KeyValuePair*]: a=expression ':' b=expression { _PyPegen_key_value_pair(p, a, b) }
969
970 # Comprehensions & Generators
971 # ---------------------------
972
973 for_if_clauses[asdl_comprehension_seq*]:
974 | a[asdl_comprehension_seq*]=for_if_clause+ { a }
975
976 for_if_clause[comprehension_ty]:
977 | 'async' 'for' a=star_targets 'in' ~ b=disjunction c[asdl_expr_seq*]=('if' z=disjunction { z })* {
978 CHECK_VERSION(comprehension_ty, 6, "Async comprehensions are", _PyAST_comprehension(a, b, c, 1, p->arena)) }
979 | 'for' a=star_targets 'in' ~ b=disjunction c[asdl_expr_seq*]=('if' z=disjunction { z })* {
980 _PyAST_comprehension(a, b, c, 0, p->arena) }
981 | 'async'? 'for' (bitwise_or (',' bitwise_or)* [',']) !'in' {
982 RAISE_SYNTAX_ERROR("'in' expected after for-loop variables") }
983 | invalid_for_target
984
985 listcomp[expr_ty]:
986 | '[' a=named_expression b=for_if_clauses ']' { _PyAST_ListComp(a, b, EXTRA) }
987 | invalid_comprehension
988
989 setcomp[expr_ty]:
990 | '{' a=named_expression b=for_if_clauses '}' { _PyAST_SetComp(a, b, EXTRA) }
991 | invalid_comprehension
992
993 genexp[expr_ty]:
994 | '(' a=( assignment_expression | expression !':=') b=for_if_clauses ')' { _PyAST_GeneratorExp(a, b, EXTRA) }
995 | invalid_comprehension
996
997 dictcomp[expr_ty]:
998 | '{' a=kvpair b=for_if_clauses '}' { _PyAST_DictComp(a->key, a->value, b, EXTRA) }
999 | invalid_dict_comprehension
1000
1001 # FUNCTION CALL ARGUMENTS
1002 # =======================
1003
1004 arguments[expr_ty] (memo):
1005 | a=args [','] &')' { a }
1006 | invalid_arguments
1007
1008 args[expr_ty]:
1009 | a[asdl_expr_seq*]=','.(starred_expression | ( assignment_expression | expression !':=') !'=')+ b=[',' k=kwargs {k}] {
1010 _PyPegen_collect_call_seqs(p, a, b, EXTRA) }
1011 | a=kwargs { _PyAST_Call(_PyPegen_dummy_name(p),
1012 CHECK_NULL_ALLOWED(asdl_expr_seq*, _PyPegen_seq_extract_starred_exprs(p, a)),
1013 CHECK_NULL_ALLOWED(asdl_keyword_seq*, _PyPegen_seq_delete_starred_exprs(p, a)),
1014 EXTRA) }
1015
1016 kwargs[asdl_seq*]:
1017 | a=','.kwarg_or_starred+ ',' b=','.kwarg_or_double_starred+ { _PyPegen_join_sequences(p, a, b) }
1018 | ','.kwarg_or_starred+
1019 | ','.kwarg_or_double_starred+
1020
1021 starred_expression[expr_ty]:
1022 | invalid_starred_expression
1023 | '*' a=expression { _PyAST_Starred(a, Load, EXTRA) }
1024 | '*' { RAISE_SYNTAX_ERROR("Invalid star expression") }
1025
1026 kwarg_or_starred[KeywordOrStarred*]:
1027 | invalid_kwarg
1028 | a=NAME '=' b=expression {
1029 _PyPegen_keyword_or_starred(p, CHECK(keyword_ty, _PyAST_keyword(a->v.Name.id, b, EXTRA)), 1) }
1030 | a=starred_expression { _PyPegen_keyword_or_starred(p, a, 0) }
1031
1032 kwarg_or_double_starred[KeywordOrStarred*]:
1033 | invalid_kwarg
1034 | a=NAME '=' b=expression {
1035 _PyPegen_keyword_or_starred(p, CHECK(keyword_ty, _PyAST_keyword(a->v.Name.id, b, EXTRA)), 1) }
1036 | '**' a=expression { _PyPegen_keyword_or_starred(p, CHECK(keyword_ty, _PyAST_keyword(NULL, a, EXTRA)), 1) }
1037
1038 # ASSIGNMENT TARGETS
1039 # ==================
1040
1041 # Generic targets
1042 # ---------------
1043
1044 # NOTE: star_targets may contain *bitwise_or, targets may not.
1045 star_targets[expr_ty]:
1046 | a=star_target !',' { a }
1047 | a=star_target b=(',' c=star_target { c })* [','] {
1048 _PyAST_Tuple(CHECK(asdl_expr_seq*, _PyPegen_seq_insert_in_front(p, a, b)), Store, EXTRA) }
1049
1050 star_targets_list_seq[asdl_expr_seq*]: a[asdl_expr_seq*]=','.star_target+ [','] { a }
1051
1052 star_targets_tuple_seq[asdl_expr_seq*]:
1053 | a=star_target b=(',' c=star_target { c })+ [','] { (asdl_expr_seq*) _PyPegen_seq_insert_in_front(p, a, b) }
1054 | a=star_target ',' { (asdl_expr_seq*) _PyPegen_singleton_seq(p, a) }
1055
1056 star_target[expr_ty] (memo):
1057 | '*' a=(!'*' star_target) {
1058 _PyAST_Starred(CHECK(expr_ty, _PyPegen_set_expr_context(p, a, Store)), Store, EXTRA) }
1059 | target_with_star_atom
1060
1061 target_with_star_atom[expr_ty] (memo):
1062 | a=t_primary '.' b=NAME !t_lookahead { _PyAST_Attribute(a, b->v.Name.id, Store, EXTRA) }
1063 | a=t_primary '[' b=slices ']' !t_lookahead { _PyAST_Subscript(a, b, Store, EXTRA) }
1064 | star_atom
1065
1066 star_atom[expr_ty]:
1067 | a=NAME { _PyPegen_set_expr_context(p, a, Store) }
1068 | '(' a=target_with_star_atom ')' { _PyPegen_set_expr_context(p, a, Store) }
1069 | '(' a=[star_targets_tuple_seq] ')' { _PyAST_Tuple(a, Store, EXTRA) }
1070 | '[' a=[star_targets_list_seq] ']' { _PyAST_List(a, Store, EXTRA) }
1071
1072 single_target[expr_ty]:
1073 | single_subscript_attribute_target
1074 | a=NAME { _PyPegen_set_expr_context(p, a, Store) }
1075 | '(' a=single_target ')' { a }
1076
1077 single_subscript_attribute_target[expr_ty]:
1078 | a=t_primary '.' b=NAME !t_lookahead { _PyAST_Attribute(a, b->v.Name.id, Store, EXTRA) }
1079 | a=t_primary '[' b=slices ']' !t_lookahead { _PyAST_Subscript(a, b, Store, EXTRA) }
1080
1081 t_primary[expr_ty]:
1082 | a=t_primary '.' b=NAME &t_lookahead { _PyAST_Attribute(a, b->v.Name.id, Load, EXTRA) }
1083 | a=t_primary '[' b=slices ']' &t_lookahead { _PyAST_Subscript(a, b, Load, EXTRA) }
1084 | a=t_primary b=genexp &t_lookahead {
1085 _PyAST_Call(a, CHECK(asdl_expr_seq*, (asdl_expr_seq*)_PyPegen_singleton_seq(p, b)), NULL, EXTRA) }
1086 | a=t_primary '(' b=[arguments] ')' &t_lookahead {
1087 _PyAST_Call(a,
1088 (b) ? ((expr_ty) b)->v.Call.args : NULL,
1089 (b) ? ((expr_ty) b)->v.Call.keywords : NULL,
1090 EXTRA) }
1091 | a=atom &t_lookahead { a }
1092
1093 t_lookahead: '(' | '[' | '.'
1094
1095 # Targets for del statements
1096 # --------------------------
1097
1098 del_targets[asdl_expr_seq*]: a[asdl_expr_seq*]=','.del_target+ [','] { a }
1099
1100 del_target[expr_ty] (memo):
1101 | a=t_primary '.' b=NAME !t_lookahead { _PyAST_Attribute(a, b->v.Name.id, Del, EXTRA) }
1102 | a=t_primary '[' b=slices ']' !t_lookahead { _PyAST_Subscript(a, b, Del, EXTRA) }
1103 | del_t_atom
1104
1105 del_t_atom[expr_ty]:
1106 | a=NAME { _PyPegen_set_expr_context(p, a, Del) }
1107 | '(' a=del_target ')' { _PyPegen_set_expr_context(p, a, Del) }
1108 | '(' a=[del_targets] ')' { _PyAST_Tuple(a, Del, EXTRA) }
1109 | '[' a=[del_targets] ']' { _PyAST_List(a, Del, EXTRA) }
1110
1111 # TYPING ELEMENTS
1112 # ---------------
1113
1114 # type_expressions allow */** but ignore them
1115 type_expressions[asdl_expr_seq*]:
1116 | a=','.expression+ ',' '*' b=expression ',' '**' c=expression {
1117 (asdl_expr_seq*)_PyPegen_seq_append_to_end(
1118 p,
1119 CHECK(asdl_seq*, _PyPegen_seq_append_to_end(p, a, b)),
1120 c) }
1121 | a=','.expression+ ',' '*' b=expression { (asdl_expr_seq*)_PyPegen_seq_append_to_end(p, a, b) }
1122 | a=','.expression+ ',' '**' b=expression { (asdl_expr_seq*)_PyPegen_seq_append_to_end(p, a, b) }
1123 | '*' a=expression ',' '**' b=expression {
1124 (asdl_expr_seq*)_PyPegen_seq_append_to_end(
1125 p,
1126 CHECK(asdl_seq*, _PyPegen_singleton_seq(p, a)),
1127 b) }
1128 | '*' a=expression { (asdl_expr_seq*)_PyPegen_singleton_seq(p, a) }
1129 | '**' a=expression { (asdl_expr_seq*)_PyPegen_singleton_seq(p, a) }
1130 | a[asdl_expr_seq*]=','.expression+ {a}
1131
1132 func_type_comment[Token*]:
1133 | NEWLINE t=TYPE_COMMENT &(NEWLINE INDENT) { t } # Must be followed by indented block
1134 | invalid_double_type_comments
1135 | TYPE_COMMENT
1136
1137 # ========================= END OF THE GRAMMAR ===========================
1138
1139
1140
1141 # ========================= START OF INVALID RULES =======================
1142
1143 # From here on, there are rules for invalid syntax with specialised error messages
1144 invalid_arguments:
1145 | ((','.(starred_expression | ( assignment_expression | expression !':=') !'=')+ ',' kwargs) | kwargs) a=',' ','.(starred_expression !'=')+ {
1146 RAISE_SYNTAX_ERROR_STARTING_FROM(a, "iterable argument unpacking follows keyword argument unpacking") }
1147 | a=expression b=for_if_clauses ',' [args | expression for_if_clauses] {
1148 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, _PyPegen_get_last_comprehension_item(PyPegen_last_item(b, comprehension_ty)), "Generator expression must be parenthesized") }
1149 | a=NAME b='=' expression for_if_clauses {
1150 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "invalid syntax. Maybe you meant '==' or ':=' instead of '='?")}
1151 | (args ',')? a=NAME b='=' &(',' | ')') {
1152 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "expected argument value expression")}
1153 | a=args b=for_if_clauses { _PyPegen_nonparen_genexp_in_call(p, a, b) }
1154 | args ',' a=expression b=for_if_clauses {
1155 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, _PyPegen_get_last_comprehension_item(PyPegen_last_item(b, comprehension_ty)), "Generator expression must be parenthesized") }
1156 | a=args ',' args { _PyPegen_arguments_parsing_error(p, a) }
1157 invalid_kwarg:
1158 | a[Token*]=('True'|'False'|'None') b='=' {
1159 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot assign to %s", PyBytes_AS_STRING(a->bytes)) }
1160 | a=NAME b='=' expression for_if_clauses {
1161 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "invalid syntax. Maybe you meant '==' or ':=' instead of '='?")}
1162 | !(NAME '=') a=expression b='=' {
1163 RAISE_SYNTAX_ERROR_KNOWN_RANGE(
1164 a, b, "expression cannot contain assignment, perhaps you meant \"==\"?") }
1165 | a='**' expression '=' b=expression {
1166 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot assign to keyword argument unpacking") }
1167
1168 # IMPORTANT: Note that the "_without_invalid" suffix causes the rule to not call invalid rules under it
1169 expression_without_invalid[expr_ty]:
1170 | a=disjunction 'if' b=disjunction 'else' c=expression { _PyAST_IfExp(b, a, c, EXTRA) }
1171 | disjunction
1172 | lambdef
1173 invalid_legacy_expression:
1174 | a=NAME !'(' b=star_expressions {
1175 _PyPegen_check_legacy_stmt(p, a) ? RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b,
1176 "Missing parentheses in call to '%U'. Did you mean %U(...)?", a->v.Name.id, a->v.Name.id) : NULL}
1177
1178 invalid_expression:
1179 # !(NAME STRING) is not matched so we don't show this error with some invalid string prefixes like: kf"dsfsdf"
1180 # Soft keywords need to also be ignored because they can be parsed as NAME NAME
1181 | !(NAME STRING | SOFT_KEYWORD) a=disjunction b=expression_without_invalid {
1182 _PyPegen_check_legacy_stmt(p, a) ? NULL : p->tokens[p->mark-1]->level == 0 ? NULL :
1183 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "invalid syntax. Perhaps you forgot a comma?") }
1184 | a=disjunction 'if' b=disjunction !('else'|':') { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "expected 'else' after 'if' expression") }
1185 | a='lambda' [lambda_params] b=':' &FSTRING_MIDDLE {
1186 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "f-string: lambda expressions are not allowed without parentheses") }
1187
1188 invalid_named_expression(memo):
1189 | a=expression ':=' expression {
1190 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(
1191 a, "cannot use assignment expressions with %s", _PyPegen_get_expr_name(a)) }
1192 | a=NAME '=' b=bitwise_or !('='|':=') {
1193 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "invalid syntax. Maybe you meant '==' or ':=' instead of '='?") }
1194 | !(list|tuple|genexp|'True'|'None'|'False') a=bitwise_or b='=' bitwise_or !('='|':=') {
1195 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot assign to %s here. Maybe you meant '==' instead of '='?",
1196 _PyPegen_get_expr_name(a)) }
1197
1198 invalid_assignment:
1199 | a=invalid_ann_assign_target ':' expression {
1200 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(
1201 a,
1202 "only single target (not %s) can be annotated",
1203 _PyPegen_get_expr_name(a)
1204 )}
1205 | a=star_named_expression ',' star_named_expressions* ':' expression {
1206 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "only single target (not tuple) can be annotated") }
1207 | a=expression ':' expression {
1208 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "illegal target for annotation") }
1209 | (star_targets '=')* a=star_expressions '=' {
1210 RAISE_SYNTAX_ERROR_INVALID_TARGET(STAR_TARGETS, a) }
1211 | (star_targets '=')* a=yield_expr '=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "assignment to yield expression not possible") }
1212 | a=star_expressions augassign annotated_rhs {
1213 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(
1214 a,
1215 "'%s' is an illegal expression for augmented assignment",
1216 _PyPegen_get_expr_name(a)
1217 )}
1218 invalid_ann_assign_target[expr_ty]:
1219 | list
1220 | tuple
1221 | '(' a=invalid_ann_assign_target ')' { a }
1222 invalid_del_stmt:
1223 | 'del' a=star_expressions {
1224 RAISE_SYNTAX_ERROR_INVALID_TARGET(DEL_TARGETS, a) }
1225 invalid_block:
1226 | NEWLINE !INDENT { RAISE_INDENTATION_ERROR("expected an indented block") }
1227 invalid_comprehension:
1228 | ('[' | '(' | '{') a=starred_expression for_if_clauses {
1229 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "iterable unpacking cannot be used in comprehension") }
1230 | ('[' | '{') a=star_named_expression ',' b=star_named_expressions for_if_clauses {
1231 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, PyPegen_last_item(b, expr_ty),
1232 "did you forget parentheses around the comprehension target?") }
1233 | ('[' | '{') a=star_named_expression b=',' for_if_clauses {
1234 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "did you forget parentheses around the comprehension target?") }
1235 invalid_dict_comprehension:
1236 | '{' a='**' bitwise_or for_if_clauses '}' {
1237 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "dict unpacking cannot be used in dict comprehension") }
1238 invalid_parameters:
1239 | a="/" ',' {
1240 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "at least one argument must precede /") }
1241 | (slash_no_default | slash_with_default) param_maybe_default* a='/' {
1242 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "/ may appear only once") }
1243 | slash_no_default? param_no_default* invalid_parameters_helper a=param_no_default {
1244 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "parameter without a default follows parameter with a default") }
1245 | param_no_default* a='(' param_no_default+ ','? b=')' {
1246 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "Function parameters cannot be parenthesized") }
1247 | (slash_no_default | slash_with_default)? param_maybe_default* '*' (',' | param_no_default) param_maybe_default* a='/' {
1248 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "/ must be ahead of *") }
1249 | param_maybe_default+ '/' a='*' {
1250 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "expected comma between / and *") }
1251 invalid_default:
1252 | a='=' &(')'|',') { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "expected default value expression") }
1253 invalid_star_etc:
1254 | a='*' (')' | ',' (')' | '**')) { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "named arguments must follow bare *") }
1255 | '*' ',' TYPE_COMMENT { RAISE_SYNTAX_ERROR("bare * has associated type comment") }
1256 | '*' param a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "var-positional argument cannot have default value") }
1257 | '*' (param_no_default | ',') param_maybe_default* a='*' (param_no_default | ',') {
1258 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "* argument may appear only once") }
1259 invalid_kwds:
1260 | '**' param a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "var-keyword argument cannot have default value") }
1261 | '**' param ',' a=param { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "arguments cannot follow var-keyword argument") }
1262 | '**' param ',' a[Token*]=('*'|'**'|'/') { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "arguments cannot follow var-keyword argument") }
1263 invalid_parameters_helper: # This is only there to avoid type errors
1264 | a=slash_with_default { _PyPegen_singleton_seq(p, a) }
1265 | param_with_default+
1266 invalid_lambda_parameters:
1267 | a="/" ',' {
1268 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "at least one argument must precede /") }
1269 | (lambda_slash_no_default | lambda_slash_with_default) lambda_param_maybe_default* a='/' {
1270 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "/ may appear only once") }
1271 | lambda_slash_no_default? lambda_param_no_default* invalid_lambda_parameters_helper a=lambda_param_no_default {
1272 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "parameter without a default follows parameter with a default") }
1273 | lambda_param_no_default* a='(' ','.lambda_param+ ','? b=')' {
1274 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "Lambda expression parameters cannot be parenthesized") }
1275 | (lambda_slash_no_default | lambda_slash_with_default)? lambda_param_maybe_default* '*' (',' | lambda_param_no_default) lambda_param_maybe_default* a='/' {
1276 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "/ must be ahead of *") }
1277 | lambda_param_maybe_default+ '/' a='*' {
1278 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "expected comma between / and *") }
1279 invalid_lambda_parameters_helper:
1280 | a=lambda_slash_with_default { _PyPegen_singleton_seq(p, a) }
1281 | lambda_param_with_default+
1282 invalid_lambda_star_etc:
1283 | '*' (':' | ',' (':' | '**')) { RAISE_SYNTAX_ERROR("named arguments must follow bare *") }
1284 | '*' lambda_param a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "var-positional argument cannot have default value") }
1285 | '*' (lambda_param_no_default | ',') lambda_param_maybe_default* a='*' (lambda_param_no_default | ',') {
1286 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "* argument may appear only once") }
1287 invalid_lambda_kwds:
1288 | '**' lambda_param a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "var-keyword argument cannot have default value") }
1289 | '**' lambda_param ',' a=lambda_param { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "arguments cannot follow var-keyword argument") }
1290 | '**' lambda_param ',' a[Token*]=('*'|'**'|'/') { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "arguments cannot follow var-keyword argument") }
1291 invalid_double_type_comments:
1292 | TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT {
1293 RAISE_SYNTAX_ERROR("Cannot have two type comments on def") }
1294 invalid_with_item:
1295 | expression 'as' a=expression &(',' | ')' | ':') {
1296 RAISE_SYNTAX_ERROR_INVALID_TARGET(STAR_TARGETS, a) }
1297
1298 invalid_for_target:
1299 | 'async'? 'for' a=star_expressions {
1300 RAISE_SYNTAX_ERROR_INVALID_TARGET(FOR_TARGETS, a) }
1301
1302 invalid_group:
1303 | '(' a=starred_expression ')' {
1304 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot use starred expression here") }
1305 | '(' a='**' expression ')' {
1306 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot use double starred expression here") }
1307 invalid_import:
1308 | a='import' ','.dotted_name+ 'from' dotted_name {
1309 RAISE_SYNTAX_ERROR_STARTING_FROM(a, "Did you mean to use 'from ... import ...' instead?") }
1310 | 'import' token=NEWLINE {
1311 RAISE_SYNTAX_ERROR_STARTING_FROM(token, "Expected one or more names after 'import'") }
1312
1313 invalid_import_from_targets:
1314 | import_from_as_names ',' NEWLINE {
1315 RAISE_SYNTAX_ERROR("trailing comma not allowed without surrounding parentheses") }
1316 | token=NEWLINE {
1317 RAISE_SYNTAX_ERROR_STARTING_FROM(token, "Expected one or more names after 'import'") }
1318
1319 invalid_with_stmt:
1320 | ['async'] 'with' ','.(expression ['as' star_target])+ NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") }
1321 | ['async'] 'with' '(' ','.(expressions ['as' star_target])+ ','? ')' NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") }
1322 invalid_with_stmt_indent:
1323 | ['async'] a='with' ','.(expression ['as' star_target])+ ':' NEWLINE !INDENT {
1324 RAISE_INDENTATION_ERROR("expected an indented block after 'with' statement on line %d", a->lineno) }
1325 | ['async'] a='with' '(' ','.(expressions ['as' star_target])+ ','? ')' ':' NEWLINE !INDENT {
1326 RAISE_INDENTATION_ERROR("expected an indented block after 'with' statement on line %d", a->lineno) }
1327
1328 invalid_try_stmt:
1329 | a='try' ':' NEWLINE !INDENT {
1330 RAISE_INDENTATION_ERROR("expected an indented block after 'try' statement on line %d", a->lineno) }
1331 | 'try' ':' block !('except' | 'finally') { RAISE_SYNTAX_ERROR("expected 'except' or 'finally' block") }
1332 | 'try' ':' block* except_block+ a='except' b='*' expression ['as' NAME] ':' {
1333 RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot have both 'except' and 'except*' on the same 'try'") }
1334 | 'try' ':' block* except_star_block+ a='except' [expression ['as' NAME]] ':' {
1335 RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot have both 'except' and 'except*' on the same 'try'") }
1336 invalid_except_stmt:
1337 | 'except' '*'? a=expression ',' expressions ['as' NAME ] ':' {
1338 RAISE_SYNTAX_ERROR_STARTING_FROM(a, "multiple exception types must be parenthesized") }
1339 | a='except' '*'? expression ['as' NAME ] NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") }
1340 | a='except' NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") }
1341 | a='except' '*' (NEWLINE | ':') { RAISE_SYNTAX_ERROR("expected one or more exception types") }
1342 invalid_finally_stmt:
1343 | a='finally' ':' NEWLINE !INDENT {
1344 RAISE_INDENTATION_ERROR("expected an indented block after 'finally' statement on line %d", a->lineno) }
1345 invalid_except_stmt_indent:
1346 | a='except' expression ['as' NAME ] ':' NEWLINE !INDENT {
1347 RAISE_INDENTATION_ERROR("expected an indented block after 'except' statement on line %d", a->lineno) }
1348 | a='except' ':' NEWLINE !INDENT { RAISE_INDENTATION_ERROR("expected an indented block after 'except' statement on line %d", a->lineno) }
1349 invalid_except_star_stmt_indent:
1350 | a='except' '*' expression ['as' NAME ] ':' NEWLINE !INDENT {
1351 RAISE_INDENTATION_ERROR("expected an indented block after 'except*' statement on line %d", a->lineno) }
1352 invalid_match_stmt:
1353 | "match" subject_expr NEWLINE { CHECK_VERSION(void*, 10, "Pattern matching is", RAISE_SYNTAX_ERROR("expected ':'") ) }
1354 | a="match" subject=subject_expr ':' NEWLINE !INDENT {
1355 RAISE_INDENTATION_ERROR("expected an indented block after 'match' statement on line %d", a->lineno) }
1356 invalid_case_block:
1357 | "case" patterns guard? NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") }
1358 | a="case" patterns guard? ':' NEWLINE !INDENT {
1359 RAISE_INDENTATION_ERROR("expected an indented block after 'case' statement on line %d", a->lineno) }
1360 invalid_as_pattern:
1361 | or_pattern 'as' a="_" { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot use '_' as a target") }
1362 | or_pattern 'as' !NAME a=expression { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "invalid pattern target") }
1363 invalid_class_pattern:
1364 | name_or_attr '(' a=invalid_class_argument_pattern { RAISE_SYNTAX_ERROR_KNOWN_RANGE(
1365 PyPegen_first_item(a, pattern_ty),
1366 PyPegen_last_item(a, pattern_ty),
1367 "positional patterns follow keyword patterns") }
1368 invalid_class_argument_pattern[asdl_pattern_seq*]:
1369 | [positional_patterns ','] keyword_patterns ',' a=positional_patterns { a }
1370 invalid_if_stmt:
1371 | 'if' named_expression NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") }
1372 | a='if' a=named_expression ':' NEWLINE !INDENT {
1373 RAISE_INDENTATION_ERROR("expected an indented block after 'if' statement on line %d", a->lineno) }
1374 invalid_elif_stmt:
1375 | 'elif' named_expression NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") }
1376 | a='elif' named_expression ':' NEWLINE !INDENT {
1377 RAISE_INDENTATION_ERROR("expected an indented block after 'elif' statement on line %d", a->lineno) }
1378 invalid_else_stmt:
1379 | a='else' ':' NEWLINE !INDENT {
1380 RAISE_INDENTATION_ERROR("expected an indented block after 'else' statement on line %d", a->lineno) }
1381 invalid_while_stmt:
1382 | 'while' named_expression NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") }
1383 | a='while' named_expression ':' NEWLINE !INDENT {
1384 RAISE_INDENTATION_ERROR("expected an indented block after 'while' statement on line %d", a->lineno) }
1385 invalid_for_stmt:
1386 | ['async'] 'for' star_targets 'in' star_expressions NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") }
1387 | ['async'] a='for' star_targets 'in' star_expressions ':' NEWLINE !INDENT {
1388 RAISE_INDENTATION_ERROR("expected an indented block after 'for' statement on line %d", a->lineno) }
1389 invalid_def_raw:
1390 | ['async'] a='def' NAME [type_params] '(' [params] ')' ['->' expression] ':' NEWLINE !INDENT {
1391 RAISE_INDENTATION_ERROR("expected an indented block after function definition on line %d", a->lineno) }
1392 | ['async'] 'def' NAME [type_params] &&'(' [params] ')' ['->' expression] &&':' [func_type_comment] block
1393 invalid_class_def_raw:
1394 | 'class' NAME [type_params] ['(' [arguments] ')'] NEWLINE { RAISE_SYNTAX_ERROR("expected ':'") }
1395 | a='class' NAME [type_params] ['(' [arguments] ')'] ':' NEWLINE !INDENT {
1396 RAISE_INDENTATION_ERROR("expected an indented block after class definition on line %d", a->lineno) }
1397
1398 invalid_double_starred_kvpairs:
1399 | ','.double_starred_kvpair+ ',' invalid_kvpair
1400 | expression ':' a='*' bitwise_or { RAISE_SYNTAX_ERROR_STARTING_FROM(a, "cannot use a starred expression in a dictionary value") }
1401 | expression a=':' &('}'|',') { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "expression expected after dictionary key and ':'") }
1402 invalid_kvpair:
1403 | a=expression !(':') {
1404 RAISE_ERROR_KNOWN_LOCATION(p, PyExc_SyntaxError, a->lineno, a->end_col_offset - 1, a->end_lineno, -1, "':' expected after dictionary key") }
1405 | expression ':' a='*' bitwise_or { RAISE_SYNTAX_ERROR_STARTING_FROM(a, "cannot use a starred expression in a dictionary value") }
1406 | expression a=':' &('}'|',') {RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "expression expected after dictionary key and ':'") }
1407 invalid_starred_expression:
1408 | a='*' expression '=' b=expression { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot assign to iterable argument unpacking") }
1409
1410 invalid_replacement_field:
1411 | '{' a='=' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '='") }
1412 | '{' a='!' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '!'") }
1413 | '{' a=':' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before ':'") }
1414 | '{' a='}' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "f-string: valid expression required before '}'") }
1415 | '{' !annotated_rhs { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting a valid expression after '{'")}
1416 | '{' annotated_rhs !('=' | '!' | ':' | '}') {
1417 PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '=', or '!', or ':', or '}'") }
1418 | '{' annotated_rhs '=' !('!' | ':' | '}') {
1419 PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '!', or ':', or '}'") }
1420 | '{' annotated_rhs '='? invalid_conversion_character
1421 | '{' annotated_rhs '='? ['!' NAME] !(':' | '}') {
1422 PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting ':' or '}'") }
1423 | '{' annotated_rhs '='? ['!' NAME] ':' fstring_format_spec* !'}' {
1424 PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '}', or format specs") }
1425 | '{' annotated_rhs '='? ['!' NAME] !'}' {
1426 PyErr_Occurred() ? NULL : RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: expecting '}'") }
1427
1428 invalid_conversion_character:
1429 | '!' &(':' | '}') { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: missing conversion character") }
1430 | '!' !NAME { RAISE_SYNTAX_ERROR_ON_NEXT_TOKEN("f-string: invalid conversion character") }
1431
1432 invalid_arithmetic:
1433 | sum ('+'|'-'|'*'|'/'|'%'|'//'|'@') a='not' b=inversion { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "'not' after an operator must be parenthesized") }
1434 invalid_factor:
1435 | ('+' | '-' | '~') a='not' b=factor { RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "'not' after an operator must be parenthesized") }
1436
1437 invalid_type_params:
1438 | '[' token=']' {
1439 RAISE_SYNTAX_ERROR_STARTING_FROM(
1440 token,
1441 "Type parameter list cannot be empty")}