From 0dfaa2252cfa9794bebd8bb5c48aadf783795a73 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 15 May 2020 15:05:43 +0300 Subject: [PATCH 01/17] bpo-40334: Produce better error messages on invalid targets The following error messages get produced: - `cannot delete ...` for invalid `del` targets - `... is an illegal 'for' target` for invalid targets in for statements - `... is an illegal 'with' target` for invalid targets in with statements Additionally a few `cut`s were added in various places before the invocation of the `invalid_*` rule, in order to speed things up. --- Grammar/python.gram | 75 +- Lib/test/test_syntax.py | 43 + Parser/pegen/parse.c | 1968 +++++++++++++++++++++------------------ Parser/pegen/pegen.c | 13 +- Parser/pegen/pegen.h | 5 +- 5 files changed, 1164 insertions(+), 940 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index cca92090546265..d98667e75c9479 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -92,9 +92,9 @@ assignment[stmt_ty]: | a=('(' b=single_target ')' { b } | single_subscript_attribute_target) ':' b=expression c=['=' d=annotated_rhs { d }] { CHECK_VERSION(6, "Variable annotations syntax is", _Py_AnnAssign(a, b, c, 0, EXTRA)) } - | a=(z=star_targets '=' { z })+ b=(yield_expr | star_expressions) tc=[TYPE_COMMENT] { + | a=(z=star_targets '=' { z })+ ~ b=(yield_expr | star_expressions) tc=[TYPE_COMMENT] { _Py_Assign(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA) } - | a=single_target b=augassign c=(yield_expr | star_expressions) { + | a=single_target b=augassign ~ c=(yield_expr | star_expressions) { _Py_AugAssign(a, b->kind, c, EXTRA) } | invalid_assignment @@ -122,7 +122,9 @@ yield_stmt[stmt_ty]: y=yield_expr { _Py_Expr(y, EXTRA) } assert_stmt[stmt_ty]: 'assert' a=expression b=[',' z=expression { z }] { _Py_Assert(a, b, EXTRA) } -del_stmt[stmt_ty]: 'del' a=del_targets { _Py_Delete(a, EXTRA) } +del_stmt[stmt_ty]: + | 'del' a=del_targets &(';' | NEWLINE) { _Py_Delete(a, EXTRA) } + | invalid_del_stmt import_stmt[stmt_ty]: import_name | import_from import_name[stmt_ty]: 'import' a=dotted_as_names { _Py_Import(a, EXTRA) } @@ -164,10 +166,11 @@ while_stmt[stmt_ty]: | 'while' a=named_expression ':' b=block c=[else_block] { _Py_While(a, b, c, EXTRA) } for_stmt[stmt_ty]: - | 'for' t=star_targets 'in' ex=star_expressions ':' tc=[TYPE_COMMENT] b=block el=[else_block] { + | 'for' t=star_targets 'in' ~ ex=star_expressions ':' tc=[TYPE_COMMENT] b=block el=[else_block] { _Py_For(t, ex, b, el, NEW_TYPE_COMMENT(p, tc), EXTRA) } - | ASYNC 'for' t=star_targets 'in' ex=star_expressions ':' tc=[TYPE_COMMENT] b=block el=[else_block] { + | ASYNC 'for' t=star_targets 'in' ~ ex=star_expressions ':' tc=[TYPE_COMMENT] b=block el=[else_block] { CHECK_VERSION(5, "Async for loops are", _Py_AsyncFor(t, ex, b, el, NEW_TYPE_COMMENT(p, tc), EXTRA)) } + | invalid_for_target with_stmt[stmt_ty]: | 'with' '(' a=','.with_item+ ','? ')' ':' b=block { @@ -178,6 +181,7 @@ with_stmt[stmt_ty]: CHECK_VERSION(5, "Async with statements are", _Py_AsyncWith(a, b, NULL, EXTRA)) } | ASYNC 'with' a=','.with_item+ ':' tc=[TYPE_COMMENT] b=block { CHECK_VERSION(5, "Async with statements are", _Py_AsyncWith(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA)) } + | invalid_with_target with_item[withitem_ty]: | e=expression o=['as' t=target { t }] { _Py_withitem(e, o, p->arena) } @@ -311,7 +315,7 @@ star_named_expression[expr_ty]: | '*' a=bitwise_or { _Py_Starred(a, Load, EXTRA) } | named_expression named_expression[expr_ty]: - | a=NAME ':=' b=expression { _Py_NamedExpr(CHECK(_PyPegen_set_expr_context(p, a, Store)), b, EXTRA) } + | a=NAME ':=' ~ b=expression { _Py_NamedExpr(CHECK(_PyPegen_set_expr_context(p, a, Store)), b, EXTRA) } | expression !':=' | invalid_named_expression @@ -484,18 +488,18 @@ strings[expr_ty] (memo): a=STRING+ { _PyPegen_concatenate_strings(p, a) } list[expr_ty]: | '[' a=[star_named_expressions] ']' { _Py_List(a, Load, EXTRA) } listcomp[expr_ty]: - | '[' a=named_expression b=for_if_clauses ']' { _Py_ListComp(a, b, EXTRA) } + | '[' a=named_expression ~ b=for_if_clauses ']' { _Py_ListComp(a, b, EXTRA) } | invalid_comprehension tuple[expr_ty]: | '(' a=[y=star_named_expression ',' z=[star_named_expressions] { _PyPegen_seq_insert_in_front(p, y, z) } ] ')' { _Py_Tuple(a, Load, EXTRA) } group[expr_ty]: '(' a=(yield_expr | named_expression) ')' { a } genexp[expr_ty]: - | '(' a=expression b=for_if_clauses ')' { _Py_GeneratorExp(a, b, EXTRA) } + | '(' a=expression ~ b=for_if_clauses ')' { _Py_GeneratorExp(a, b, EXTRA) } | invalid_comprehension set[expr_ty]: '{' a=expressions_list '}' { _Py_Set(a, EXTRA) } setcomp[expr_ty]: - | '{' a=expression b=for_if_clauses '}' { _Py_SetComp(a, b, EXTRA) } + | '{' a=expression ~ b=for_if_clauses '}' { _Py_SetComp(a, b, EXTRA) } | invalid_comprehension dict[expr_ty]: | '{' a=[kvpairs] '}' { _Py_Dict(CHECK(_PyPegen_get_keys(p, a)), @@ -509,10 +513,11 @@ kvpair[KeyValuePair*]: for_if_clauses[asdl_seq*]: | for_if_clause+ for_if_clause[comprehension_ty]: - | ASYNC 'for' a=star_targets 'in' b=disjunction c=('if' z=disjunction { z })* { + | ASYNC 'for' a=star_targets 'in' ~ b=disjunction c=('if' z=disjunction { z })* { CHECK_VERSION(6, "Async comprehensions are", _Py_comprehension(a, b, c, 1, p->arena)) } - | 'for' a=star_targets 'in' b=disjunction c=('if' z=disjunction { z })* { + | 'for' a=star_targets 'in' ~ b=disjunction c=('if' z=disjunction { z })* { _Py_comprehension(a, b, c, 0, p->arena) } + | invalid_for_target yield_expr[expr_ty]: | 'yield' 'from' a=expression { _Py_YieldFrom(a, EXTRA) } @@ -582,19 +587,15 @@ single_subscript_attribute_target[expr_ty]: | a=t_primary '[' b=slices ']' !t_lookahead { _Py_Subscript(a, b, Store, EXTRA) } del_targets[asdl_seq*]: a=','.del_target+ [','] { a } -# The lookaheads to del_target_end ensure that we don't match expressions where a prefix of the -# expression matches our rule, thereby letting these cases fall through to invalid_del_target. del_target[expr_ty] (memo): - | a=t_primary '.' b=NAME &del_target_end { _Py_Attribute(a, b->v.Name.id, Del, EXTRA) } - | a=t_primary '[' b=slices ']' &del_target_end { _Py_Subscript(a, b, Del, EXTRA) } + | a=t_primary '.' b=NAME !t_lookahead { _Py_Attribute(a, b->v.Name.id, Del, EXTRA) } + | a=t_primary '[' b=slices ']' !t_lookahead { _Py_Subscript(a, b, Del, EXTRA) } | del_t_atom del_t_atom[expr_ty]: - | a=NAME &del_target_end { _PyPegen_set_expr_context(p, a, Del) } + | a=NAME { _PyPegen_set_expr_context(p, a, Del) } | '(' a=del_target ')' { _PyPegen_set_expr_context(p, a, Del) } | '(' a=[del_targets] ')' { _Py_Tuple(a, Del, EXTRA) } | '[' a=[del_targets] ']' { _Py_List(a, Del, EXTRA) } - | invalid_del_target -del_target_end: ')' | ']' | ',' | ';' | NEWLINE targets[asdl_seq*]: a=','.target+ [','] { a } target[expr_ty] (memo): @@ -642,15 +643,28 @@ invalid_assignment: RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "illegal target for annotation") } | a=star_expressions '=' (yield_expr | star_expressions) { RAISE_SYNTAX_ERROR_KNOWN_LOCATION( - _PyPegen_get_invalid_target(a), - "cannot assign to %s", _PyPegen_get_expr_name(_PyPegen_get_invalid_target(a))) } + GET_INVALID_TARGET(a), + "cannot assign to %s", _PyPegen_get_expr_name(GET_INVALID_TARGET(a))) } | a=star_expressions augassign (yield_expr | star_expressions) { RAISE_SYNTAX_ERROR_KNOWN_LOCATION( a, "'%s' is an illegal expression for augmented assignment", _PyPegen_get_expr_name(a) )} - +invalid_del_stmt: + | 'del' a=star_expressions { + GET_INVALID_DEL_TARGET(a) != NULL ? + RAISE_SYNTAX_ERROR_KNOWN_LOCATION( + GET_INVALID_DEL_TARGET(a), + "cannot delete %s", _PyPegen_get_expr_name(GET_INVALID_DEL_TARGET(a)) + ) : + RAISE_SYNTAX_ERROR("invalid syntax") } + # This additional alternative is necessary, because (*a) is not a valid star_expression + # and will not be caught by the previous one. + | 'del' '(' a=starred_expression ')' { + RAISE_SYNTAX_ERROR_KNOWN_LOCATION( + a, + "cannot delete starred") } invalid_block: | NEWLINE !INDENT { RAISE_INDENTATION_ERROR("expected an indented block") } invalid_comprehension: @@ -666,6 +680,19 @@ invalid_lambda_star_etc: invalid_double_type_comments: | TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT { RAISE_SYNTAX_ERROR("Cannot have two type comments on def") } -invalid_del_target: - | a=star_expression &del_target_end { - RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "cannot delete %s", _PyPegen_get_expr_name(a)) } +invalid_with_target: + | ASYNC? 'with' expression 'as' a=expressions ':' { + RAISE_SYNTAX_ERROR_KNOWN_LOCATION( + GET_INVALID_TARGET(a), + "'%s' is an illegal 'with' target", _PyPegen_get_expr_name(GET_INVALID_TARGET(a)) + ) } + +# Comparison is used here, because the `a() in b` in `for a() in b: pass` is parsed +# as a comparison. Thus, we only need to search the left side of the comparison +# for invalid targets. +invalid_for_target: + | ASYNC? 'for' a=comparison { + RAISE_SYNTAX_ERROR_KNOWN_LOCATION( + GET_INVALID_TARGET(a->v.Compare.left), + "'%s' is an illegal 'for' target", _PyPegen_get_expr_name(GET_INVALID_TARGET(a->v.Compare.left)) + ) } diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py index 60c7d9fd3868e8..49d6c796b42ecb 100644 --- a/Lib/test/test_syntax.py +++ b/Lib/test/test_syntax.py @@ -148,6 +148,49 @@ Traceback (most recent call last): SyntaxError: 'list' is an illegal expression for augmented assignment +Invalid targets in `for` loops and `with` statements should also +produce a specialized error message + +>>> for a() in b: pass +Traceback (most recent call last): +SyntaxError: 'function call' is an illegal 'for' target + +>>> for (a, b()) in b: pass +Traceback (most recent call last): +SyntaxError: 'function call' is an illegal 'for' target + +>>> for [a, b()] in b: pass +Traceback (most recent call last): +SyntaxError: 'function call' is an illegal 'for' target + +>>> for (*a, b, c+1) in b: pass +Traceback (most recent call last): +SyntaxError: 'operator' is an illegal 'for' target + +>>> for (x, *(y, z.d())) in b: pass +Traceback (most recent call last): +SyntaxError: 'function call' is an illegal 'for' target + +>>> with a as b(): pass +Traceback (most recent call last): +SyntaxError: 'function call' is an illegal 'with' target + +>>> with a as (b, c()): pass +Traceback (most recent call last): +SyntaxError: 'function call' is an illegal 'with' target + +>>> with a as [b, c()]: pass +Traceback (most recent call last): +SyntaxError: 'function call' is an illegal 'with' target + +>>> with a as (*b, c, d+1): pass +Traceback (most recent call last): +SyntaxError: 'operator' is an illegal 'with' target + +>>> with a as (x, *(y, z.d())): pass +Traceback (most recent call last): +SyntaxError: 'function call' is an illegal 'with' target + From compiler_complex_args(): >>> def f(None=1): diff --git a/Parser/pegen/parse.c b/Parser/pegen/parse.c index f4c5692212768d..65e5c6f05bf50b 100644 --- a/Parser/pegen/parse.c +++ b/Parser/pegen/parse.c @@ -204,171 +204,173 @@ static KeywordToken *reserved_keywords[] = { #define del_targets_type 1133 #define del_target_type 1134 #define del_t_atom_type 1135 -#define del_target_end_type 1136 -#define targets_type 1137 -#define target_type 1138 -#define t_primary_type 1139 // Left-recursive -#define t_lookahead_type 1140 -#define t_atom_type 1141 -#define incorrect_arguments_type 1142 -#define invalid_kwarg_type 1143 -#define invalid_named_expression_type 1144 -#define invalid_assignment_type 1145 +#define targets_type 1136 +#define target_type 1137 +#define t_primary_type 1138 // Left-recursive +#define t_lookahead_type 1139 +#define t_atom_type 1140 +#define incorrect_arguments_type 1141 +#define invalid_kwarg_type 1142 +#define invalid_named_expression_type 1143 +#define invalid_assignment_type 1144 +#define invalid_del_stmt_type 1145 #define invalid_block_type 1146 #define invalid_comprehension_type 1147 #define invalid_parameters_type 1148 #define invalid_star_etc_type 1149 #define invalid_lambda_star_etc_type 1150 #define invalid_double_type_comments_type 1151 -#define invalid_del_target_type 1152 -#define _loop0_1_type 1153 -#define _loop0_2_type 1154 -#define _loop0_4_type 1155 -#define _gather_3_type 1156 -#define _loop0_6_type 1157 -#define _gather_5_type 1158 -#define _loop0_8_type 1159 -#define _gather_7_type 1160 -#define _loop0_10_type 1161 -#define _gather_9_type 1162 -#define _loop1_11_type 1163 -#define _loop0_13_type 1164 -#define _gather_12_type 1165 -#define _tmp_14_type 1166 -#define _tmp_15_type 1167 -#define _tmp_16_type 1168 -#define _tmp_17_type 1169 -#define _tmp_18_type 1170 -#define _tmp_19_type 1171 -#define _tmp_20_type 1172 -#define _tmp_21_type 1173 -#define _loop1_22_type 1174 -#define _tmp_23_type 1175 -#define _tmp_24_type 1176 -#define _loop0_26_type 1177 -#define _gather_25_type 1178 -#define _loop0_28_type 1179 -#define _gather_27_type 1180 -#define _tmp_29_type 1181 -#define _loop0_30_type 1182 -#define _loop1_31_type 1183 -#define _loop0_33_type 1184 -#define _gather_32_type 1185 -#define _tmp_34_type 1186 -#define _loop0_36_type 1187 -#define _gather_35_type 1188 -#define _tmp_37_type 1189 -#define _loop0_39_type 1190 -#define _gather_38_type 1191 -#define _loop0_41_type 1192 -#define _gather_40_type 1193 -#define _loop0_43_type 1194 -#define _gather_42_type 1195 -#define _loop0_45_type 1196 -#define _gather_44_type 1197 -#define _tmp_46_type 1198 -#define _loop1_47_type 1199 -#define _tmp_48_type 1200 -#define _tmp_49_type 1201 -#define _tmp_50_type 1202 -#define _tmp_51_type 1203 -#define _tmp_52_type 1204 -#define _loop0_53_type 1205 -#define _loop0_54_type 1206 -#define _loop0_55_type 1207 -#define _loop1_56_type 1208 -#define _loop0_57_type 1209 -#define _loop1_58_type 1210 -#define _loop1_59_type 1211 -#define _loop1_60_type 1212 -#define _loop0_61_type 1213 -#define _loop1_62_type 1214 -#define _loop0_63_type 1215 -#define _loop1_64_type 1216 -#define _loop0_65_type 1217 -#define _loop1_66_type 1218 -#define _loop1_67_type 1219 -#define _tmp_68_type 1220 -#define _loop0_70_type 1221 -#define _gather_69_type 1222 -#define _loop1_71_type 1223 -#define _loop0_73_type 1224 -#define _gather_72_type 1225 -#define _loop1_74_type 1226 -#define _loop0_75_type 1227 -#define _loop0_76_type 1228 -#define _loop0_77_type 1229 -#define _loop1_78_type 1230 -#define _loop0_79_type 1231 -#define _loop1_80_type 1232 -#define _loop1_81_type 1233 -#define _loop1_82_type 1234 -#define _loop0_83_type 1235 -#define _loop1_84_type 1236 -#define _loop0_85_type 1237 -#define _loop1_86_type 1238 -#define _loop0_87_type 1239 -#define _loop1_88_type 1240 -#define _loop1_89_type 1241 -#define _loop1_90_type 1242 -#define _loop1_91_type 1243 -#define _tmp_92_type 1244 -#define _loop0_94_type 1245 -#define _gather_93_type 1246 -#define _tmp_95_type 1247 -#define _tmp_96_type 1248 -#define _tmp_97_type 1249 -#define _tmp_98_type 1250 -#define _loop1_99_type 1251 -#define _tmp_100_type 1252 -#define _tmp_101_type 1253 -#define _loop0_103_type 1254 -#define _gather_102_type 1255 -#define _loop1_104_type 1256 -#define _loop0_105_type 1257 -#define _loop0_106_type 1258 -#define _tmp_107_type 1259 -#define _tmp_108_type 1260 -#define _loop0_110_type 1261 -#define _gather_109_type 1262 -#define _loop0_112_type 1263 -#define _gather_111_type 1264 -#define _loop0_114_type 1265 -#define _gather_113_type 1266 -#define _loop0_116_type 1267 -#define _gather_115_type 1268 +#define invalid_with_target_type 1152 +#define invalid_for_target_type 1153 +#define _loop0_1_type 1154 +#define _loop0_2_type 1155 +#define _loop0_4_type 1156 +#define _gather_3_type 1157 +#define _loop0_6_type 1158 +#define _gather_5_type 1159 +#define _loop0_8_type 1160 +#define _gather_7_type 1161 +#define _loop0_10_type 1162 +#define _gather_9_type 1163 +#define _loop1_11_type 1164 +#define _loop0_13_type 1165 +#define _gather_12_type 1166 +#define _tmp_14_type 1167 +#define _tmp_15_type 1168 +#define _tmp_16_type 1169 +#define _tmp_17_type 1170 +#define _tmp_18_type 1171 +#define _tmp_19_type 1172 +#define _tmp_20_type 1173 +#define _tmp_21_type 1174 +#define _loop1_22_type 1175 +#define _tmp_23_type 1176 +#define _tmp_24_type 1177 +#define _loop0_26_type 1178 +#define _gather_25_type 1179 +#define _loop0_28_type 1180 +#define _gather_27_type 1181 +#define _tmp_29_type 1182 +#define _tmp_30_type 1183 +#define _loop0_31_type 1184 +#define _loop1_32_type 1185 +#define _loop0_34_type 1186 +#define _gather_33_type 1187 +#define _tmp_35_type 1188 +#define _loop0_37_type 1189 +#define _gather_36_type 1190 +#define _tmp_38_type 1191 +#define _loop0_40_type 1192 +#define _gather_39_type 1193 +#define _loop0_42_type 1194 +#define _gather_41_type 1195 +#define _loop0_44_type 1196 +#define _gather_43_type 1197 +#define _loop0_46_type 1198 +#define _gather_45_type 1199 +#define _tmp_47_type 1200 +#define _loop1_48_type 1201 +#define _tmp_49_type 1202 +#define _tmp_50_type 1203 +#define _tmp_51_type 1204 +#define _tmp_52_type 1205 +#define _tmp_53_type 1206 +#define _loop0_54_type 1207 +#define _loop0_55_type 1208 +#define _loop0_56_type 1209 +#define _loop1_57_type 1210 +#define _loop0_58_type 1211 +#define _loop1_59_type 1212 +#define _loop1_60_type 1213 +#define _loop1_61_type 1214 +#define _loop0_62_type 1215 +#define _loop1_63_type 1216 +#define _loop0_64_type 1217 +#define _loop1_65_type 1218 +#define _loop0_66_type 1219 +#define _loop1_67_type 1220 +#define _loop1_68_type 1221 +#define _tmp_69_type 1222 +#define _loop0_71_type 1223 +#define _gather_70_type 1224 +#define _loop1_72_type 1225 +#define _loop0_74_type 1226 +#define _gather_73_type 1227 +#define _loop1_75_type 1228 +#define _loop0_76_type 1229 +#define _loop0_77_type 1230 +#define _loop0_78_type 1231 +#define _loop1_79_type 1232 +#define _loop0_80_type 1233 +#define _loop1_81_type 1234 +#define _loop1_82_type 1235 +#define _loop1_83_type 1236 +#define _loop0_84_type 1237 +#define _loop1_85_type 1238 +#define _loop0_86_type 1239 +#define _loop1_87_type 1240 +#define _loop0_88_type 1241 +#define _loop1_89_type 1242 +#define _loop1_90_type 1243 +#define _loop1_91_type 1244 +#define _loop1_92_type 1245 +#define _tmp_93_type 1246 +#define _loop0_95_type 1247 +#define _gather_94_type 1248 +#define _tmp_96_type 1249 +#define _tmp_97_type 1250 +#define _tmp_98_type 1251 +#define _tmp_99_type 1252 +#define _loop1_100_type 1253 +#define _tmp_101_type 1254 +#define _tmp_102_type 1255 +#define _loop0_104_type 1256 +#define _gather_103_type 1257 +#define _loop1_105_type 1258 +#define _loop0_106_type 1259 +#define _loop0_107_type 1260 +#define _tmp_108_type 1261 +#define _tmp_109_type 1262 +#define _loop0_111_type 1263 +#define _gather_110_type 1264 +#define _loop0_113_type 1265 +#define _gather_112_type 1266 +#define _loop0_115_type 1267 +#define _gather_114_type 1268 #define _loop0_117_type 1269 -#define _loop0_119_type 1270 -#define _gather_118_type 1271 -#define _tmp_120_type 1272 -#define _loop0_122_type 1273 -#define _gather_121_type 1274 -#define _loop0_124_type 1275 -#define _gather_123_type 1276 -#define _tmp_125_type 1277 -#define _loop0_126_type 1278 -#define _tmp_127_type 1279 -#define _tmp_128_type 1280 -#define _tmp_129_type 1281 -#define _tmp_130_type 1282 -#define _loop0_131_type 1283 -#define _tmp_132_type 1284 -#define _tmp_133_type 1285 -#define _tmp_134_type 1286 -#define _tmp_135_type 1287 -#define _tmp_136_type 1288 -#define _tmp_137_type 1289 -#define _tmp_138_type 1290 -#define _tmp_139_type 1291 -#define _tmp_140_type 1292 -#define _tmp_141_type 1293 -#define _tmp_142_type 1294 -#define _tmp_143_type 1295 -#define _tmp_144_type 1296 -#define _tmp_145_type 1297 -#define _loop1_146_type 1298 -#define _tmp_147_type 1299 -#define _tmp_148_type 1300 +#define _gather_116_type 1270 +#define _loop0_118_type 1271 +#define _loop0_120_type 1272 +#define _gather_119_type 1273 +#define _tmp_121_type 1274 +#define _loop0_123_type 1275 +#define _gather_122_type 1276 +#define _loop0_125_type 1277 +#define _gather_124_type 1278 +#define _tmp_126_type 1279 +#define _loop0_127_type 1280 +#define _tmp_128_type 1281 +#define _tmp_129_type 1282 +#define _tmp_130_type 1283 +#define _tmp_131_type 1284 +#define _loop0_132_type 1285 +#define _tmp_133_type 1286 +#define _tmp_134_type 1287 +#define _tmp_135_type 1288 +#define _tmp_136_type 1289 +#define _tmp_137_type 1290 +#define _tmp_138_type 1291 +#define _tmp_139_type 1292 +#define _tmp_140_type 1293 +#define _tmp_141_type 1294 +#define _tmp_142_type 1295 +#define _tmp_143_type 1296 +#define _tmp_144_type 1297 +#define _tmp_145_type 1298 +#define _tmp_146_type 1299 +#define _loop1_147_type 1300 +#define _tmp_148_type 1301 +#define _tmp_149_type 1302 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -506,7 +508,6 @@ static expr_ty single_subscript_attribute_target_rule(Parser *p); static asdl_seq* del_targets_rule(Parser *p); static expr_ty del_target_rule(Parser *p); static expr_ty del_t_atom_rule(Parser *p); -static void *del_target_end_rule(Parser *p); static asdl_seq* targets_rule(Parser *p); static expr_ty target_rule(Parser *p); static expr_ty t_primary_rule(Parser *p); @@ -516,13 +517,15 @@ static void *incorrect_arguments_rule(Parser *p); static void *invalid_kwarg_rule(Parser *p); static void *invalid_named_expression_rule(Parser *p); static void *invalid_assignment_rule(Parser *p); +static void *invalid_del_stmt_rule(Parser *p); static void *invalid_block_rule(Parser *p); static void *invalid_comprehension_rule(Parser *p); static void *invalid_parameters_rule(Parser *p); static void *invalid_star_etc_rule(Parser *p); static void *invalid_lambda_star_etc_rule(Parser *p); static void *invalid_double_type_comments_rule(Parser *p); -static void *invalid_del_target_rule(Parser *p); +static void *invalid_with_target_rule(Parser *p); +static void *invalid_for_target_rule(Parser *p); static asdl_seq *_loop0_1_rule(Parser *p); static asdl_seq *_loop0_2_rule(Parser *p); static asdl_seq *_loop0_4_rule(Parser *p); @@ -552,109 +555,109 @@ static asdl_seq *_gather_25_rule(Parser *p); static asdl_seq *_loop0_28_rule(Parser *p); static asdl_seq *_gather_27_rule(Parser *p); static void *_tmp_29_rule(Parser *p); -static asdl_seq *_loop0_30_rule(Parser *p); -static asdl_seq *_loop1_31_rule(Parser *p); -static asdl_seq *_loop0_33_rule(Parser *p); -static asdl_seq *_gather_32_rule(Parser *p); -static void *_tmp_34_rule(Parser *p); -static asdl_seq *_loop0_36_rule(Parser *p); -static asdl_seq *_gather_35_rule(Parser *p); -static void *_tmp_37_rule(Parser *p); -static asdl_seq *_loop0_39_rule(Parser *p); -static asdl_seq *_gather_38_rule(Parser *p); -static asdl_seq *_loop0_41_rule(Parser *p); -static asdl_seq *_gather_40_rule(Parser *p); -static asdl_seq *_loop0_43_rule(Parser *p); -static asdl_seq *_gather_42_rule(Parser *p); -static asdl_seq *_loop0_45_rule(Parser *p); -static asdl_seq *_gather_44_rule(Parser *p); -static void *_tmp_46_rule(Parser *p); -static asdl_seq *_loop1_47_rule(Parser *p); -static void *_tmp_48_rule(Parser *p); +static void *_tmp_30_rule(Parser *p); +static asdl_seq *_loop0_31_rule(Parser *p); +static asdl_seq *_loop1_32_rule(Parser *p); +static asdl_seq *_loop0_34_rule(Parser *p); +static asdl_seq *_gather_33_rule(Parser *p); +static void *_tmp_35_rule(Parser *p); +static asdl_seq *_loop0_37_rule(Parser *p); +static asdl_seq *_gather_36_rule(Parser *p); +static void *_tmp_38_rule(Parser *p); +static asdl_seq *_loop0_40_rule(Parser *p); +static asdl_seq *_gather_39_rule(Parser *p); +static asdl_seq *_loop0_42_rule(Parser *p); +static asdl_seq *_gather_41_rule(Parser *p); +static asdl_seq *_loop0_44_rule(Parser *p); +static asdl_seq *_gather_43_rule(Parser *p); +static asdl_seq *_loop0_46_rule(Parser *p); +static asdl_seq *_gather_45_rule(Parser *p); +static void *_tmp_47_rule(Parser *p); +static asdl_seq *_loop1_48_rule(Parser *p); static void *_tmp_49_rule(Parser *p); static void *_tmp_50_rule(Parser *p); static void *_tmp_51_rule(Parser *p); static void *_tmp_52_rule(Parser *p); -static asdl_seq *_loop0_53_rule(Parser *p); +static void *_tmp_53_rule(Parser *p); static asdl_seq *_loop0_54_rule(Parser *p); static asdl_seq *_loop0_55_rule(Parser *p); -static asdl_seq *_loop1_56_rule(Parser *p); -static asdl_seq *_loop0_57_rule(Parser *p); -static asdl_seq *_loop1_58_rule(Parser *p); +static asdl_seq *_loop0_56_rule(Parser *p); +static asdl_seq *_loop1_57_rule(Parser *p); +static asdl_seq *_loop0_58_rule(Parser *p); static asdl_seq *_loop1_59_rule(Parser *p); static asdl_seq *_loop1_60_rule(Parser *p); -static asdl_seq *_loop0_61_rule(Parser *p); -static asdl_seq *_loop1_62_rule(Parser *p); -static asdl_seq *_loop0_63_rule(Parser *p); -static asdl_seq *_loop1_64_rule(Parser *p); -static asdl_seq *_loop0_65_rule(Parser *p); -static asdl_seq *_loop1_66_rule(Parser *p); +static asdl_seq *_loop1_61_rule(Parser *p); +static asdl_seq *_loop0_62_rule(Parser *p); +static asdl_seq *_loop1_63_rule(Parser *p); +static asdl_seq *_loop0_64_rule(Parser *p); +static asdl_seq *_loop1_65_rule(Parser *p); +static asdl_seq *_loop0_66_rule(Parser *p); static asdl_seq *_loop1_67_rule(Parser *p); -static void *_tmp_68_rule(Parser *p); -static asdl_seq *_loop0_70_rule(Parser *p); -static asdl_seq *_gather_69_rule(Parser *p); -static asdl_seq *_loop1_71_rule(Parser *p); -static asdl_seq *_loop0_73_rule(Parser *p); -static asdl_seq *_gather_72_rule(Parser *p); -static asdl_seq *_loop1_74_rule(Parser *p); -static asdl_seq *_loop0_75_rule(Parser *p); +static asdl_seq *_loop1_68_rule(Parser *p); +static void *_tmp_69_rule(Parser *p); +static asdl_seq *_loop0_71_rule(Parser *p); +static asdl_seq *_gather_70_rule(Parser *p); +static asdl_seq *_loop1_72_rule(Parser *p); +static asdl_seq *_loop0_74_rule(Parser *p); +static asdl_seq *_gather_73_rule(Parser *p); +static asdl_seq *_loop1_75_rule(Parser *p); static asdl_seq *_loop0_76_rule(Parser *p); static asdl_seq *_loop0_77_rule(Parser *p); -static asdl_seq *_loop1_78_rule(Parser *p); -static asdl_seq *_loop0_79_rule(Parser *p); -static asdl_seq *_loop1_80_rule(Parser *p); +static asdl_seq *_loop0_78_rule(Parser *p); +static asdl_seq *_loop1_79_rule(Parser *p); +static asdl_seq *_loop0_80_rule(Parser *p); static asdl_seq *_loop1_81_rule(Parser *p); static asdl_seq *_loop1_82_rule(Parser *p); -static asdl_seq *_loop0_83_rule(Parser *p); -static asdl_seq *_loop1_84_rule(Parser *p); -static asdl_seq *_loop0_85_rule(Parser *p); -static asdl_seq *_loop1_86_rule(Parser *p); -static asdl_seq *_loop0_87_rule(Parser *p); -static asdl_seq *_loop1_88_rule(Parser *p); +static asdl_seq *_loop1_83_rule(Parser *p); +static asdl_seq *_loop0_84_rule(Parser *p); +static asdl_seq *_loop1_85_rule(Parser *p); +static asdl_seq *_loop0_86_rule(Parser *p); +static asdl_seq *_loop1_87_rule(Parser *p); +static asdl_seq *_loop0_88_rule(Parser *p); static asdl_seq *_loop1_89_rule(Parser *p); static asdl_seq *_loop1_90_rule(Parser *p); static asdl_seq *_loop1_91_rule(Parser *p); -static void *_tmp_92_rule(Parser *p); -static asdl_seq *_loop0_94_rule(Parser *p); -static asdl_seq *_gather_93_rule(Parser *p); -static void *_tmp_95_rule(Parser *p); +static asdl_seq *_loop1_92_rule(Parser *p); +static void *_tmp_93_rule(Parser *p); +static asdl_seq *_loop0_95_rule(Parser *p); +static asdl_seq *_gather_94_rule(Parser *p); static void *_tmp_96_rule(Parser *p); static void *_tmp_97_rule(Parser *p); static void *_tmp_98_rule(Parser *p); -static asdl_seq *_loop1_99_rule(Parser *p); -static void *_tmp_100_rule(Parser *p); +static void *_tmp_99_rule(Parser *p); +static asdl_seq *_loop1_100_rule(Parser *p); static void *_tmp_101_rule(Parser *p); -static asdl_seq *_loop0_103_rule(Parser *p); -static asdl_seq *_gather_102_rule(Parser *p); -static asdl_seq *_loop1_104_rule(Parser *p); -static asdl_seq *_loop0_105_rule(Parser *p); +static void *_tmp_102_rule(Parser *p); +static asdl_seq *_loop0_104_rule(Parser *p); +static asdl_seq *_gather_103_rule(Parser *p); +static asdl_seq *_loop1_105_rule(Parser *p); static asdl_seq *_loop0_106_rule(Parser *p); -static void *_tmp_107_rule(Parser *p); +static asdl_seq *_loop0_107_rule(Parser *p); static void *_tmp_108_rule(Parser *p); -static asdl_seq *_loop0_110_rule(Parser *p); -static asdl_seq *_gather_109_rule(Parser *p); -static asdl_seq *_loop0_112_rule(Parser *p); -static asdl_seq *_gather_111_rule(Parser *p); -static asdl_seq *_loop0_114_rule(Parser *p); -static asdl_seq *_gather_113_rule(Parser *p); -static asdl_seq *_loop0_116_rule(Parser *p); -static asdl_seq *_gather_115_rule(Parser *p); +static void *_tmp_109_rule(Parser *p); +static asdl_seq *_loop0_111_rule(Parser *p); +static asdl_seq *_gather_110_rule(Parser *p); +static asdl_seq *_loop0_113_rule(Parser *p); +static asdl_seq *_gather_112_rule(Parser *p); +static asdl_seq *_loop0_115_rule(Parser *p); +static asdl_seq *_gather_114_rule(Parser *p); static asdl_seq *_loop0_117_rule(Parser *p); -static asdl_seq *_loop0_119_rule(Parser *p); -static asdl_seq *_gather_118_rule(Parser *p); -static void *_tmp_120_rule(Parser *p); -static asdl_seq *_loop0_122_rule(Parser *p); -static asdl_seq *_gather_121_rule(Parser *p); -static asdl_seq *_loop0_124_rule(Parser *p); -static asdl_seq *_gather_123_rule(Parser *p); -static void *_tmp_125_rule(Parser *p); -static asdl_seq *_loop0_126_rule(Parser *p); -static void *_tmp_127_rule(Parser *p); +static asdl_seq *_gather_116_rule(Parser *p); +static asdl_seq *_loop0_118_rule(Parser *p); +static asdl_seq *_loop0_120_rule(Parser *p); +static asdl_seq *_gather_119_rule(Parser *p); +static void *_tmp_121_rule(Parser *p); +static asdl_seq *_loop0_123_rule(Parser *p); +static asdl_seq *_gather_122_rule(Parser *p); +static asdl_seq *_loop0_125_rule(Parser *p); +static asdl_seq *_gather_124_rule(Parser *p); +static void *_tmp_126_rule(Parser *p); +static asdl_seq *_loop0_127_rule(Parser *p); static void *_tmp_128_rule(Parser *p); static void *_tmp_129_rule(Parser *p); static void *_tmp_130_rule(Parser *p); -static asdl_seq *_loop0_131_rule(Parser *p); -static void *_tmp_132_rule(Parser *p); +static void *_tmp_131_rule(Parser *p); +static asdl_seq *_loop0_132_rule(Parser *p); static void *_tmp_133_rule(Parser *p); static void *_tmp_134_rule(Parser *p); static void *_tmp_135_rule(Parser *p); @@ -668,9 +671,10 @@ static void *_tmp_142_rule(Parser *p); static void *_tmp_143_rule(Parser *p); static void *_tmp_144_rule(Parser *p); static void *_tmp_145_rule(Parser *p); -static asdl_seq *_loop1_146_rule(Parser *p); -static void *_tmp_147_rule(Parser *p); +static void *_tmp_146_rule(Parser *p); +static asdl_seq *_loop1_147_rule(Parser *p); static void *_tmp_148_rule(Parser *p); +static void *_tmp_149_rule(Parser *p); // file: statements? $ @@ -1591,8 +1595,8 @@ compound_stmt_rule(Parser *p) // 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) +// | ((star_targets '='))+ ~ (yield_expr | star_expressions) TYPE_COMMENT? +// | single_target augassign ~ (yield_expr | star_expressions) // | invalid_assignment static stmt_ty assignment_rule(Parser *p) @@ -1674,13 +1678,16 @@ assignment_rule(Parser *p) } p->mark = _mark; } - { // ((star_targets '='))+ (yield_expr | star_expressions) TYPE_COMMENT? + { // ((star_targets '='))+ ~ (yield_expr | star_expressions) TYPE_COMMENT? + int _cut_var = 0; asdl_seq * a; void *b; void *tc; if ( (a = _loop1_22_rule(p)) // ((star_targets '='))+ && + (_cut_var = 1) + && (b = _tmp_23_rule(p)) // yield_expr | star_expressions && (tc = _PyPegen_expect_token(p, TYPE_COMMENT), 1) // TYPE_COMMENT? @@ -1702,8 +1709,10 @@ assignment_rule(Parser *p) goto done; } p->mark = _mark; + if (_cut_var) return NULL; } - { // single_target augassign (yield_expr | star_expressions) + { // single_target augassign ~ (yield_expr | star_expressions) + int _cut_var = 0; expr_ty a; AugOperator* b; void *c; @@ -1712,6 +1721,8 @@ assignment_rule(Parser *p) && (b = augassign_rule(p)) // augassign && + (_cut_var = 1) + && (c = _tmp_24_rule(p)) // yield_expr | star_expressions ) { @@ -1731,6 +1742,7 @@ assignment_rule(Parser *p) goto done; } p->mark = _mark; + if (_cut_var) return NULL; } { // invalid_assignment void *invalid_assignment_var; @@ -2162,7 +2174,7 @@ assert_stmt_rule(Parser *p) return _res; } -// del_stmt: 'del' del_targets +// del_stmt: 'del' del_targets &(';' | NEWLINE) | invalid_del_stmt static stmt_ty del_stmt_rule(Parser *p) { @@ -2179,13 +2191,15 @@ del_stmt_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // 'del' del_targets + { // 'del' del_targets &(';' | NEWLINE) Token * _keyword; asdl_seq* a; if ( (_keyword = _PyPegen_expect_token(p, 503)) // token='del' && (a = del_targets_rule(p)) // del_targets + && + _PyPegen_lookahead(1, _tmp_30_rule, p) ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -2205,6 +2219,17 @@ del_stmt_rule(Parser *p) } p->mark = _mark; } + { // invalid_del_stmt + void *invalid_del_stmt_var; + if ( + (invalid_del_stmt_var = invalid_del_stmt_rule(p)) // invalid_del_stmt + ) + { + _res = invalid_del_stmt_var; + goto done; + } + p->mark = _mark; + } _res = NULL; done: return _res; @@ -2322,7 +2347,7 @@ import_from_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 514)) // token='from' && - (a = _loop0_30_rule(p)) // (('.' | '...'))* + (a = _loop0_31_rule(p)) // (('.' | '...'))* && (b = dotted_name_rule(p)) // dotted_name && @@ -2356,7 +2381,7 @@ import_from_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 514)) // token='from' && - (a = _loop1_31_rule(p)) // (('.' | '...'))+ + (a = _loop1_32_rule(p)) // (('.' | '...'))+ && (_keyword_1 = _PyPegen_expect_token(p, 513)) // token='import' && @@ -2462,7 +2487,7 @@ import_from_as_names_rule(Parser *p) { // ','.import_from_as_name+ asdl_seq * a; if ( - (a = _gather_32_rule(p)) // ','.import_from_as_name+ + (a = _gather_33_rule(p)) // ','.import_from_as_name+ ) { _res = a; @@ -2494,7 +2519,7 @@ import_from_as_name_rule(Parser *p) if ( (a = _PyPegen_name_token(p)) // NAME && - (b = _tmp_34_rule(p), 1) // ['as' NAME] + (b = _tmp_35_rule(p), 1) // ['as' NAME] ) { _res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena ); @@ -2523,7 +2548,7 @@ dotted_as_names_rule(Parser *p) { // ','.dotted_as_name+ asdl_seq * a; if ( - (a = _gather_35_rule(p)) // ','.dotted_as_name+ + (a = _gather_36_rule(p)) // ','.dotted_as_name+ ) { _res = a; @@ -2555,7 +2580,7 @@ dotted_as_name_rule(Parser *p) if ( (a = dotted_name_rule(p)) // dotted_name && - (b = _tmp_37_rule(p), 1) // ['as' NAME] + (b = _tmp_38_rule(p), 1) // ['as' NAME] ) { _res = _Py_alias ( a -> v . Name . id , ( b ) ? ( ( expr_ty ) b ) -> v . Name . id : NULL , p -> arena ); @@ -2924,8 +2949,9 @@ while_stmt_rule(Parser *p) } // 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? +// | '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 static stmt_ty for_stmt_rule(Parser *p) { @@ -2942,7 +2968,8 @@ for_stmt_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // 'for' star_targets 'in' star_expressions ':' TYPE_COMMENT? block else_block? + { // 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? + int _cut_var = 0; Token * _keyword; Token * _keyword_1; Token * _literal; @@ -2958,6 +2985,8 @@ for_stmt_rule(Parser *p) && (_keyword_1 = _PyPegen_expect_token(p, 518)) // token='in' && + (_cut_var = 1) + && (ex = star_expressions_rule(p)) // star_expressions && (_literal = _PyPegen_expect_token(p, 11)) // token=':' @@ -2985,8 +3014,10 @@ for_stmt_rule(Parser *p) goto done; } p->mark = _mark; + if (_cut_var) return NULL; } - { // ASYNC 'for' star_targets 'in' star_expressions ':' TYPE_COMMENT? block else_block? + { // ASYNC 'for' star_targets 'in' ~ star_expressions ':' TYPE_COMMENT? block else_block? + int _cut_var = 0; Token * _keyword; Token * _keyword_1; Token * _literal; @@ -3005,6 +3036,8 @@ for_stmt_rule(Parser *p) && (_keyword_1 = _PyPegen_expect_token(p, 518)) // token='in' && + (_cut_var = 1) + && (ex = star_expressions_rule(p)) // star_expressions && (_literal = _PyPegen_expect_token(p, 11)) // token=':' @@ -3032,6 +3065,18 @@ for_stmt_rule(Parser *p) goto done; } p->mark = _mark; + if (_cut_var) return NULL; + } + { // invalid_for_target + void *invalid_for_target_var; + if ( + (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target + ) + { + _res = invalid_for_target_var; + goto done; + } + p->mark = _mark; } _res = NULL; done: @@ -3043,6 +3088,7 @@ for_stmt_rule(Parser *p) // | 'with' ','.with_item+ ':' TYPE_COMMENT? block // | ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block // | ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block +// | invalid_with_target static stmt_ty with_stmt_rule(Parser *p) { @@ -3073,7 +3119,7 @@ with_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _gather_38_rule(p)) // ','.with_item+ + (a = _gather_39_rule(p)) // ','.with_item+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? && @@ -3110,7 +3156,7 @@ with_stmt_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 519)) // token='with' && - (a = _gather_40_rule(p)) // ','.with_item+ + (a = _gather_41_rule(p)) // ','.with_item+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -3153,7 +3199,7 @@ with_stmt_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _gather_42_rule(p)) // ','.with_item+ + (a = _gather_43_rule(p)) // ','.with_item+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? && @@ -3193,7 +3239,7 @@ with_stmt_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 519)) // token='with' && - (a = _gather_44_rule(p)) // ','.with_item+ + (a = _gather_45_rule(p)) // ','.with_item+ && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -3219,6 +3265,17 @@ with_stmt_rule(Parser *p) } p->mark = _mark; } + { // invalid_with_target + void *invalid_with_target_var; + if ( + (invalid_with_target_var = invalid_with_target_rule(p)) // invalid_with_target + ) + { + _res = invalid_with_target_var; + goto done; + } + p->mark = _mark; + } _res = NULL; done: return _res; @@ -3239,7 +3296,7 @@ with_item_rule(Parser *p) if ( (e = expression_rule(p)) // expression && - (o = _tmp_46_rule(p), 1) // ['as' target] + (o = _tmp_47_rule(p), 1) // ['as' target] ) { _res = _Py_withitem ( e , o , p -> arena ); @@ -3321,7 +3378,7 @@ try_stmt_rule(Parser *p) && (b = block_rule(p)) // block && - (ex = _loop1_47_rule(p)) // except_block+ + (ex = _loop1_48_rule(p)) // except_block+ && (el = else_block_rule(p), 1) // else_block? && @@ -3378,7 +3435,7 @@ except_block_rule(Parser *p) && (e = expression_rule(p)) // expression && - (t = _tmp_48_rule(p), 1) // ['as' NAME] + (t = _tmp_49_rule(p), 1) // ['as' NAME] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -3545,7 +3602,7 @@ raise_stmt_rule(Parser *p) && (a = expression_rule(p)) // expression && - (b = _tmp_49_rule(p), 1) // ['from' expression] + (b = _tmp_50_rule(p), 1) // ['from' expression] ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -3676,7 +3733,7 @@ function_def_raw_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (a = _tmp_50_rule(p), 1) // ['->' expression] + (a = _tmp_51_rule(p), 1) // ['->' expression] && (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -3726,7 +3783,7 @@ function_def_raw_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' && - (a = _tmp_51_rule(p), 1) // ['->' expression] + (a = _tmp_52_rule(p), 1) // ['->' expression] && (_literal_2 = _PyPegen_expect_token(p, 11)) // token=':' && @@ -3777,7 +3834,7 @@ func_type_comment_rule(Parser *p) && (t = _PyPegen_expect_token(p, TYPE_COMMENT)) // token='TYPE_COMMENT' && - _PyPegen_lookahead(1, _tmp_52_rule, p) + _PyPegen_lookahead(1, _tmp_53_rule, p) ) { _res = t; @@ -3874,9 +3931,9 @@ parameters_rule(Parser *p) if ( (a = slash_no_default_rule(p)) // slash_no_default && - (b = _loop0_53_rule(p)) // param_no_default* + (b = _loop0_54_rule(p)) // param_no_default* && - (c = _loop0_54_rule(p)) // param_with_default* + (c = _loop0_55_rule(p)) // param_with_default* && (d = star_etc_rule(p), 1) // star_etc? ) @@ -3897,7 +3954,7 @@ parameters_rule(Parser *p) if ( (a = slash_with_default_rule(p)) // slash_with_default && - (b = _loop0_55_rule(p)) // param_with_default* + (b = _loop0_56_rule(p)) // param_with_default* && (c = star_etc_rule(p), 1) // star_etc? ) @@ -3916,9 +3973,9 @@ parameters_rule(Parser *p) asdl_seq * b; void *c; if ( - (a = _loop1_56_rule(p)) // param_no_default+ + (a = _loop1_57_rule(p)) // param_no_default+ && - (b = _loop0_57_rule(p)) // param_with_default* + (b = _loop0_58_rule(p)) // param_with_default* && (c = star_etc_rule(p), 1) // star_etc? ) @@ -3936,7 +3993,7 @@ parameters_rule(Parser *p) asdl_seq * a; void *b; if ( - (a = _loop1_58_rule(p)) // param_with_default+ + (a = _loop1_59_rule(p)) // param_with_default+ && (b = star_etc_rule(p), 1) // star_etc? ) @@ -3984,7 +4041,7 @@ slash_no_default_rule(Parser *p) Token * _literal_1; asdl_seq * a; if ( - (a = _loop1_59_rule(p)) // param_no_default+ + (a = _loop1_60_rule(p)) // param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -4004,7 +4061,7 @@ slash_no_default_rule(Parser *p) Token * _literal; asdl_seq * a; if ( - (a = _loop1_60_rule(p)) // param_no_default+ + (a = _loop1_61_rule(p)) // param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -4042,9 +4099,9 @@ slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_61_rule(p)) // param_no_default* + (a = _loop0_62_rule(p)) // param_no_default* && - (b = _loop1_62_rule(p)) // param_with_default+ + (b = _loop1_63_rule(p)) // param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -4065,9 +4122,9 @@ slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_63_rule(p)) // param_no_default* + (a = _loop0_64_rule(p)) // param_no_default* && - (b = _loop1_64_rule(p)) // param_with_default+ + (b = _loop1_65_rule(p)) // param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -4111,7 +4168,7 @@ star_etc_rule(Parser *p) && (a = param_no_default_rule(p)) // param_no_default && - (b = _loop0_65_rule(p)) // param_maybe_default* + (b = _loop0_66_rule(p)) // param_maybe_default* && (c = kwds_rule(p), 1) // kwds? ) @@ -4135,7 +4192,7 @@ star_etc_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _loop1_66_rule(p)) // param_maybe_default+ + (b = _loop1_67_rule(p)) // param_maybe_default+ && (c = kwds_rule(p), 1) // kwds? ) @@ -4515,7 +4572,7 @@ decorators_rule(Parser *p) { // (('@' named_expression NEWLINE))+ asdl_seq * a; if ( - (a = _loop1_67_rule(p)) // (('@' named_expression NEWLINE))+ + (a = _loop1_68_rule(p)) // (('@' named_expression NEWLINE))+ ) { _res = a; @@ -4603,7 +4660,7 @@ class_def_raw_rule(Parser *p) && (a = _PyPegen_name_token(p)) // NAME && - (b = _tmp_68_rule(p), 1) // ['(' arguments? ')'] + (b = _tmp_69_rule(p), 1) // ['(' arguments? ')'] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -4709,7 +4766,7 @@ expressions_list_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_69_rule(p)) // ','.star_expression+ + (a = _gather_70_rule(p)) // ','.star_expression+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) @@ -4756,7 +4813,7 @@ star_expressions_rule(Parser *p) if ( (a = star_expression_rule(p)) // star_expression && - (b = _loop1_71_rule(p)) // ((',' star_expression))+ + (b = _loop1_72_rule(p)) // ((',' star_expression))+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) @@ -4896,7 +4953,7 @@ star_named_expressions_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_72_rule(p)) // ','.star_named_expression+ + (a = _gather_73_rule(p)) // ','.star_named_expression+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) @@ -4974,7 +5031,7 @@ star_named_expression_rule(Parser *p) return _res; } -// named_expression: NAME ':=' expression | expression !':=' | invalid_named_expression +// named_expression: NAME ':=' ~ expression | expression !':=' | invalid_named_expression static expr_ty named_expression_rule(Parser *p) { @@ -4991,7 +5048,8 @@ named_expression_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // NAME ':=' expression + { // NAME ':=' ~ expression + int _cut_var = 0; Token * _literal; expr_ty a; expr_ty b; @@ -5000,6 +5058,8 @@ named_expression_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 53)) // token=':=' && + (_cut_var = 1) + && (b = expression_rule(p)) // expression ) { @@ -5019,6 +5079,7 @@ named_expression_rule(Parser *p) goto done; } p->mark = _mark; + if (_cut_var) return NULL; } { // expression !':=' expr_ty expression_var; @@ -5110,7 +5171,7 @@ expressions_rule(Parser *p) if ( (a = expression_rule(p)) // expression && - (b = _loop1_74_rule(p)) // ((',' expression))+ + (b = _loop1_75_rule(p)) // ((',' expression))+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) @@ -5332,9 +5393,9 @@ lambda_parameters_rule(Parser *p) if ( (a = lambda_slash_no_default_rule(p)) // lambda_slash_no_default && - (b = _loop0_75_rule(p)) // lambda_param_no_default* + (b = _loop0_76_rule(p)) // lambda_param_no_default* && - (c = _loop0_76_rule(p)) // lambda_param_with_default* + (c = _loop0_77_rule(p)) // lambda_param_with_default* && (d = lambda_star_etc_rule(p), 1) // lambda_star_etc? ) @@ -5355,7 +5416,7 @@ lambda_parameters_rule(Parser *p) if ( (a = lambda_slash_with_default_rule(p)) // lambda_slash_with_default && - (b = _loop0_77_rule(p)) // lambda_param_with_default* + (b = _loop0_78_rule(p)) // lambda_param_with_default* && (c = lambda_star_etc_rule(p), 1) // lambda_star_etc? ) @@ -5374,9 +5435,9 @@ lambda_parameters_rule(Parser *p) asdl_seq * b; void *c; if ( - (a = _loop1_78_rule(p)) // lambda_param_no_default+ + (a = _loop1_79_rule(p)) // lambda_param_no_default+ && - (b = _loop0_79_rule(p)) // lambda_param_with_default* + (b = _loop0_80_rule(p)) // lambda_param_with_default* && (c = lambda_star_etc_rule(p), 1) // lambda_star_etc? ) @@ -5394,7 +5455,7 @@ lambda_parameters_rule(Parser *p) asdl_seq * a; void *b; if ( - (a = _loop1_80_rule(p)) // lambda_param_with_default+ + (a = _loop1_81_rule(p)) // lambda_param_with_default+ && (b = lambda_star_etc_rule(p), 1) // lambda_star_etc? ) @@ -5444,7 +5505,7 @@ lambda_slash_no_default_rule(Parser *p) Token * _literal_1; asdl_seq * a; if ( - (a = _loop1_81_rule(p)) // lambda_param_no_default+ + (a = _loop1_82_rule(p)) // lambda_param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -5464,7 +5525,7 @@ lambda_slash_no_default_rule(Parser *p) Token * _literal; asdl_seq * a; if ( - (a = _loop1_82_rule(p)) // lambda_param_no_default+ + (a = _loop1_83_rule(p)) // lambda_param_no_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -5502,9 +5563,9 @@ lambda_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_83_rule(p)) // lambda_param_no_default* + (a = _loop0_84_rule(p)) // lambda_param_no_default* && - (b = _loop1_84_rule(p)) // lambda_param_with_default+ + (b = _loop1_85_rule(p)) // lambda_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -5525,9 +5586,9 @@ lambda_slash_with_default_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _loop0_85_rule(p)) // lambda_param_no_default* + (a = _loop0_86_rule(p)) // lambda_param_no_default* && - (b = _loop1_86_rule(p)) // lambda_param_with_default+ + (b = _loop1_87_rule(p)) // lambda_param_with_default+ && (_literal = _PyPegen_expect_token(p, 17)) // token='/' && @@ -5571,7 +5632,7 @@ lambda_star_etc_rule(Parser *p) && (a = lambda_param_no_default_rule(p)) // lambda_param_no_default && - (b = _loop0_87_rule(p)) // lambda_param_maybe_default* + (b = _loop0_88_rule(p)) // lambda_param_maybe_default* && (c = lambda_kwds_rule(p), 1) // lambda_kwds? ) @@ -5595,7 +5656,7 @@ lambda_star_etc_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _loop1_88_rule(p)) // lambda_param_maybe_default+ + (b = _loop1_89_rule(p)) // lambda_param_maybe_default+ && (c = lambda_kwds_rule(p), 1) // lambda_kwds? ) @@ -5901,7 +5962,7 @@ disjunction_rule(Parser *p) if ( (a = conjunction_rule(p)) // conjunction && - (b = _loop1_89_rule(p)) // (('or' conjunction))+ + (b = _loop1_90_rule(p)) // (('or' conjunction))+ ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -5963,7 +6024,7 @@ conjunction_rule(Parser *p) if ( (a = inversion_rule(p)) // inversion && - (b = _loop1_90_rule(p)) // (('and' inversion))+ + (b = _loop1_91_rule(p)) // (('and' inversion))+ ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -6085,7 +6146,7 @@ comparison_rule(Parser *p) if ( (a = bitwise_or_rule(p)) // bitwise_or && - (b = _loop1_91_rule(p)) // compare_op_bitwise_or_pair+ + (b = _loop1_92_rule(p)) // compare_op_bitwise_or_pair+ ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -6297,10 +6358,10 @@ noteq_bitwise_or_rule(Parser *p) CmpopExprPair* _res = NULL; int _mark = p->mark; { // ('!=') bitwise_or - void *_tmp_92_var; + void *_tmp_93_var; expr_ty a; if ( - (_tmp_92_var = _tmp_92_rule(p)) // '!=' + (_tmp_93_var = _tmp_93_rule(p)) // '!=' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -7742,7 +7803,7 @@ slices_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_93_rule(p)) // ','.slice+ + (a = _gather_94_rule(p)) // ','.slice+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) @@ -7798,7 +7859,7 @@ slice_rule(Parser *p) && (b = expression_rule(p), 1) // expression? && - (c = _tmp_95_rule(p), 1) // [':' expression?] + (c = _tmp_96_rule(p), 1) // [':' expression?] ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -7986,40 +8047,40 @@ atom_rule(Parser *p) p->mark = _mark; } { // &'(' (tuple | group | genexp) - void *_tmp_96_var; + void *_tmp_97_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 7) // token='(' && - (_tmp_96_var = _tmp_96_rule(p)) // tuple | group | genexp + (_tmp_97_var = _tmp_97_rule(p)) // tuple | group | genexp ) { - _res = _tmp_96_var; + _res = _tmp_97_var; goto done; } p->mark = _mark; } { // &'[' (list | listcomp) - void *_tmp_97_var; + void *_tmp_98_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 9) // token='[' && - (_tmp_97_var = _tmp_97_rule(p)) // list | listcomp + (_tmp_98_var = _tmp_98_rule(p)) // list | listcomp ) { - _res = _tmp_97_var; + _res = _tmp_98_var; goto done; } p->mark = _mark; } { // &'{' (dict | set | dictcomp | setcomp) - void *_tmp_98_var; + void *_tmp_99_var; if ( _PyPegen_lookahead_with_int(1, _PyPegen_expect_token, p, 25) // token='{' && - (_tmp_98_var = _tmp_98_rule(p)) // dict | set | dictcomp | setcomp + (_tmp_99_var = _tmp_99_rule(p)) // dict | set | dictcomp | setcomp ) { - _res = _tmp_98_var; + _res = _tmp_99_var; goto done; } p->mark = _mark; @@ -8066,7 +8127,7 @@ strings_rule(Parser *p) { // STRING+ asdl_seq * a; if ( - (a = _loop1_99_rule(p)) // STRING+ + (a = _loop1_100_rule(p)) // STRING+ ) { _res = _PyPegen_concatenate_strings ( p , a ); @@ -8135,7 +8196,7 @@ list_rule(Parser *p) return _res; } -// listcomp: '[' named_expression for_if_clauses ']' | invalid_comprehension +// listcomp: '[' named_expression ~ for_if_clauses ']' | invalid_comprehension static expr_ty listcomp_rule(Parser *p) { @@ -8152,7 +8213,8 @@ listcomp_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // '[' named_expression for_if_clauses ']' + { // '[' named_expression ~ for_if_clauses ']' + int _cut_var = 0; Token * _literal; Token * _literal_1; expr_ty a; @@ -8162,6 +8224,8 @@ listcomp_rule(Parser *p) && (a = named_expression_rule(p)) // named_expression && + (_cut_var = 1) + && (b = for_if_clauses_rule(p)) // for_if_clauses && (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' @@ -8183,6 +8247,7 @@ listcomp_rule(Parser *p) goto done; } p->mark = _mark; + if (_cut_var) return NULL; } { // invalid_comprehension void *invalid_comprehension_var; @@ -8224,7 +8289,7 @@ tuple_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_100_rule(p), 1) // [star_named_expression ',' star_named_expressions?] + (a = _tmp_101_rule(p), 1) // [star_named_expression ',' star_named_expressions?] && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -8267,7 +8332,7 @@ group_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 7)) // token='(' && - (a = _tmp_101_rule(p)) // yield_expr | named_expression + (a = _tmp_102_rule(p)) // yield_expr | named_expression && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' ) @@ -8286,7 +8351,7 @@ group_rule(Parser *p) return _res; } -// genexp: '(' expression for_if_clauses ')' | invalid_comprehension +// genexp: '(' expression ~ for_if_clauses ')' | invalid_comprehension static expr_ty genexp_rule(Parser *p) { @@ -8303,7 +8368,8 @@ genexp_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // '(' expression for_if_clauses ')' + { // '(' expression ~ for_if_clauses ')' + int _cut_var = 0; Token * _literal; Token * _literal_1; expr_ty a; @@ -8313,6 +8379,8 @@ genexp_rule(Parser *p) && (a = expression_rule(p)) // expression && + (_cut_var = 1) + && (b = for_if_clauses_rule(p)) // for_if_clauses && (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' @@ -8334,6 +8402,7 @@ genexp_rule(Parser *p) goto done; } p->mark = _mark; + if (_cut_var) return NULL; } { // invalid_comprehension void *invalid_comprehension_var; @@ -8402,7 +8471,7 @@ set_rule(Parser *p) return _res; } -// setcomp: '{' expression for_if_clauses '}' | invalid_comprehension +// setcomp: '{' expression ~ for_if_clauses '}' | invalid_comprehension static expr_ty setcomp_rule(Parser *p) { @@ -8419,7 +8488,8 @@ setcomp_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // '{' expression for_if_clauses '}' + { // '{' expression ~ for_if_clauses '}' + int _cut_var = 0; Token * _literal; Token * _literal_1; expr_ty a; @@ -8429,6 +8499,8 @@ setcomp_rule(Parser *p) && (a = expression_rule(p)) // expression && + (_cut_var = 1) + && (b = for_if_clauses_rule(p)) // for_if_clauses && (_literal_1 = _PyPegen_expect_token(p, 26)) // token='}' @@ -8450,6 +8522,7 @@ setcomp_rule(Parser *p) goto done; } p->mark = _mark; + if (_cut_var) return NULL; } { // invalid_comprehension void *invalid_comprehension_var; @@ -8586,7 +8659,7 @@ kvpairs_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_102_rule(p)) // ','.kvpair+ + (a = _gather_103_rule(p)) // ','.kvpair+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) @@ -8668,12 +8741,12 @@ for_if_clauses_rule(Parser *p) asdl_seq* _res = NULL; int _mark = p->mark; { // for_if_clause+ - asdl_seq * _loop1_104_var; + asdl_seq * _loop1_105_var; if ( - (_loop1_104_var = _loop1_104_rule(p)) // for_if_clause+ + (_loop1_105_var = _loop1_105_rule(p)) // for_if_clause+ ) { - _res = _loop1_104_var; + _res = _loop1_105_var; goto done; } p->mark = _mark; @@ -8684,8 +8757,9 @@ for_if_clauses_rule(Parser *p) } // for_if_clause: -// | ASYNC 'for' star_targets 'in' disjunction (('if' disjunction))* -// | 'for' star_targets 'in' disjunction (('if' disjunction))* +// | ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))* +// | 'for' star_targets 'in' ~ disjunction (('if' disjunction))* +// | invalid_for_target static comprehension_ty for_if_clause_rule(Parser *p) { @@ -8694,7 +8768,8 @@ for_if_clause_rule(Parser *p) } comprehension_ty _res = NULL; int _mark = p->mark; - { // ASYNC 'for' star_targets 'in' disjunction (('if' disjunction))* + { // ASYNC 'for' star_targets 'in' ~ disjunction (('if' disjunction))* + int _cut_var = 0; Token * _keyword; Token * _keyword_1; expr_ty a; @@ -8710,9 +8785,11 @@ for_if_clause_rule(Parser *p) && (_keyword_1 = _PyPegen_expect_token(p, 518)) // token='in' && + (_cut_var = 1) + && (b = disjunction_rule(p)) // disjunction && - (c = _loop0_105_rule(p)) // (('if' disjunction))* + (c = _loop0_106_rule(p)) // (('if' disjunction))* ) { _res = CHECK_VERSION ( 6 , "Async comprehensions are" , _Py_comprehension ( a , b , c , 1 , p -> arena ) ); @@ -8723,8 +8800,10 @@ for_if_clause_rule(Parser *p) goto done; } p->mark = _mark; + if (_cut_var) return NULL; } - { // 'for' star_targets 'in' disjunction (('if' disjunction))* + { // 'for' star_targets 'in' ~ disjunction (('if' disjunction))* + int _cut_var = 0; Token * _keyword; Token * _keyword_1; expr_ty a; @@ -8737,9 +8816,11 @@ for_if_clause_rule(Parser *p) && (_keyword_1 = _PyPegen_expect_token(p, 518)) // token='in' && + (_cut_var = 1) + && (b = disjunction_rule(p)) // disjunction && - (c = _loop0_106_rule(p)) // (('if' disjunction))* + (c = _loop0_107_rule(p)) // (('if' disjunction))* ) { _res = _Py_comprehension ( a , b , c , 0 , p -> arena ); @@ -8750,6 +8831,18 @@ for_if_clause_rule(Parser *p) goto done; } p->mark = _mark; + if (_cut_var) return NULL; + } + { // invalid_for_target + void *invalid_for_target_var; + if ( + (invalid_for_target_var = invalid_for_target_rule(p)) // invalid_for_target + ) + { + _res = invalid_for_target_var; + goto done; + } + p->mark = _mark; } _res = NULL; done: @@ -8905,7 +8998,7 @@ args_rule(Parser *p) if ( (a = starred_expression_rule(p)) // starred_expression && - (b = _tmp_107_rule(p), 1) // [',' args] + (b = _tmp_108_rule(p), 1) // [',' args] ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -8954,7 +9047,7 @@ args_rule(Parser *p) if ( (a = named_expression_rule(p)) // named_expression && - (b = _tmp_108_rule(p), 1) // [',' args] + (b = _tmp_109_rule(p), 1) // [',' args] ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -8996,11 +9089,11 @@ kwargs_rule(Parser *p) asdl_seq * a; asdl_seq * b; if ( - (a = _gather_109_rule(p)) // ','.kwarg_or_starred+ + (a = _gather_110_rule(p)) // ','.kwarg_or_starred+ && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (b = _gather_111_rule(p)) // ','.kwarg_or_double_starred+ + (b = _gather_112_rule(p)) // ','.kwarg_or_double_starred+ ) { _res = _PyPegen_join_sequences ( p , a , b ); @@ -9013,23 +9106,23 @@ kwargs_rule(Parser *p) p->mark = _mark; } { // ','.kwarg_or_starred+ - asdl_seq * _gather_113_var; + asdl_seq * _gather_114_var; if ( - (_gather_113_var = _gather_113_rule(p)) // ','.kwarg_or_starred+ + (_gather_114_var = _gather_114_rule(p)) // ','.kwarg_or_starred+ ) { - _res = _gather_113_var; + _res = _gather_114_var; goto done; } p->mark = _mark; } { // ','.kwarg_or_double_starred+ - asdl_seq * _gather_115_var; + asdl_seq * _gather_116_var; if ( - (_gather_115_var = _gather_115_rule(p)) // ','.kwarg_or_double_starred+ + (_gather_116_var = _gather_116_rule(p)) // ','.kwarg_or_double_starred+ ) { - _res = _gather_115_var; + _res = _gather_116_var; goto done; } p->mark = _mark; @@ -9294,7 +9387,7 @@ star_targets_rule(Parser *p) if ( (a = star_target_rule(p)) // star_target && - (b = _loop0_117_rule(p)) // ((',' star_target))* + (b = _loop0_118_rule(p)) // ((',' star_target))* && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) @@ -9335,7 +9428,7 @@ star_targets_seq_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_118_rule(p)) // ','.star_target+ + (a = _gather_119_rule(p)) // ','.star_target+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) @@ -9383,7 +9476,7 @@ star_target_rule(Parser *p) if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (a = _tmp_120_rule(p)) // !'*' star_target + (a = _tmp_121_rule(p)) // !'*' star_target ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -9769,7 +9862,7 @@ del_targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_121_rule(p)) // ','.del_target+ + (a = _gather_122_rule(p)) // ','.del_target+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) @@ -9789,8 +9882,8 @@ del_targets_rule(Parser *p) } // del_target: -// | t_primary '.' NAME &del_target_end -// | t_primary '[' slices ']' &del_target_end +// | t_primary '.' NAME !t_lookahead +// | t_primary '[' slices ']' !t_lookahead // | del_t_atom static expr_ty del_target_rule(Parser *p) @@ -9810,7 +9903,7 @@ del_target_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // t_primary '.' NAME &del_target_end + { // t_primary '.' NAME !t_lookahead Token * _literal; expr_ty a; expr_ty b; @@ -9821,7 +9914,7 @@ del_target_rule(Parser *p) && (b = _PyPegen_name_token(p)) // NAME && - _PyPegen_lookahead(1, del_target_end_rule, p) + _PyPegen_lookahead(0, t_lookahead_rule, p) ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -9841,7 +9934,7 @@ del_target_rule(Parser *p) } p->mark = _mark; } - { // t_primary '[' slices ']' &del_target_end + { // t_primary '[' slices ']' !t_lookahead Token * _literal; Token * _literal_1; expr_ty a; @@ -9855,7 +9948,7 @@ del_target_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' && - _PyPegen_lookahead(1, del_target_end_rule, p) + _PyPegen_lookahead(0, t_lookahead_rule, p) ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -9892,12 +9985,7 @@ del_target_rule(Parser *p) return _res; } -// del_t_atom: -// | NAME &del_target_end -// | '(' del_target ')' -// | '(' del_targets? ')' -// | '[' del_targets? ']' -// | invalid_del_target +// del_t_atom: NAME | '(' del_target ')' | '(' del_targets? ')' | '[' del_targets? ']' static expr_ty del_t_atom_rule(Parser *p) { @@ -9914,12 +10002,10 @@ del_t_atom_rule(Parser *p) UNUSED(_start_lineno); // Only used by EXTRA macro int _start_col_offset = p->tokens[_mark]->col_offset; UNUSED(_start_col_offset); // Only used by EXTRA macro - { // NAME &del_target_end + { // NAME expr_ty a; if ( (a = _PyPegen_name_token(p)) // NAME - && - _PyPegen_lookahead(1, del_target_end_rule, p) ) { _res = _PyPegen_set_expr_context ( p , a , Del ); @@ -10010,86 +10096,6 @@ del_t_atom_rule(Parser *p) } p->mark = _mark; } - { // invalid_del_target - void *invalid_del_target_var; - if ( - (invalid_del_target_var = invalid_del_target_rule(p)) // invalid_del_target - ) - { - _res = invalid_del_target_var; - goto done; - } - p->mark = _mark; - } - _res = NULL; - done: - return _res; -} - -// del_target_end: ')' | ']' | ',' | ';' | NEWLINE -static void * -del_target_end_rule(Parser *p) -{ - if (p->error_indicator) { - return NULL; - } - void * _res = NULL; - int _mark = p->mark; - { // ')' - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 8)) // token=')' - ) - { - _res = _literal; - goto done; - } - p->mark = _mark; - } - { // ']' - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 10)) // token=']' - ) - { - _res = _literal; - goto done; - } - p->mark = _mark; - } - { // ',' - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - ) - { - _res = _literal; - goto done; - } - p->mark = _mark; - } - { // ';' - Token * _literal; - if ( - (_literal = _PyPegen_expect_token(p, 13)) // token=';' - ) - { - _res = _literal; - goto done; - } - p->mark = _mark; - } - { // NEWLINE - Token * newline_var; - if ( - (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' - ) - { - _res = newline_var; - goto done; - } - p->mark = _mark; - } _res = NULL; done: return _res; @@ -10109,7 +10115,7 @@ targets_rule(Parser *p) UNUSED(_opt_var); // Silence compiler warnings asdl_seq * a; if ( - (a = _gather_123_rule(p)) // ','.target+ + (a = _gather_124_rule(p)) // ','.target+ && (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? ) @@ -10637,7 +10643,7 @@ incorrect_arguments_rule(Parser *p) && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_opt_var = _tmp_125_rule(p), 1) // [args | expression for_if_clauses] + (_opt_var = _tmp_126_rule(p), 1) // [args | expression for_if_clauses] ) { _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "Generator expression must be parenthesized" ); @@ -10796,14 +10802,14 @@ invalid_assignment_rule(Parser *p) { // star_named_expression ',' star_named_expressions* ':' Token * _literal; Token * _literal_1; - asdl_seq * _loop0_126_var; + asdl_seq * _loop0_127_var; expr_ty a; if ( (a = star_named_expression_rule(p)) // star_named_expression && (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_loop0_126_var = _loop0_126_rule(p)) // star_named_expressions* + (_loop0_127_var = _loop0_127_rule(p)) // star_named_expressions* && (_literal_1 = _PyPegen_expect_token(p, 11)) // token=':' ) @@ -10830,7 +10836,7 @@ invalid_assignment_rule(Parser *p) && (expression_var = expression_rule(p)) // expression && - (_opt_var = _tmp_127_rule(p), 1) // ['=' annotated_rhs] + (_opt_var = _tmp_128_rule(p), 1) // ['=' annotated_rhs] ) { _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "illegal target for annotation" ); @@ -10844,17 +10850,17 @@ invalid_assignment_rule(Parser *p) } { // star_expressions '=' (yield_expr | star_expressions) Token * _literal; - void *_tmp_128_var; + void *_tmp_129_var; expr_ty a; if ( (a = star_expressions_rule(p)) // star_expressions && (_literal = _PyPegen_expect_token(p, 22)) // token='=' && - (_tmp_128_var = _tmp_128_rule(p)) // yield_expr | star_expressions + (_tmp_129_var = _tmp_129_rule(p)) // yield_expr | star_expressions ) { - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( _PyPegen_get_invalid_target ( a ) , "cannot assign to %s" , _PyPegen_get_expr_name ( _PyPegen_get_invalid_target ( a ) ) ); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_TARGET ( a ) , "cannot assign to %s" , _PyPegen_get_expr_name ( GET_INVALID_TARGET ( a ) ) ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; return NULL; @@ -10864,7 +10870,7 @@ invalid_assignment_rule(Parser *p) p->mark = _mark; } { // star_expressions augassign (yield_expr | star_expressions) - void *_tmp_129_var; + void *_tmp_130_var; expr_ty a; AugOperator* augassign_var; if ( @@ -10872,7 +10878,7 @@ invalid_assignment_rule(Parser *p) && (augassign_var = augassign_rule(p)) // augassign && - (_tmp_129_var = _tmp_129_rule(p)) // yield_expr | star_expressions + (_tmp_130_var = _tmp_130_rule(p)) // yield_expr | star_expressions ) { _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "'%s' is an illegal expression for augmented assignment" , _PyPegen_get_expr_name ( a ) ); @@ -10889,6 +10895,62 @@ invalid_assignment_rule(Parser *p) return _res; } +// invalid_del_stmt: 'del' star_expressions | 'del' '(' starred_expression ')' +static void * +invalid_del_stmt_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // 'del' star_expressions + Token * _keyword; + expr_ty a; + if ( + (_keyword = _PyPegen_expect_token(p, 503)) // token='del' + && + (a = star_expressions_rule(p)) // star_expressions + ) + { + _res = GET_INVALID_DEL_TARGET ( a ) != NULL ? RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_DEL_TARGET ( a ) , "cannot delete %s" , _PyPegen_get_expr_name ( GET_INVALID_DEL_TARGET ( a ) ) ) : RAISE_SYNTAX_ERROR ( "invalid syntax" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + return NULL; + } + goto done; + } + p->mark = _mark; + } + { // 'del' '(' starred_expression ')' + Token * _keyword; + Token * _literal; + Token * _literal_1; + expr_ty a; + if ( + (_keyword = _PyPegen_expect_token(p, 503)) // token='del' + && + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (a = starred_expression_rule(p)) // starred_expression + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + ) + { + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot delete starred" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + return NULL; + } + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + // invalid_block: NEWLINE !INDENT static void * invalid_block_rule(Parser *p) @@ -10930,11 +10992,11 @@ invalid_comprehension_rule(Parser *p) void * _res = NULL; int _mark = p->mark; { // ('[' | '(' | '{') starred_expression for_if_clauses - void *_tmp_130_var; + void *_tmp_131_var; expr_ty a; asdl_seq* for_if_clauses_var; if ( - (_tmp_130_var = _tmp_130_rule(p)) // '[' | '(' | '{' + (_tmp_131_var = _tmp_131_rule(p)) // '[' | '(' | '{' && (a = starred_expression_rule(p)) // starred_expression && @@ -10966,13 +11028,13 @@ invalid_parameters_rule(Parser *p) void * _res = NULL; int _mark = p->mark; { // param_no_default* (slash_with_default | param_with_default+) param_no_default - asdl_seq * _loop0_131_var; - void *_tmp_132_var; + asdl_seq * _loop0_132_var; + void *_tmp_133_var; arg_ty param_no_default_var; if ( - (_loop0_131_var = _loop0_131_rule(p)) // param_no_default* + (_loop0_132_var = _loop0_132_rule(p)) // param_no_default* && - (_tmp_132_var = _tmp_132_rule(p)) // slash_with_default | param_with_default+ + (_tmp_133_var = _tmp_133_rule(p)) // slash_with_default | param_with_default+ && (param_no_default_var = param_no_default_rule(p)) // param_no_default ) @@ -11002,11 +11064,11 @@ invalid_star_etc_rule(Parser *p) int _mark = p->mark; { // '*' (')' | ',' (')' | '**')) Token * _literal; - void *_tmp_133_var; + void *_tmp_134_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_133_var = _tmp_133_rule(p)) // ')' | ',' (')' | '**') + (_tmp_134_var = _tmp_134_rule(p)) // ')' | ',' (')' | '**') ) { _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" ); @@ -11034,11 +11096,11 @@ invalid_lambda_star_etc_rule(Parser *p) int _mark = p->mark; { // '*' (':' | ',' (':' | '**')) Token * _literal; - void *_tmp_134_var; + void *_tmp_135_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_134_var = _tmp_134_rule(p)) // ':' | ',' (':' | '**') + (_tmp_135_var = _tmp_135_rule(p)) // ':' | ',' (':' | '**') ) { _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" ); @@ -11096,24 +11158,74 @@ invalid_double_type_comments_rule(Parser *p) return _res; } -// invalid_del_target: star_expression &del_target_end +// invalid_with_target: ASYNC? 'with' expression 'as' expressions ':' static void * -invalid_del_target_rule(Parser *p) +invalid_with_target_rule(Parser *p) { if (p->error_indicator) { return NULL; } void * _res = NULL; int _mark = p->mark; - { // star_expression &del_target_end + { // ASYNC? 'with' expression 'as' expressions ':' + Token * _keyword; + Token * _keyword_1; + Token * _literal; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings expr_ty a; + expr_ty expression_var; if ( - (a = star_expression_rule(p)) // star_expression + (_opt_var = _PyPegen_expect_token(p, ASYNC), 1) // ASYNC? + && + (_keyword = _PyPegen_expect_token(p, 519)) // token='with' + && + (expression_var = expression_rule(p)) // expression + && + (_keyword_1 = _PyPegen_expect_token(p, 531)) // token='as' + && + (a = expressions_rule(p)) // expressions && - _PyPegen_lookahead(1, del_target_end_rule, p) + (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot delete %s" , _PyPegen_get_expr_name ( a ) ); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_TARGET ( a ) , "'%s' is an illegal 'with' target" , _PyPegen_get_expr_name ( GET_INVALID_TARGET ( a ) ) ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + return NULL; + } + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + +// invalid_for_target: ASYNC? 'for' comparison +static void * +invalid_for_target_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // ASYNC? 'for' comparison + Token * _keyword; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + expr_ty a; + if ( + (_opt_var = _PyPegen_expect_token(p, ASYNC), 1) // ASYNC? + && + (_keyword = _PyPegen_expect_token(p, 517)) // token='for' + && + (a = comparison_rule(p)) // comparison + ) + { + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_TARGET ( a -> v . Compare . left ) , "'%s' is an illegal 'for' target" , _PyPegen_get_expr_name ( GET_INVALID_TARGET ( a -> v . Compare . left ) ) ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; return NULL; @@ -12022,12 +12134,12 @@ _loop1_22_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // (star_targets '=') - void *_tmp_135_var; + void *_tmp_136_var; while ( - (_tmp_135_var = _tmp_135_rule(p)) // star_targets '=' + (_tmp_136_var = _tmp_136_rule(p)) // star_targets '=' ) { - _res = _tmp_135_var; + _res = _tmp_136_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -12331,9 +12443,45 @@ _tmp_29_rule(Parser *p) return _res; } -// _loop0_30: ('.' | '...') +// _tmp_30: ';' | NEWLINE +static void * +_tmp_30_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // ';' + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 13)) // token=';' + ) + { + _res = _literal; + goto done; + } + p->mark = _mark; + } + { // NEWLINE + Token * newline_var; + if ( + (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + ) + { + _res = newline_var; + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + +// _loop0_31: ('.' | '...') static asdl_seq * -_loop0_30_rule(Parser *p) +_loop0_31_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12349,12 +12497,12 @@ _loop0_30_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('.' | '...') - void *_tmp_136_var; + void *_tmp_137_var; while ( - (_tmp_136_var = _tmp_136_rule(p)) // '.' | '...' + (_tmp_137_var = _tmp_137_rule(p)) // '.' | '...' ) { - _res = _tmp_136_var; + _res = _tmp_137_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -12370,19 +12518,19 @@ _loop0_30_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_30"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_31"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_30_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_31_type, _seq); return _seq; } -// _loop1_31: ('.' | '...') +// _loop1_32: ('.' | '...') static asdl_seq * -_loop1_31_rule(Parser *p) +_loop1_32_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12398,12 +12546,12 @@ _loop1_31_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('.' | '...') - void *_tmp_137_var; + void *_tmp_138_var; while ( - (_tmp_137_var = _tmp_137_rule(p)) // '.' | '...' + (_tmp_138_var = _tmp_138_rule(p)) // '.' | '...' ) { - _res = _tmp_137_var; + _res = _tmp_138_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -12423,19 +12571,19 @@ _loop1_31_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_31"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_32"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_31_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_32_type, _seq); return _seq; } -// _loop0_33: ',' import_from_as_name +// _loop0_34: ',' import_from_as_name static asdl_seq * -_loop0_33_rule(Parser *p) +_loop0_34_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12480,32 +12628,32 @@ _loop0_33_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_33"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_34"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_33_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_34_type, _seq); return _seq; } -// _gather_32: import_from_as_name _loop0_33 +// _gather_33: import_from_as_name _loop0_34 static asdl_seq * -_gather_32_rule(Parser *p) +_gather_33_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // import_from_as_name _loop0_33 + { // import_from_as_name _loop0_34 alias_ty elem; asdl_seq * seq; if ( (elem = import_from_as_name_rule(p)) // import_from_as_name && - (seq = _loop0_33_rule(p)) // _loop0_33 + (seq = _loop0_34_rule(p)) // _loop0_34 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -12518,9 +12666,9 @@ _gather_32_rule(Parser *p) return _res; } -// _tmp_34: 'as' NAME +// _tmp_35: 'as' NAME static void * -_tmp_34_rule(Parser *p) +_tmp_35_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12550,9 +12698,9 @@ _tmp_34_rule(Parser *p) return _res; } -// _loop0_36: ',' dotted_as_name +// _loop0_37: ',' dotted_as_name static asdl_seq * -_loop0_36_rule(Parser *p) +_loop0_37_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12597,32 +12745,32 @@ _loop0_36_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_36"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_37"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_36_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_37_type, _seq); return _seq; } -// _gather_35: dotted_as_name _loop0_36 +// _gather_36: dotted_as_name _loop0_37 static asdl_seq * -_gather_35_rule(Parser *p) +_gather_36_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // dotted_as_name _loop0_36 + { // dotted_as_name _loop0_37 alias_ty elem; asdl_seq * seq; if ( (elem = dotted_as_name_rule(p)) // dotted_as_name && - (seq = _loop0_36_rule(p)) // _loop0_36 + (seq = _loop0_37_rule(p)) // _loop0_37 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -12635,9 +12783,9 @@ _gather_35_rule(Parser *p) return _res; } -// _tmp_37: 'as' NAME +// _tmp_38: 'as' NAME static void * -_tmp_37_rule(Parser *p) +_tmp_38_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12667,9 +12815,9 @@ _tmp_37_rule(Parser *p) return _res; } -// _loop0_39: ',' with_item +// _loop0_40: ',' with_item static asdl_seq * -_loop0_39_rule(Parser *p) +_loop0_40_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12714,32 +12862,32 @@ _loop0_39_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_39"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_40"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_39_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_40_type, _seq); return _seq; } -// _gather_38: with_item _loop0_39 +// _gather_39: with_item _loop0_40 static asdl_seq * -_gather_38_rule(Parser *p) +_gather_39_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // with_item _loop0_39 + { // with_item _loop0_40 withitem_ty elem; asdl_seq * seq; if ( (elem = with_item_rule(p)) // with_item && - (seq = _loop0_39_rule(p)) // _loop0_39 + (seq = _loop0_40_rule(p)) // _loop0_40 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -12752,9 +12900,9 @@ _gather_38_rule(Parser *p) return _res; } -// _loop0_41: ',' with_item +// _loop0_42: ',' with_item static asdl_seq * -_loop0_41_rule(Parser *p) +_loop0_42_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12799,32 +12947,32 @@ _loop0_41_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_41"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_42"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_41_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_42_type, _seq); return _seq; } -// _gather_40: with_item _loop0_41 +// _gather_41: with_item _loop0_42 static asdl_seq * -_gather_40_rule(Parser *p) +_gather_41_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // with_item _loop0_41 + { // with_item _loop0_42 withitem_ty elem; asdl_seq * seq; if ( (elem = with_item_rule(p)) // with_item && - (seq = _loop0_41_rule(p)) // _loop0_41 + (seq = _loop0_42_rule(p)) // _loop0_42 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -12837,9 +12985,9 @@ _gather_40_rule(Parser *p) return _res; } -// _loop0_43: ',' with_item +// _loop0_44: ',' with_item static asdl_seq * -_loop0_43_rule(Parser *p) +_loop0_44_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12884,32 +13032,32 @@ _loop0_43_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_43"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_44"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_43_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_44_type, _seq); return _seq; } -// _gather_42: with_item _loop0_43 +// _gather_43: with_item _loop0_44 static asdl_seq * -_gather_42_rule(Parser *p) +_gather_43_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // with_item _loop0_43 + { // with_item _loop0_44 withitem_ty elem; asdl_seq * seq; if ( (elem = with_item_rule(p)) // with_item && - (seq = _loop0_43_rule(p)) // _loop0_43 + (seq = _loop0_44_rule(p)) // _loop0_44 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -12922,9 +13070,9 @@ _gather_42_rule(Parser *p) return _res; } -// _loop0_45: ',' with_item +// _loop0_46: ',' with_item static asdl_seq * -_loop0_45_rule(Parser *p) +_loop0_46_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12969,32 +13117,32 @@ _loop0_45_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_45"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_46"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_45_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_46_type, _seq); return _seq; } -// _gather_44: with_item _loop0_45 +// _gather_45: with_item _loop0_46 static asdl_seq * -_gather_44_rule(Parser *p) +_gather_45_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // with_item _loop0_45 + { // with_item _loop0_46 withitem_ty elem; asdl_seq * seq; if ( (elem = with_item_rule(p)) // with_item && - (seq = _loop0_45_rule(p)) // _loop0_45 + (seq = _loop0_46_rule(p)) // _loop0_46 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -13007,9 +13155,9 @@ _gather_44_rule(Parser *p) return _res; } -// _tmp_46: 'as' target +// _tmp_47: 'as' target static void * -_tmp_46_rule(Parser *p) +_tmp_47_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13039,9 +13187,9 @@ _tmp_46_rule(Parser *p) return _res; } -// _loop1_47: except_block +// _loop1_48: except_block static asdl_seq * -_loop1_47_rule(Parser *p) +_loop1_48_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13082,19 +13230,19 @@ _loop1_47_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_47"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_48"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_47_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_48_type, _seq); return _seq; } -// _tmp_48: 'as' NAME +// _tmp_49: 'as' NAME static void * -_tmp_48_rule(Parser *p) +_tmp_49_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13124,9 +13272,9 @@ _tmp_48_rule(Parser *p) return _res; } -// _tmp_49: 'from' expression +// _tmp_50: 'from' expression static void * -_tmp_49_rule(Parser *p) +_tmp_50_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13156,9 +13304,9 @@ _tmp_49_rule(Parser *p) return _res; } -// _tmp_50: '->' expression +// _tmp_51: '->' expression static void * -_tmp_50_rule(Parser *p) +_tmp_51_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13188,9 +13336,9 @@ _tmp_50_rule(Parser *p) return _res; } -// _tmp_51: '->' expression +// _tmp_52: '->' expression static void * -_tmp_51_rule(Parser *p) +_tmp_52_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13220,9 +13368,9 @@ _tmp_51_rule(Parser *p) return _res; } -// _tmp_52: NEWLINE INDENT +// _tmp_53: NEWLINE INDENT static void * -_tmp_52_rule(Parser *p) +_tmp_53_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13248,9 +13396,9 @@ _tmp_52_rule(Parser *p) return _res; } -// _loop0_53: param_no_default +// _loop0_54: param_no_default static asdl_seq * -_loop0_53_rule(Parser *p) +_loop0_54_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13287,19 +13435,19 @@ _loop0_53_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_53"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_54"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_53_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_54_type, _seq); return _seq; } -// _loop0_54: param_with_default +// _loop0_55: param_with_default static asdl_seq * -_loop0_54_rule(Parser *p) +_loop0_55_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13336,19 +13484,19 @@ _loop0_54_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_54"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_55"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_54_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_55_type, _seq); return _seq; } -// _loop0_55: param_with_default +// _loop0_56: param_with_default static asdl_seq * -_loop0_55_rule(Parser *p) +_loop0_56_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13385,19 +13533,19 @@ _loop0_55_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_55"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_56"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_55_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_56_type, _seq); return _seq; } -// _loop1_56: param_no_default +// _loop1_57: param_no_default static asdl_seq * -_loop1_56_rule(Parser *p) +_loop1_57_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13438,19 +13586,19 @@ _loop1_56_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_56"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_57"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_56_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_57_type, _seq); return _seq; } -// _loop0_57: param_with_default +// _loop0_58: param_with_default static asdl_seq * -_loop0_57_rule(Parser *p) +_loop0_58_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13487,19 +13635,19 @@ _loop0_57_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_57"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_58"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_57_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_58_type, _seq); return _seq; } -// _loop1_58: param_with_default +// _loop1_59: param_with_default static asdl_seq * -_loop1_58_rule(Parser *p) +_loop1_59_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13540,19 +13688,19 @@ _loop1_58_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_58"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_59"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_58_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_59_type, _seq); return _seq; } -// _loop1_59: param_no_default +// _loop1_60: param_no_default static asdl_seq * -_loop1_59_rule(Parser *p) +_loop1_60_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13593,19 +13741,19 @@ _loop1_59_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_59"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_60"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_59_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_60_type, _seq); return _seq; } -// _loop1_60: param_no_default +// _loop1_61: param_no_default static asdl_seq * -_loop1_60_rule(Parser *p) +_loop1_61_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13646,19 +13794,19 @@ _loop1_60_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_60"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_61"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_60_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_61_type, _seq); return _seq; } -// _loop0_61: param_no_default +// _loop0_62: param_no_default static asdl_seq * -_loop0_61_rule(Parser *p) +_loop0_62_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13695,19 +13843,19 @@ _loop0_61_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_61"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_62"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_61_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_62_type, _seq); return _seq; } -// _loop1_62: param_with_default +// _loop1_63: param_with_default static asdl_seq * -_loop1_62_rule(Parser *p) +_loop1_63_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13748,19 +13896,19 @@ _loop1_62_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_62"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_63"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_62_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_63_type, _seq); return _seq; } -// _loop0_63: param_no_default +// _loop0_64: param_no_default static asdl_seq * -_loop0_63_rule(Parser *p) +_loop0_64_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13797,19 +13945,19 @@ _loop0_63_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_63"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_64"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_63_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_64_type, _seq); return _seq; } -// _loop1_64: param_with_default +// _loop1_65: param_with_default static asdl_seq * -_loop1_64_rule(Parser *p) +_loop1_65_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13850,19 +13998,19 @@ _loop1_64_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_64"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_65"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_64_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_65_type, _seq); return _seq; } -// _loop0_65: param_maybe_default +// _loop0_66: param_maybe_default static asdl_seq * -_loop0_65_rule(Parser *p) +_loop0_66_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13899,19 +14047,19 @@ _loop0_65_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_65"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_66"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_65_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_66_type, _seq); return _seq; } -// _loop1_66: param_maybe_default +// _loop1_67: param_maybe_default static asdl_seq * -_loop1_66_rule(Parser *p) +_loop1_67_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13952,19 +14100,19 @@ _loop1_66_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_66"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_67"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_66_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_67_type, _seq); return _seq; } -// _loop1_67: ('@' named_expression NEWLINE) +// _loop1_68: ('@' named_expression NEWLINE) static asdl_seq * -_loop1_67_rule(Parser *p) +_loop1_68_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13980,12 +14128,12 @@ _loop1_67_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('@' named_expression NEWLINE) - void *_tmp_138_var; + void *_tmp_139_var; while ( - (_tmp_138_var = _tmp_138_rule(p)) // '@' named_expression NEWLINE + (_tmp_139_var = _tmp_139_rule(p)) // '@' named_expression NEWLINE ) { - _res = _tmp_138_var; + _res = _tmp_139_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -14005,19 +14153,19 @@ _loop1_67_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_67"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_68"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_67_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_68_type, _seq); return _seq; } -// _tmp_68: '(' arguments? ')' +// _tmp_69: '(' arguments? ')' static void * -_tmp_68_rule(Parser *p) +_tmp_69_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14050,9 +14198,9 @@ _tmp_68_rule(Parser *p) return _res; } -// _loop0_70: ',' star_expression +// _loop0_71: ',' star_expression static asdl_seq * -_loop0_70_rule(Parser *p) +_loop0_71_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14097,32 +14245,32 @@ _loop0_70_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_70"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_71"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_70_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_71_type, _seq); return _seq; } -// _gather_69: star_expression _loop0_70 +// _gather_70: star_expression _loop0_71 static asdl_seq * -_gather_69_rule(Parser *p) +_gather_70_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_expression _loop0_70 + { // star_expression _loop0_71 expr_ty elem; asdl_seq * seq; if ( (elem = star_expression_rule(p)) // star_expression && - (seq = _loop0_70_rule(p)) // _loop0_70 + (seq = _loop0_71_rule(p)) // _loop0_71 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -14135,9 +14283,9 @@ _gather_69_rule(Parser *p) return _res; } -// _loop1_71: (',' star_expression) +// _loop1_72: (',' star_expression) static asdl_seq * -_loop1_71_rule(Parser *p) +_loop1_72_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14153,12 +14301,12 @@ _loop1_71_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // (',' star_expression) - void *_tmp_139_var; + void *_tmp_140_var; while ( - (_tmp_139_var = _tmp_139_rule(p)) // ',' star_expression + (_tmp_140_var = _tmp_140_rule(p)) // ',' star_expression ) { - _res = _tmp_139_var; + _res = _tmp_140_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -14178,19 +14326,19 @@ _loop1_71_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_71"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_72"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_71_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_72_type, _seq); return _seq; } -// _loop0_73: ',' star_named_expression +// _loop0_74: ',' star_named_expression static asdl_seq * -_loop0_73_rule(Parser *p) +_loop0_74_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14235,32 +14383,32 @@ _loop0_73_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_73"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_74"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_73_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_74_type, _seq); return _seq; } -// _gather_72: star_named_expression _loop0_73 +// _gather_73: star_named_expression _loop0_74 static asdl_seq * -_gather_72_rule(Parser *p) +_gather_73_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_named_expression _loop0_73 + { // star_named_expression _loop0_74 expr_ty elem; asdl_seq * seq; if ( (elem = star_named_expression_rule(p)) // star_named_expression && - (seq = _loop0_73_rule(p)) // _loop0_73 + (seq = _loop0_74_rule(p)) // _loop0_74 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -14273,9 +14421,9 @@ _gather_72_rule(Parser *p) return _res; } -// _loop1_74: (',' expression) +// _loop1_75: (',' expression) static asdl_seq * -_loop1_74_rule(Parser *p) +_loop1_75_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14291,12 +14439,12 @@ _loop1_74_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // (',' expression) - void *_tmp_140_var; + void *_tmp_141_var; while ( - (_tmp_140_var = _tmp_140_rule(p)) // ',' expression + (_tmp_141_var = _tmp_141_rule(p)) // ',' expression ) { - _res = _tmp_140_var; + _res = _tmp_141_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -14316,19 +14464,19 @@ _loop1_74_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_74"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_75"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_74_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_75_type, _seq); return _seq; } -// _loop0_75: lambda_param_no_default +// _loop0_76: lambda_param_no_default static asdl_seq * -_loop0_75_rule(Parser *p) +_loop0_76_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14365,19 +14513,19 @@ _loop0_75_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_75"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_76"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_75_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_76_type, _seq); return _seq; } -// _loop0_76: lambda_param_with_default +// _loop0_77: lambda_param_with_default static asdl_seq * -_loop0_76_rule(Parser *p) +_loop0_77_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14414,19 +14562,19 @@ _loop0_76_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_76"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_77"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_76_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_77_type, _seq); return _seq; } -// _loop0_77: lambda_param_with_default +// _loop0_78: lambda_param_with_default static asdl_seq * -_loop0_77_rule(Parser *p) +_loop0_78_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14463,19 +14611,19 @@ _loop0_77_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_77"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_78"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_77_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_78_type, _seq); return _seq; } -// _loop1_78: lambda_param_no_default +// _loop1_79: lambda_param_no_default static asdl_seq * -_loop1_78_rule(Parser *p) +_loop1_79_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14516,19 +14664,19 @@ _loop1_78_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_78"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_79"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_78_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_79_type, _seq); return _seq; } -// _loop0_79: lambda_param_with_default +// _loop0_80: lambda_param_with_default static asdl_seq * -_loop0_79_rule(Parser *p) +_loop0_80_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14565,19 +14713,19 @@ _loop0_79_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_79"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_80"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_79_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_80_type, _seq); return _seq; } -// _loop1_80: lambda_param_with_default +// _loop1_81: lambda_param_with_default static asdl_seq * -_loop1_80_rule(Parser *p) +_loop1_81_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14618,19 +14766,19 @@ _loop1_80_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_80"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_81"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_80_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_81_type, _seq); return _seq; } -// _loop1_81: lambda_param_no_default +// _loop1_82: lambda_param_no_default static asdl_seq * -_loop1_81_rule(Parser *p) +_loop1_82_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14671,19 +14819,19 @@ _loop1_81_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_81"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_82"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_81_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_82_type, _seq); return _seq; } -// _loop1_82: lambda_param_no_default +// _loop1_83: lambda_param_no_default static asdl_seq * -_loop1_82_rule(Parser *p) +_loop1_83_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14724,19 +14872,19 @@ _loop1_82_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_82"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_83"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_82_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_83_type, _seq); return _seq; } -// _loop0_83: lambda_param_no_default +// _loop0_84: lambda_param_no_default static asdl_seq * -_loop0_83_rule(Parser *p) +_loop0_84_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14773,19 +14921,19 @@ _loop0_83_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_83"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_84"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_83_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_84_type, _seq); return _seq; } -// _loop1_84: lambda_param_with_default +// _loop1_85: lambda_param_with_default static asdl_seq * -_loop1_84_rule(Parser *p) +_loop1_85_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14826,19 +14974,19 @@ _loop1_84_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_84"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_85"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_84_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_85_type, _seq); return _seq; } -// _loop0_85: lambda_param_no_default +// _loop0_86: lambda_param_no_default static asdl_seq * -_loop0_85_rule(Parser *p) +_loop0_86_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14875,19 +15023,19 @@ _loop0_85_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_85"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_86"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_85_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_86_type, _seq); return _seq; } -// _loop1_86: lambda_param_with_default +// _loop1_87: lambda_param_with_default static asdl_seq * -_loop1_86_rule(Parser *p) +_loop1_87_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14928,19 +15076,19 @@ _loop1_86_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_86"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_87"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_86_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_87_type, _seq); return _seq; } -// _loop0_87: lambda_param_maybe_default +// _loop0_88: lambda_param_maybe_default static asdl_seq * -_loop0_87_rule(Parser *p) +_loop0_88_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -14977,19 +15125,19 @@ _loop0_87_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_87"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_88"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_87_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_88_type, _seq); return _seq; } -// _loop1_88: lambda_param_maybe_default +// _loop1_89: lambda_param_maybe_default static asdl_seq * -_loop1_88_rule(Parser *p) +_loop1_89_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15030,19 +15178,19 @@ _loop1_88_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_88"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_89"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_88_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_89_type, _seq); return _seq; } -// _loop1_89: ('or' conjunction) +// _loop1_90: ('or' conjunction) static asdl_seq * -_loop1_89_rule(Parser *p) +_loop1_90_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15058,12 +15206,12 @@ _loop1_89_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('or' conjunction) - void *_tmp_141_var; + void *_tmp_142_var; while ( - (_tmp_141_var = _tmp_141_rule(p)) // 'or' conjunction + (_tmp_142_var = _tmp_142_rule(p)) // 'or' conjunction ) { - _res = _tmp_141_var; + _res = _tmp_142_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -15083,19 +15231,19 @@ _loop1_89_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_89"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_90"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_89_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_90_type, _seq); return _seq; } -// _loop1_90: ('and' inversion) +// _loop1_91: ('and' inversion) static asdl_seq * -_loop1_90_rule(Parser *p) +_loop1_91_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15111,12 +15259,12 @@ _loop1_90_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('and' inversion) - void *_tmp_142_var; + void *_tmp_143_var; while ( - (_tmp_142_var = _tmp_142_rule(p)) // 'and' inversion + (_tmp_143_var = _tmp_143_rule(p)) // 'and' inversion ) { - _res = _tmp_142_var; + _res = _tmp_143_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -15136,19 +15284,19 @@ _loop1_90_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_90"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_91"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_90_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_91_type, _seq); return _seq; } -// _loop1_91: compare_op_bitwise_or_pair +// _loop1_92: compare_op_bitwise_or_pair static asdl_seq * -_loop1_91_rule(Parser *p) +_loop1_92_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15189,19 +15337,19 @@ _loop1_91_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_91"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_92"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_91_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_92_type, _seq); return _seq; } -// _tmp_92: '!=' +// _tmp_93: '!=' static void * -_tmp_92_rule(Parser *p) +_tmp_93_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15228,9 +15376,9 @@ _tmp_92_rule(Parser *p) return _res; } -// _loop0_94: ',' slice +// _loop0_95: ',' slice static asdl_seq * -_loop0_94_rule(Parser *p) +_loop0_95_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15275,32 +15423,32 @@ _loop0_94_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_94"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_95"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_94_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_95_type, _seq); return _seq; } -// _gather_93: slice _loop0_94 +// _gather_94: slice _loop0_95 static asdl_seq * -_gather_93_rule(Parser *p) +_gather_94_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // slice _loop0_94 + { // slice _loop0_95 expr_ty elem; asdl_seq * seq; if ( (elem = slice_rule(p)) // slice && - (seq = _loop0_94_rule(p)) // _loop0_94 + (seq = _loop0_95_rule(p)) // _loop0_95 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -15313,9 +15461,9 @@ _gather_93_rule(Parser *p) return _res; } -// _tmp_95: ':' expression? +// _tmp_96: ':' expression? static void * -_tmp_95_rule(Parser *p) +_tmp_96_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15345,9 +15493,9 @@ _tmp_95_rule(Parser *p) return _res; } -// _tmp_96: tuple | group | genexp +// _tmp_97: tuple | group | genexp static void * -_tmp_96_rule(Parser *p) +_tmp_97_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15392,9 +15540,9 @@ _tmp_96_rule(Parser *p) return _res; } -// _tmp_97: list | listcomp +// _tmp_98: list | listcomp static void * -_tmp_97_rule(Parser *p) +_tmp_98_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15428,9 +15576,9 @@ _tmp_97_rule(Parser *p) return _res; } -// _tmp_98: dict | set | dictcomp | setcomp +// _tmp_99: dict | set | dictcomp | setcomp static void * -_tmp_98_rule(Parser *p) +_tmp_99_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15486,9 +15634,9 @@ _tmp_98_rule(Parser *p) return _res; } -// _loop1_99: STRING +// _loop1_100: STRING static asdl_seq * -_loop1_99_rule(Parser *p) +_loop1_100_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15529,19 +15677,19 @@ _loop1_99_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_99"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_100"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_99_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_100_type, _seq); return _seq; } -// _tmp_100: star_named_expression ',' star_named_expressions? +// _tmp_101: star_named_expression ',' star_named_expressions? static void * -_tmp_100_rule(Parser *p) +_tmp_101_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15574,9 +15722,9 @@ _tmp_100_rule(Parser *p) return _res; } -// _tmp_101: yield_expr | named_expression +// _tmp_102: yield_expr | named_expression static void * -_tmp_101_rule(Parser *p) +_tmp_102_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15610,9 +15758,9 @@ _tmp_101_rule(Parser *p) return _res; } -// _loop0_103: ',' kvpair +// _loop0_104: ',' kvpair static asdl_seq * -_loop0_103_rule(Parser *p) +_loop0_104_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15657,32 +15805,32 @@ _loop0_103_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_103"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_104"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_103_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_104_type, _seq); return _seq; } -// _gather_102: kvpair _loop0_103 +// _gather_103: kvpair _loop0_104 static asdl_seq * -_gather_102_rule(Parser *p) +_gather_103_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // kvpair _loop0_103 + { // kvpair _loop0_104 KeyValuePair* elem; asdl_seq * seq; if ( (elem = kvpair_rule(p)) // kvpair && - (seq = _loop0_103_rule(p)) // _loop0_103 + (seq = _loop0_104_rule(p)) // _loop0_104 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -15695,9 +15843,9 @@ _gather_102_rule(Parser *p) return _res; } -// _loop1_104: for_if_clause +// _loop1_105: for_if_clause static asdl_seq * -_loop1_104_rule(Parser *p) +_loop1_105_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15738,19 +15886,19 @@ _loop1_104_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_104"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_105"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_104_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_105_type, _seq); return _seq; } -// _loop0_105: ('if' disjunction) +// _loop0_106: ('if' disjunction) static asdl_seq * -_loop0_105_rule(Parser *p) +_loop0_106_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15766,12 +15914,12 @@ _loop0_105_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('if' disjunction) - void *_tmp_143_var; + void *_tmp_144_var; while ( - (_tmp_143_var = _tmp_143_rule(p)) // 'if' disjunction + (_tmp_144_var = _tmp_144_rule(p)) // 'if' disjunction ) { - _res = _tmp_143_var; + _res = _tmp_144_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -15787,19 +15935,19 @@ _loop0_105_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_105"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_106"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_105_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_106_type, _seq); return _seq; } -// _loop0_106: ('if' disjunction) +// _loop0_107: ('if' disjunction) static asdl_seq * -_loop0_106_rule(Parser *p) +_loop0_107_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15815,12 +15963,12 @@ _loop0_106_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('if' disjunction) - void *_tmp_144_var; + void *_tmp_145_var; while ( - (_tmp_144_var = _tmp_144_rule(p)) // 'if' disjunction + (_tmp_145_var = _tmp_145_rule(p)) // 'if' disjunction ) { - _res = _tmp_144_var; + _res = _tmp_145_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -15836,19 +15984,19 @@ _loop0_106_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_106"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_107"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_106_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_107_type, _seq); return _seq; } -// _tmp_107: ',' args +// _tmp_108: ',' args static void * -_tmp_107_rule(Parser *p) +_tmp_108_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15878,9 +16026,9 @@ _tmp_107_rule(Parser *p) return _res; } -// _tmp_108: ',' args +// _tmp_109: ',' args static void * -_tmp_108_rule(Parser *p) +_tmp_109_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15910,9 +16058,9 @@ _tmp_108_rule(Parser *p) return _res; } -// _loop0_110: ',' kwarg_or_starred +// _loop0_111: ',' kwarg_or_starred static asdl_seq * -_loop0_110_rule(Parser *p) +_loop0_111_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -15957,32 +16105,32 @@ _loop0_110_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_110"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_111"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_110_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_111_type, _seq); return _seq; } -// _gather_109: kwarg_or_starred _loop0_110 +// _gather_110: kwarg_or_starred _loop0_111 static asdl_seq * -_gather_109_rule(Parser *p) +_gather_110_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_110 + { // kwarg_or_starred _loop0_111 KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_110_rule(p)) // _loop0_110 + (seq = _loop0_111_rule(p)) // _loop0_111 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -15995,9 +16143,9 @@ _gather_109_rule(Parser *p) return _res; } -// _loop0_112: ',' kwarg_or_double_starred +// _loop0_113: ',' kwarg_or_double_starred static asdl_seq * -_loop0_112_rule(Parser *p) +_loop0_113_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16042,32 +16190,32 @@ _loop0_112_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_112"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_113"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_112_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_113_type, _seq); return _seq; } -// _gather_111: kwarg_or_double_starred _loop0_112 +// _gather_112: kwarg_or_double_starred _loop0_113 static asdl_seq * -_gather_111_rule(Parser *p) +_gather_112_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_112 + { // kwarg_or_double_starred _loop0_113 KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_112_rule(p)) // _loop0_112 + (seq = _loop0_113_rule(p)) // _loop0_113 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -16080,9 +16228,9 @@ _gather_111_rule(Parser *p) return _res; } -// _loop0_114: ',' kwarg_or_starred +// _loop0_115: ',' kwarg_or_starred static asdl_seq * -_loop0_114_rule(Parser *p) +_loop0_115_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16127,32 +16275,32 @@ _loop0_114_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_114"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_115"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_114_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_115_type, _seq); return _seq; } -// _gather_113: kwarg_or_starred _loop0_114 +// _gather_114: kwarg_or_starred _loop0_115 static asdl_seq * -_gather_113_rule(Parser *p) +_gather_114_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_starred _loop0_114 + { // kwarg_or_starred _loop0_115 KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_starred_rule(p)) // kwarg_or_starred && - (seq = _loop0_114_rule(p)) // _loop0_114 + (seq = _loop0_115_rule(p)) // _loop0_115 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -16165,9 +16313,9 @@ _gather_113_rule(Parser *p) return _res; } -// _loop0_116: ',' kwarg_or_double_starred +// _loop0_117: ',' kwarg_or_double_starred static asdl_seq * -_loop0_116_rule(Parser *p) +_loop0_117_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16212,32 +16360,32 @@ _loop0_116_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_116"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_117"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_116_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_117_type, _seq); return _seq; } -// _gather_115: kwarg_or_double_starred _loop0_116 +// _gather_116: kwarg_or_double_starred _loop0_117 static asdl_seq * -_gather_115_rule(Parser *p) +_gather_116_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // kwarg_or_double_starred _loop0_116 + { // kwarg_or_double_starred _loop0_117 KeywordOrStarred* elem; asdl_seq * seq; if ( (elem = kwarg_or_double_starred_rule(p)) // kwarg_or_double_starred && - (seq = _loop0_116_rule(p)) // _loop0_116 + (seq = _loop0_117_rule(p)) // _loop0_117 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -16250,9 +16398,9 @@ _gather_115_rule(Parser *p) return _res; } -// _loop0_117: (',' star_target) +// _loop0_118: (',' star_target) static asdl_seq * -_loop0_117_rule(Parser *p) +_loop0_118_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16268,12 +16416,12 @@ _loop0_117_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // (',' star_target) - void *_tmp_145_var; + void *_tmp_146_var; while ( - (_tmp_145_var = _tmp_145_rule(p)) // ',' star_target + (_tmp_146_var = _tmp_146_rule(p)) // ',' star_target ) { - _res = _tmp_145_var; + _res = _tmp_146_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -16289,19 +16437,19 @@ _loop0_117_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_117"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_118"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_117_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_118_type, _seq); return _seq; } -// _loop0_119: ',' star_target +// _loop0_120: ',' star_target static asdl_seq * -_loop0_119_rule(Parser *p) +_loop0_120_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16346,32 +16494,32 @@ _loop0_119_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_119"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_120"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_119_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_120_type, _seq); return _seq; } -// _gather_118: star_target _loop0_119 +// _gather_119: star_target _loop0_120 static asdl_seq * -_gather_118_rule(Parser *p) +_gather_119_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // star_target _loop0_119 + { // star_target _loop0_120 expr_ty elem; asdl_seq * seq; if ( (elem = star_target_rule(p)) // star_target && - (seq = _loop0_119_rule(p)) // _loop0_119 + (seq = _loop0_120_rule(p)) // _loop0_120 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -16384,9 +16532,9 @@ _gather_118_rule(Parser *p) return _res; } -// _tmp_120: !'*' star_target +// _tmp_121: !'*' star_target static void * -_tmp_120_rule(Parser *p) +_tmp_121_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16411,9 +16559,9 @@ _tmp_120_rule(Parser *p) return _res; } -// _loop0_122: ',' del_target +// _loop0_123: ',' del_target static asdl_seq * -_loop0_122_rule(Parser *p) +_loop0_123_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16458,32 +16606,32 @@ _loop0_122_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_122"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_123"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_122_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_123_type, _seq); return _seq; } -// _gather_121: del_target _loop0_122 +// _gather_122: del_target _loop0_123 static asdl_seq * -_gather_121_rule(Parser *p) +_gather_122_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // del_target _loop0_122 + { // del_target _loop0_123 expr_ty elem; asdl_seq * seq; if ( (elem = del_target_rule(p)) // del_target && - (seq = _loop0_122_rule(p)) // _loop0_122 + (seq = _loop0_123_rule(p)) // _loop0_123 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -16496,9 +16644,9 @@ _gather_121_rule(Parser *p) return _res; } -// _loop0_124: ',' target +// _loop0_125: ',' target static asdl_seq * -_loop0_124_rule(Parser *p) +_loop0_125_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16543,32 +16691,32 @@ _loop0_124_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_124"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_125"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_124_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_125_type, _seq); return _seq; } -// _gather_123: target _loop0_124 +// _gather_124: target _loop0_125 static asdl_seq * -_gather_123_rule(Parser *p) +_gather_124_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // target _loop0_124 + { // target _loop0_125 expr_ty elem; asdl_seq * seq; if ( (elem = target_rule(p)) // target && - (seq = _loop0_124_rule(p)) // _loop0_124 + (seq = _loop0_125_rule(p)) // _loop0_125 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -16581,9 +16729,9 @@ _gather_123_rule(Parser *p) return _res; } -// _tmp_125: args | expression for_if_clauses +// _tmp_126: args | expression for_if_clauses static void * -_tmp_125_rule(Parser *p) +_tmp_126_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16620,9 +16768,9 @@ _tmp_125_rule(Parser *p) return _res; } -// _loop0_126: star_named_expressions +// _loop0_127: star_named_expressions static asdl_seq * -_loop0_126_rule(Parser *p) +_loop0_127_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16659,19 +16807,19 @@ _loop0_126_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_126"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_127"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_126_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_127_type, _seq); return _seq; } -// _tmp_127: '=' annotated_rhs +// _tmp_128: '=' annotated_rhs static void * -_tmp_127_rule(Parser *p) +_tmp_128_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16697,9 +16845,9 @@ _tmp_127_rule(Parser *p) return _res; } -// _tmp_128: yield_expr | star_expressions +// _tmp_129: yield_expr | star_expressions static void * -_tmp_128_rule(Parser *p) +_tmp_129_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16733,9 +16881,9 @@ _tmp_128_rule(Parser *p) return _res; } -// _tmp_129: yield_expr | star_expressions +// _tmp_130: yield_expr | star_expressions static void * -_tmp_129_rule(Parser *p) +_tmp_130_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16769,9 +16917,9 @@ _tmp_129_rule(Parser *p) return _res; } -// _tmp_130: '[' | '(' | '{' +// _tmp_131: '[' | '(' | '{' static void * -_tmp_130_rule(Parser *p) +_tmp_131_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16816,9 +16964,9 @@ _tmp_130_rule(Parser *p) return _res; } -// _loop0_131: param_no_default +// _loop0_132: param_no_default static asdl_seq * -_loop0_131_rule(Parser *p) +_loop0_132_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16855,19 +17003,19 @@ _loop0_131_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_131"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_132"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop0_131_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_132_type, _seq); return _seq; } -// _tmp_132: slash_with_default | param_with_default+ +// _tmp_133: slash_with_default | param_with_default+ static void * -_tmp_132_rule(Parser *p) +_tmp_133_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16886,12 +17034,12 @@ _tmp_132_rule(Parser *p) p->mark = _mark; } { // param_with_default+ - asdl_seq * _loop1_146_var; + asdl_seq * _loop1_147_var; if ( - (_loop1_146_var = _loop1_146_rule(p)) // param_with_default+ + (_loop1_147_var = _loop1_147_rule(p)) // param_with_default+ ) { - _res = _loop1_146_var; + _res = _loop1_147_var; goto done; } p->mark = _mark; @@ -16901,9 +17049,9 @@ _tmp_132_rule(Parser *p) return _res; } -// _tmp_133: ')' | ',' (')' | '**') +// _tmp_134: ')' | ',' (')' | '**') static void * -_tmp_133_rule(Parser *p) +_tmp_134_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16923,14 +17071,14 @@ _tmp_133_rule(Parser *p) } { // ',' (')' | '**') Token * _literal; - void *_tmp_147_var; + void *_tmp_148_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_147_var = _tmp_147_rule(p)) // ')' | '**' + (_tmp_148_var = _tmp_148_rule(p)) // ')' | '**' ) { - _res = _PyPegen_dummy_name(p, _literal, _tmp_147_var); + _res = _PyPegen_dummy_name(p, _literal, _tmp_148_var); goto done; } p->mark = _mark; @@ -16940,9 +17088,9 @@ _tmp_133_rule(Parser *p) return _res; } -// _tmp_134: ':' | ',' (':' | '**') +// _tmp_135: ':' | ',' (':' | '**') static void * -_tmp_134_rule(Parser *p) +_tmp_135_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16962,14 +17110,14 @@ _tmp_134_rule(Parser *p) } { // ',' (':' | '**') Token * _literal; - void *_tmp_148_var; + void *_tmp_149_var; if ( (_literal = _PyPegen_expect_token(p, 12)) // token=',' && - (_tmp_148_var = _tmp_148_rule(p)) // ':' | '**' + (_tmp_149_var = _tmp_149_rule(p)) // ':' | '**' ) { - _res = _PyPegen_dummy_name(p, _literal, _tmp_148_var); + _res = _PyPegen_dummy_name(p, _literal, _tmp_149_var); goto done; } p->mark = _mark; @@ -16979,9 +17127,9 @@ _tmp_134_rule(Parser *p) return _res; } -// _tmp_135: star_targets '=' +// _tmp_136: star_targets '=' static void * -_tmp_135_rule(Parser *p) +_tmp_136_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17011,9 +17159,9 @@ _tmp_135_rule(Parser *p) return _res; } -// _tmp_136: '.' | '...' +// _tmp_137: '.' | '...' static void * -_tmp_136_rule(Parser *p) +_tmp_137_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17047,9 +17195,9 @@ _tmp_136_rule(Parser *p) return _res; } -// _tmp_137: '.' | '...' +// _tmp_138: '.' | '...' static void * -_tmp_137_rule(Parser *p) +_tmp_138_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17083,9 +17231,9 @@ _tmp_137_rule(Parser *p) return _res; } -// _tmp_138: '@' named_expression NEWLINE +// _tmp_139: '@' named_expression NEWLINE static void * -_tmp_138_rule(Parser *p) +_tmp_139_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17118,9 +17266,9 @@ _tmp_138_rule(Parser *p) return _res; } -// _tmp_139: ',' star_expression +// _tmp_140: ',' star_expression static void * -_tmp_139_rule(Parser *p) +_tmp_140_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17150,9 +17298,9 @@ _tmp_139_rule(Parser *p) return _res; } -// _tmp_140: ',' expression +// _tmp_141: ',' expression static void * -_tmp_140_rule(Parser *p) +_tmp_141_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17182,9 +17330,9 @@ _tmp_140_rule(Parser *p) return _res; } -// _tmp_141: 'or' conjunction +// _tmp_142: 'or' conjunction static void * -_tmp_141_rule(Parser *p) +_tmp_142_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17214,9 +17362,9 @@ _tmp_141_rule(Parser *p) return _res; } -// _tmp_142: 'and' inversion +// _tmp_143: 'and' inversion static void * -_tmp_142_rule(Parser *p) +_tmp_143_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17246,9 +17394,9 @@ _tmp_142_rule(Parser *p) return _res; } -// _tmp_143: 'if' disjunction +// _tmp_144: 'if' disjunction static void * -_tmp_143_rule(Parser *p) +_tmp_144_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17278,9 +17426,9 @@ _tmp_143_rule(Parser *p) return _res; } -// _tmp_144: 'if' disjunction +// _tmp_145: 'if' disjunction static void * -_tmp_144_rule(Parser *p) +_tmp_145_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17310,9 +17458,9 @@ _tmp_144_rule(Parser *p) return _res; } -// _tmp_145: ',' star_target +// _tmp_146: ',' star_target static void * -_tmp_145_rule(Parser *p) +_tmp_146_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17342,9 +17490,9 @@ _tmp_145_rule(Parser *p) return _res; } -// _loop1_146: param_with_default +// _loop1_147: param_with_default static asdl_seq * -_loop1_146_rule(Parser *p) +_loop1_147_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17385,19 +17533,19 @@ _loop1_146_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_146"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_147"); PyMem_Free(_children); return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); - _PyPegen_insert_memo(p, _start_mark, _loop1_146_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_147_type, _seq); return _seq; } -// _tmp_147: ')' | '**' +// _tmp_148: ')' | '**' static void * -_tmp_147_rule(Parser *p) +_tmp_148_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17431,9 +17579,9 @@ _tmp_147_rule(Parser *p) return _res; } -// _tmp_148: ':' | '**' +// _tmp_149: ':' | '**' static void * -_tmp_148_rule(Parser *p) +_tmp_149_rule(Parser *p) { if (p->error_indicator) { return NULL; diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c index 7f3e4561de6055..713bfac2ef55fe 100644 --- a/Parser/pegen/pegen.c +++ b/Parser/pegen/pegen.c @@ -2058,7 +2058,7 @@ _PyPegen_make_module(Parser *p, asdl_seq *a) { // Error reporting helpers expr_ty -_PyPegen_get_invalid_target(expr_ty e) +_PyPegen_get_invalid_target(expr_ty e, int del_targets) { if (e == NULL) { return NULL; @@ -2068,7 +2068,7 @@ _PyPegen_get_invalid_target(expr_ty e) Py_ssize_t len = asdl_seq_LEN(CONTAINER->v.TYPE.elts);\ for (Py_ssize_t i = 0; i < len; i++) {\ expr_ty other = asdl_seq_GET(CONTAINER->v.TYPE.elts, i);\ - expr_ty child = _PyPegen_get_invalid_target(other);\ + expr_ty child = _PyPegen_get_invalid_target(other, del_targets);\ if (child != NULL) {\ return child;\ }\ @@ -2091,7 +2091,12 @@ _PyPegen_get_invalid_target(expr_ty e) return NULL; } case Starred_kind: - return _PyPegen_get_invalid_target(e->v.Starred.value); + if (del_targets) { + return e; + } + else { + return _PyPegen_get_invalid_target(e->v.Starred.value, del_targets); + } case Name_kind: case Subscript_kind: case Attribute_kind: @@ -2099,4 +2104,4 @@ _PyPegen_get_invalid_target(expr_ty e) default: return e; } -} \ No newline at end of file +} diff --git a/Parser/pegen/pegen.h b/Parser/pegen/pegen.h index b9d4c048bb52b0..f8db7f861f4fbf 100644 --- a/Parser/pegen/pegen.h +++ b/Parser/pegen/pegen.h @@ -261,8 +261,9 @@ int _PyPegen_check_barry_as_flufl(Parser *); mod_ty _PyPegen_make_module(Parser *, asdl_seq *); // Error reporting helpers - -expr_ty _PyPegen_get_invalid_target(expr_ty e); +expr_ty _PyPegen_get_invalid_target(expr_ty e, int del_targets); +#define GET_INVALID_TARGET(e) _PyPegen_get_invalid_target(e, 0) +#define GET_INVALID_DEL_TARGET(e) _PyPegen_get_invalid_target(e, 1) void *_PyPegen_parse(Parser *); From d4a9dd681fe5f298807734667cc490d5007debff Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 15 May 2020 16:33:57 +0300 Subject: [PATCH 02/17] Fix test_exceptions --- Lib/test/test_exceptions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py index efd77fdbaabe1b..d4cab79ac4d176 100644 --- a/Lib/test/test_exceptions.py +++ b/Lib/test/test_exceptions.py @@ -248,9 +248,9 @@ def baz(): check('def f():\n x, y: int', 2, 3) check('[*x for x in xs]', 1, 2) check('foo(x for x in range(10), 100)', 1, 5) + check('for 1 in []: pass', 1, 5) check('(yield i) = 2', 1, 1 if support.use_old_parser() else 2) check('def f(*):\n pass', 1, 7 if support.use_old_parser() else 8) - check('for 1 in []: pass', 1, 5 if support.use_old_parser() else 7) @cpython_only def testSettingException(self): From 72a133922009f2f79a9c7f8e4543a452ec1d9d1d Mon Sep 17 00:00:00 2001 From: "blurb-it[bot]" <43283697+blurb-it[bot]@users.noreply.github.com> Date: Fri, 15 May 2020 13:38:58 +0000 Subject: [PATCH 03/17] =?UTF-8?q?=F0=9F=93=9C=F0=9F=A4=96=20Added=20by=20b?= =?UTF-8?q?lurb=5Fit.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../Core and Builtins/2020-05-15-13-38-54.bpo-40334.eQqslk.rst | 1 + 1 file changed, 1 insertion(+) create mode 100644 Misc/NEWS.d/next/Core and Builtins/2020-05-15-13-38-54.bpo-40334.eQqslk.rst diff --git a/Misc/NEWS.d/next/Core and Builtins/2020-05-15-13-38-54.bpo-40334.eQqslk.rst b/Misc/NEWS.d/next/Core and Builtins/2020-05-15-13-38-54.bpo-40334.eQqslk.rst new file mode 100644 index 00000000000000..419d858cfc3566 --- /dev/null +++ b/Misc/NEWS.d/next/Core and Builtins/2020-05-15-13-38-54.bpo-40334.eQqslk.rst @@ -0,0 +1 @@ +Produce better error messages for invalid targets. The error message remains the same for invalid `del` targets (`cannot delete `) and changes for invalid targets in `for` and `with` statements. In `for` statements the new error message is `'' is an illegal 'for' target`, while in `with` statements it is `'' is an illegal 'with' target`. \ No newline at end of file From 1b6cf0b327f024dc53ab548bbfb2bca55064c31c Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 15 May 2020 21:23:44 +0300 Subject: [PATCH 04/17] Produce the same error messages with the old parser for with and for targets --- Grammar/python.gram | 4 ++-- Lib/test/test_syntax.py | 20 +++++++++---------- .../2020-05-15-13-38-54.bpo-40334.eQqslk.rst | 1 - Parser/pegen/parse.c | 4 ++-- 4 files changed, 14 insertions(+), 15 deletions(-) delete mode 100644 Misc/NEWS.d/next/Core and Builtins/2020-05-15-13-38-54.bpo-40334.eQqslk.rst diff --git a/Grammar/python.gram b/Grammar/python.gram index d98667e75c9479..a427cfafc121f0 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -684,7 +684,7 @@ invalid_with_target: | ASYNC? 'with' expression 'as' a=expressions ':' { RAISE_SYNTAX_ERROR_KNOWN_LOCATION( GET_INVALID_TARGET(a), - "'%s' is an illegal 'with' target", _PyPegen_get_expr_name(GET_INVALID_TARGET(a)) + "cannot assign to %s", _PyPegen_get_expr_name(GET_INVALID_TARGET(a)) ) } # Comparison is used here, because the `a() in b` in `for a() in b: pass` is parsed @@ -694,5 +694,5 @@ invalid_for_target: | ASYNC? 'for' a=comparison { RAISE_SYNTAX_ERROR_KNOWN_LOCATION( GET_INVALID_TARGET(a->v.Compare.left), - "'%s' is an illegal 'for' target", _PyPegen_get_expr_name(GET_INVALID_TARGET(a->v.Compare.left)) + "cannot assign to %s", _PyPegen_get_expr_name(GET_INVALID_TARGET(a->v.Compare.left)) ) } diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py index 49d6c796b42ecb..a16831a3f64157 100644 --- a/Lib/test/test_syntax.py +++ b/Lib/test/test_syntax.py @@ -153,43 +153,43 @@ >>> for a() in b: pass Traceback (most recent call last): -SyntaxError: 'function call' is an illegal 'for' target +SyntaxError: cannot assign to function call >>> for (a, b()) in b: pass Traceback (most recent call last): -SyntaxError: 'function call' is an illegal 'for' target +SyntaxError: cannot assign to function call >>> for [a, b()] in b: pass Traceback (most recent call last): -SyntaxError: 'function call' is an illegal 'for' target +SyntaxError: cannot assign to function call >>> for (*a, b, c+1) in b: pass Traceback (most recent call last): -SyntaxError: 'operator' is an illegal 'for' target +SyntaxError: cannot assign to operator >>> for (x, *(y, z.d())) in b: pass Traceback (most recent call last): -SyntaxError: 'function call' is an illegal 'for' target +SyntaxError: cannot assign to function call >>> with a as b(): pass Traceback (most recent call last): -SyntaxError: 'function call' is an illegal 'with' target +SyntaxError: cannot assign to function call >>> with a as (b, c()): pass Traceback (most recent call last): -SyntaxError: 'function call' is an illegal 'with' target +SyntaxError: cannot assign to function call >>> with a as [b, c()]: pass Traceback (most recent call last): -SyntaxError: 'function call' is an illegal 'with' target +SyntaxError: cannot assign to function call >>> with a as (*b, c, d+1): pass Traceback (most recent call last): -SyntaxError: 'operator' is an illegal 'with' target +SyntaxError: cannot assign to operator >>> with a as (x, *(y, z.d())): pass Traceback (most recent call last): -SyntaxError: 'function call' is an illegal 'with' target +SyntaxError: cannot assign to function call From compiler_complex_args(): diff --git a/Misc/NEWS.d/next/Core and Builtins/2020-05-15-13-38-54.bpo-40334.eQqslk.rst b/Misc/NEWS.d/next/Core and Builtins/2020-05-15-13-38-54.bpo-40334.eQqslk.rst deleted file mode 100644 index 419d858cfc3566..00000000000000 --- a/Misc/NEWS.d/next/Core and Builtins/2020-05-15-13-38-54.bpo-40334.eQqslk.rst +++ /dev/null @@ -1 +0,0 @@ -Produce better error messages for invalid targets. The error message remains the same for invalid `del` targets (`cannot delete `) and changes for invalid targets in `for` and `with` statements. In `for` statements the new error message is `'' is an illegal 'for' target`, while in `with` statements it is `'' is an illegal 'with' target`. \ No newline at end of file diff --git a/Parser/pegen/parse.c b/Parser/pegen/parse.c index 65e5c6f05bf50b..42fc21860ca20b 100644 --- a/Parser/pegen/parse.c +++ b/Parser/pegen/parse.c @@ -11189,7 +11189,7 @@ invalid_with_target_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_TARGET ( a ) , "'%s' is an illegal 'with' target" , _PyPegen_get_expr_name ( GET_INVALID_TARGET ( a ) ) ); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_TARGET ( a ) , "cannot assign to %s" , _PyPegen_get_expr_name ( GET_INVALID_TARGET ( a ) ) ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; return NULL; @@ -11225,7 +11225,7 @@ invalid_for_target_rule(Parser *p) (a = comparison_rule(p)) // comparison ) { - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_TARGET ( a -> v . Compare . left ) , "'%s' is an illegal 'for' target" , _PyPegen_get_expr_name ( GET_INVALID_TARGET ( a -> v . Compare . left ) ) ); + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_TARGET ( a -> v . Compare . left ) , "cannot assign to %s" , _PyPegen_get_expr_name ( GET_INVALID_TARGET ( a -> v . Compare . left ) ) ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; return NULL; From 1ad3819b21c8b29a1203eb11332b293bb2467067 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 15 May 2020 21:35:10 +0300 Subject: [PATCH 05/17] Add invalid_group rule --- Grammar/python.gram | 16 +- Lib/test/test_syntax.py | 2 +- Parser/pegen/parse.c | 374 +++++++++++++++++++++------------------- 3 files changed, 209 insertions(+), 183 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index a427cfafc121f0..5905cbf6198cee 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -493,7 +493,9 @@ listcomp[expr_ty]: tuple[expr_ty]: | '(' a=[y=star_named_expression ',' z=[star_named_expressions] { _PyPegen_seq_insert_in_front(p, y, z) } ] ')' { _Py_Tuple(a, Load, EXTRA) } -group[expr_ty]: '(' a=(yield_expr | named_expression) ')' { a } +group[expr_ty]: + | '(' a=(yield_expr | named_expression) ')' { a } + | invalid_group genexp[expr_ty]: | '(' a=expression ~ b=for_if_clauses ')' { _Py_GeneratorExp(a, b, EXTRA) } | invalid_comprehension @@ -659,12 +661,6 @@ invalid_del_stmt: "cannot delete %s", _PyPegen_get_expr_name(GET_INVALID_DEL_TARGET(a)) ) : RAISE_SYNTAX_ERROR("invalid syntax") } - # This additional alternative is necessary, because (*a) is not a valid star_expression - # and will not be caught by the previous one. - | 'del' '(' a=starred_expression ')' { - RAISE_SYNTAX_ERROR_KNOWN_LOCATION( - a, - "cannot delete starred") } invalid_block: | NEWLINE !INDENT { RAISE_INDENTATION_ERROR("expected an indented block") } invalid_comprehension: @@ -696,3 +692,9 @@ invalid_for_target: GET_INVALID_TARGET(a->v.Compare.left), "cannot assign to %s", _PyPegen_get_expr_name(GET_INVALID_TARGET(a->v.Compare.left)) ) } + +invalid_group: + | '(' a=starred_expression ')' { + RAISE_SYNTAX_ERROR_KNOWN_LOCATION( + a, + "can't use starred expression here") } diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py index a16831a3f64157..657200224ebd65 100644 --- a/Lib/test/test_syntax.py +++ b/Lib/test/test_syntax.py @@ -745,7 +745,7 @@ def test_assign_del(self): self._check_error("del (1, 2)", "delete literal") self._check_error("del None", "delete None") self._check_error("del *x", "delete starred") - self._check_error("del (*x)", "delete starred") + self._check_error("del (*x)", "use starred expression") self._check_error("del (*x,)", "delete starred") self._check_error("del [*x,]", "delete starred") self._check_error("del f()", "delete function call") diff --git a/Parser/pegen/parse.c b/Parser/pegen/parse.c index 42fc21860ca20b..2d7beea4f5462d 100644 --- a/Parser/pegen/parse.c +++ b/Parser/pegen/parse.c @@ -222,155 +222,156 @@ static KeywordToken *reserved_keywords[] = { #define invalid_double_type_comments_type 1151 #define invalid_with_target_type 1152 #define invalid_for_target_type 1153 -#define _loop0_1_type 1154 -#define _loop0_2_type 1155 -#define _loop0_4_type 1156 -#define _gather_3_type 1157 -#define _loop0_6_type 1158 -#define _gather_5_type 1159 -#define _loop0_8_type 1160 -#define _gather_7_type 1161 -#define _loop0_10_type 1162 -#define _gather_9_type 1163 -#define _loop1_11_type 1164 -#define _loop0_13_type 1165 -#define _gather_12_type 1166 -#define _tmp_14_type 1167 -#define _tmp_15_type 1168 -#define _tmp_16_type 1169 -#define _tmp_17_type 1170 -#define _tmp_18_type 1171 -#define _tmp_19_type 1172 -#define _tmp_20_type 1173 -#define _tmp_21_type 1174 -#define _loop1_22_type 1175 -#define _tmp_23_type 1176 -#define _tmp_24_type 1177 -#define _loop0_26_type 1178 -#define _gather_25_type 1179 -#define _loop0_28_type 1180 -#define _gather_27_type 1181 -#define _tmp_29_type 1182 -#define _tmp_30_type 1183 -#define _loop0_31_type 1184 -#define _loop1_32_type 1185 -#define _loop0_34_type 1186 -#define _gather_33_type 1187 -#define _tmp_35_type 1188 -#define _loop0_37_type 1189 -#define _gather_36_type 1190 -#define _tmp_38_type 1191 -#define _loop0_40_type 1192 -#define _gather_39_type 1193 -#define _loop0_42_type 1194 -#define _gather_41_type 1195 -#define _loop0_44_type 1196 -#define _gather_43_type 1197 -#define _loop0_46_type 1198 -#define _gather_45_type 1199 -#define _tmp_47_type 1200 -#define _loop1_48_type 1201 -#define _tmp_49_type 1202 -#define _tmp_50_type 1203 -#define _tmp_51_type 1204 -#define _tmp_52_type 1205 -#define _tmp_53_type 1206 -#define _loop0_54_type 1207 -#define _loop0_55_type 1208 -#define _loop0_56_type 1209 -#define _loop1_57_type 1210 -#define _loop0_58_type 1211 -#define _loop1_59_type 1212 -#define _loop1_60_type 1213 -#define _loop1_61_type 1214 -#define _loop0_62_type 1215 -#define _loop1_63_type 1216 -#define _loop0_64_type 1217 -#define _loop1_65_type 1218 -#define _loop0_66_type 1219 -#define _loop1_67_type 1220 -#define _loop1_68_type 1221 -#define _tmp_69_type 1222 -#define _loop0_71_type 1223 -#define _gather_70_type 1224 -#define _loop1_72_type 1225 -#define _loop0_74_type 1226 -#define _gather_73_type 1227 -#define _loop1_75_type 1228 -#define _loop0_76_type 1229 -#define _loop0_77_type 1230 -#define _loop0_78_type 1231 -#define _loop1_79_type 1232 -#define _loop0_80_type 1233 -#define _loop1_81_type 1234 -#define _loop1_82_type 1235 -#define _loop1_83_type 1236 -#define _loop0_84_type 1237 -#define _loop1_85_type 1238 -#define _loop0_86_type 1239 -#define _loop1_87_type 1240 -#define _loop0_88_type 1241 -#define _loop1_89_type 1242 -#define _loop1_90_type 1243 -#define _loop1_91_type 1244 -#define _loop1_92_type 1245 -#define _tmp_93_type 1246 -#define _loop0_95_type 1247 -#define _gather_94_type 1248 -#define _tmp_96_type 1249 -#define _tmp_97_type 1250 -#define _tmp_98_type 1251 -#define _tmp_99_type 1252 -#define _loop1_100_type 1253 -#define _tmp_101_type 1254 -#define _tmp_102_type 1255 -#define _loop0_104_type 1256 -#define _gather_103_type 1257 -#define _loop1_105_type 1258 -#define _loop0_106_type 1259 -#define _loop0_107_type 1260 -#define _tmp_108_type 1261 -#define _tmp_109_type 1262 -#define _loop0_111_type 1263 -#define _gather_110_type 1264 -#define _loop0_113_type 1265 -#define _gather_112_type 1266 -#define _loop0_115_type 1267 -#define _gather_114_type 1268 -#define _loop0_117_type 1269 -#define _gather_116_type 1270 -#define _loop0_118_type 1271 -#define _loop0_120_type 1272 -#define _gather_119_type 1273 -#define _tmp_121_type 1274 -#define _loop0_123_type 1275 -#define _gather_122_type 1276 -#define _loop0_125_type 1277 -#define _gather_124_type 1278 -#define _tmp_126_type 1279 -#define _loop0_127_type 1280 -#define _tmp_128_type 1281 -#define _tmp_129_type 1282 -#define _tmp_130_type 1283 -#define _tmp_131_type 1284 -#define _loop0_132_type 1285 -#define _tmp_133_type 1286 -#define _tmp_134_type 1287 -#define _tmp_135_type 1288 -#define _tmp_136_type 1289 -#define _tmp_137_type 1290 -#define _tmp_138_type 1291 -#define _tmp_139_type 1292 -#define _tmp_140_type 1293 -#define _tmp_141_type 1294 -#define _tmp_142_type 1295 -#define _tmp_143_type 1296 -#define _tmp_144_type 1297 -#define _tmp_145_type 1298 -#define _tmp_146_type 1299 -#define _loop1_147_type 1300 -#define _tmp_148_type 1301 -#define _tmp_149_type 1302 +#define invalid_group_type 1154 +#define _loop0_1_type 1155 +#define _loop0_2_type 1156 +#define _loop0_4_type 1157 +#define _gather_3_type 1158 +#define _loop0_6_type 1159 +#define _gather_5_type 1160 +#define _loop0_8_type 1161 +#define _gather_7_type 1162 +#define _loop0_10_type 1163 +#define _gather_9_type 1164 +#define _loop1_11_type 1165 +#define _loop0_13_type 1166 +#define _gather_12_type 1167 +#define _tmp_14_type 1168 +#define _tmp_15_type 1169 +#define _tmp_16_type 1170 +#define _tmp_17_type 1171 +#define _tmp_18_type 1172 +#define _tmp_19_type 1173 +#define _tmp_20_type 1174 +#define _tmp_21_type 1175 +#define _loop1_22_type 1176 +#define _tmp_23_type 1177 +#define _tmp_24_type 1178 +#define _loop0_26_type 1179 +#define _gather_25_type 1180 +#define _loop0_28_type 1181 +#define _gather_27_type 1182 +#define _tmp_29_type 1183 +#define _tmp_30_type 1184 +#define _loop0_31_type 1185 +#define _loop1_32_type 1186 +#define _loop0_34_type 1187 +#define _gather_33_type 1188 +#define _tmp_35_type 1189 +#define _loop0_37_type 1190 +#define _gather_36_type 1191 +#define _tmp_38_type 1192 +#define _loop0_40_type 1193 +#define _gather_39_type 1194 +#define _loop0_42_type 1195 +#define _gather_41_type 1196 +#define _loop0_44_type 1197 +#define _gather_43_type 1198 +#define _loop0_46_type 1199 +#define _gather_45_type 1200 +#define _tmp_47_type 1201 +#define _loop1_48_type 1202 +#define _tmp_49_type 1203 +#define _tmp_50_type 1204 +#define _tmp_51_type 1205 +#define _tmp_52_type 1206 +#define _tmp_53_type 1207 +#define _loop0_54_type 1208 +#define _loop0_55_type 1209 +#define _loop0_56_type 1210 +#define _loop1_57_type 1211 +#define _loop0_58_type 1212 +#define _loop1_59_type 1213 +#define _loop1_60_type 1214 +#define _loop1_61_type 1215 +#define _loop0_62_type 1216 +#define _loop1_63_type 1217 +#define _loop0_64_type 1218 +#define _loop1_65_type 1219 +#define _loop0_66_type 1220 +#define _loop1_67_type 1221 +#define _loop1_68_type 1222 +#define _tmp_69_type 1223 +#define _loop0_71_type 1224 +#define _gather_70_type 1225 +#define _loop1_72_type 1226 +#define _loop0_74_type 1227 +#define _gather_73_type 1228 +#define _loop1_75_type 1229 +#define _loop0_76_type 1230 +#define _loop0_77_type 1231 +#define _loop0_78_type 1232 +#define _loop1_79_type 1233 +#define _loop0_80_type 1234 +#define _loop1_81_type 1235 +#define _loop1_82_type 1236 +#define _loop1_83_type 1237 +#define _loop0_84_type 1238 +#define _loop1_85_type 1239 +#define _loop0_86_type 1240 +#define _loop1_87_type 1241 +#define _loop0_88_type 1242 +#define _loop1_89_type 1243 +#define _loop1_90_type 1244 +#define _loop1_91_type 1245 +#define _loop1_92_type 1246 +#define _tmp_93_type 1247 +#define _loop0_95_type 1248 +#define _gather_94_type 1249 +#define _tmp_96_type 1250 +#define _tmp_97_type 1251 +#define _tmp_98_type 1252 +#define _tmp_99_type 1253 +#define _loop1_100_type 1254 +#define _tmp_101_type 1255 +#define _tmp_102_type 1256 +#define _loop0_104_type 1257 +#define _gather_103_type 1258 +#define _loop1_105_type 1259 +#define _loop0_106_type 1260 +#define _loop0_107_type 1261 +#define _tmp_108_type 1262 +#define _tmp_109_type 1263 +#define _loop0_111_type 1264 +#define _gather_110_type 1265 +#define _loop0_113_type 1266 +#define _gather_112_type 1267 +#define _loop0_115_type 1268 +#define _gather_114_type 1269 +#define _loop0_117_type 1270 +#define _gather_116_type 1271 +#define _loop0_118_type 1272 +#define _loop0_120_type 1273 +#define _gather_119_type 1274 +#define _tmp_121_type 1275 +#define _loop0_123_type 1276 +#define _gather_122_type 1277 +#define _loop0_125_type 1278 +#define _gather_124_type 1279 +#define _tmp_126_type 1280 +#define _loop0_127_type 1281 +#define _tmp_128_type 1282 +#define _tmp_129_type 1283 +#define _tmp_130_type 1284 +#define _tmp_131_type 1285 +#define _loop0_132_type 1286 +#define _tmp_133_type 1287 +#define _tmp_134_type 1288 +#define _tmp_135_type 1289 +#define _tmp_136_type 1290 +#define _tmp_137_type 1291 +#define _tmp_138_type 1292 +#define _tmp_139_type 1293 +#define _tmp_140_type 1294 +#define _tmp_141_type 1295 +#define _tmp_142_type 1296 +#define _tmp_143_type 1297 +#define _tmp_144_type 1298 +#define _tmp_145_type 1299 +#define _tmp_146_type 1300 +#define _loop1_147_type 1301 +#define _tmp_148_type 1302 +#define _tmp_149_type 1303 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -526,6 +527,7 @@ static void *invalid_lambda_star_etc_rule(Parser *p); static void *invalid_double_type_comments_rule(Parser *p); static void *invalid_with_target_rule(Parser *p); static void *invalid_for_target_rule(Parser *p); +static void *invalid_group_rule(Parser *p); static asdl_seq *_loop0_1_rule(Parser *p); static asdl_seq *_loop0_2_rule(Parser *p); static asdl_seq *_loop0_4_rule(Parser *p); @@ -8316,7 +8318,7 @@ tuple_rule(Parser *p) return _res; } -// group: '(' (yield_expr | named_expression) ')' +// group: '(' (yield_expr | named_expression) ')' | invalid_group static expr_ty group_rule(Parser *p) { @@ -8346,6 +8348,17 @@ group_rule(Parser *p) } p->mark = _mark; } + { // invalid_group + void *invalid_group_var; + if ( + (invalid_group_var = invalid_group_rule(p)) // invalid_group + ) + { + _res = invalid_group_var; + goto done; + } + p->mark = _mark; + } _res = NULL; done: return _res; @@ -10895,7 +10908,7 @@ invalid_assignment_rule(Parser *p) return _res; } -// invalid_del_stmt: 'del' star_expressions | 'del' '(' starred_expression ')' +// invalid_del_stmt: 'del' star_expressions static void * invalid_del_stmt_rule(Parser *p) { @@ -10922,30 +10935,6 @@ invalid_del_stmt_rule(Parser *p) } p->mark = _mark; } - { // 'del' '(' starred_expression ')' - Token * _keyword; - Token * _literal; - Token * _literal_1; - expr_ty a; - if ( - (_keyword = _PyPegen_expect_token(p, 503)) // token='del' - && - (_literal = _PyPegen_expect_token(p, 7)) // token='(' - && - (a = starred_expression_rule(p)) // starred_expression - && - (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' - ) - { - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "cannot delete starred" ); - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - return NULL; - } - goto done; - } - p->mark = _mark; - } _res = NULL; done: return _res; @@ -11239,6 +11228,41 @@ invalid_for_target_rule(Parser *p) return _res; } +// invalid_group: '(' starred_expression ')' +static void * +invalid_group_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '(' starred_expression ')' + Token * _literal; + Token * _literal_1; + expr_ty a; + if ( + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (a = starred_expression_rule(p)) // starred_expression + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + ) + { + _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( a , "can't use starred expression here" ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + return NULL; + } + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + // _loop0_1: NEWLINE static asdl_seq * _loop0_1_rule(Parser *p) From 6f30315741e04ad672e126fcd6366a6e81f4d2df Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sat, 16 May 2020 12:55:01 +0300 Subject: [PATCH 06/17] Update Grammar/python.gram Co-authored-by: Pablo Galindo --- Grammar/python.gram | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index 5905cbf6198cee..bf54904a32890c 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -695,6 +695,4 @@ invalid_for_target: invalid_group: | '(' a=starred_expression ')' { - RAISE_SYNTAX_ERROR_KNOWN_LOCATION( - a, - "can't use starred expression here") } + RAISE_SYNTAX_ERROR_KNOWN_LOCATION(a, "can't use starred expression here") } From f750aba1aee1a32c7000e7bac761dbbc468a5750 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sat, 16 May 2020 12:55:17 +0300 Subject: [PATCH 07/17] Update Parser/pegen/pegen.c Co-authored-by: Pablo Galindo --- Parser/pegen/pegen.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c index 713bfac2ef55fe..67036e34736fcd 100644 --- a/Parser/pegen/pegen.c +++ b/Parser/pegen/pegen.c @@ -2094,9 +2094,7 @@ _PyPegen_get_invalid_target(expr_ty e, int del_targets) if (del_targets) { return e; } - else { - return _PyPegen_get_invalid_target(e->v.Starred.value, del_targets); - } + return _PyPegen_get_invalid_target(e->v.Starred.value, del_targets); case Name_kind: case Subscript_kind: case Attribute_kind: From 132178ffe1308ddc78431e529863a91d7da7058e Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sat, 16 May 2020 13:48:31 +0300 Subject: [PATCH 08/17] Address Guido's feedback Correctly identify invalid targets, when there are multiple context managers in a with statement, avoid SEGFAULT in invalid for targets and improve paremeter naming in _PyPegen_get_invalid_target. --- Grammar/python.gram | 17 ++-- Lib/test/test_syntax.py | 8 ++ Parser/pegen/parse.c | 184 +++++++++++++++++++++++----------------- Parser/pegen/pegen.c | 19 ++++- Parser/pegen/pegen.h | 1 + 5 files changed, 138 insertions(+), 91 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index bf54904a32890c..c9319f24584732 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -181,9 +181,10 @@ with_stmt[stmt_ty]: CHECK_VERSION(5, "Async with statements are", _Py_AsyncWith(a, b, NULL, EXTRA)) } | ASYNC 'with' a=','.with_item+ ':' tc=[TYPE_COMMENT] b=block { CHECK_VERSION(5, "Async with statements are", _Py_AsyncWith(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA)) } - | invalid_with_target with_item[withitem_ty]: - | e=expression o=['as' t=target { t }] { _Py_withitem(e, o, p->arena) } + | e=expression 'as' t=target &(',' | ')' | ':') { _Py_withitem(e, t, p->arena) } + | invalid_with_item + | e=expression { _Py_withitem(e, NULL, p->arena) } try_stmt[stmt_ty]: | 'try' ':' b=block f=finally_block { _Py_Try(b, NULL, NULL, f, EXTRA) } @@ -676,8 +677,8 @@ invalid_lambda_star_etc: invalid_double_type_comments: | TYPE_COMMENT NEWLINE TYPE_COMMENT NEWLINE INDENT { RAISE_SYNTAX_ERROR("Cannot have two type comments on def") } -invalid_with_target: - | ASYNC? 'with' expression 'as' a=expressions ':' { +invalid_with_item: + | expression 'as' a=expression { RAISE_SYNTAX_ERROR_KNOWN_LOCATION( GET_INVALID_TARGET(a), "cannot assign to %s", _PyPegen_get_expr_name(GET_INVALID_TARGET(a)) @@ -688,10 +689,12 @@ invalid_with_target: # for invalid targets. invalid_for_target: | ASYNC? 'for' a=comparison { + _PyPegen_get_invalid_for_target(a) != NULL ? RAISE_SYNTAX_ERROR_KNOWN_LOCATION( - GET_INVALID_TARGET(a->v.Compare.left), - "cannot assign to %s", _PyPegen_get_expr_name(GET_INVALID_TARGET(a->v.Compare.left)) - ) } + _PyPegen_get_invalid_for_target(a), + "cannot assign to %s", _PyPegen_get_expr_name(_PyPegen_get_invalid_for_target(a)) + ) : + NULL } invalid_group: | '(' a=starred_expression ')' { diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py index 657200224ebd65..3bfe8fa5bf1346 100644 --- a/Lib/test/test_syntax.py +++ b/Lib/test/test_syntax.py @@ -171,6 +171,10 @@ Traceback (most recent call last): SyntaxError: cannot assign to function call +>>> for i < (): pass +Traceback (most recent call last): +SyntaxError: invalid syntax + >>> with a as b(): pass Traceback (most recent call last): SyntaxError: cannot assign to function call @@ -191,6 +195,10 @@ Traceback (most recent call last): SyntaxError: cannot assign to function call +>>> with a as b, c as d(): pass +Traceback (most recent call last): +SyntaxError: cannot assign to function call + From compiler_complex_args(): >>> def f(None=1): diff --git a/Parser/pegen/parse.c b/Parser/pegen/parse.c index 2d7beea4f5462d..388bd07762acf4 100644 --- a/Parser/pegen/parse.c +++ b/Parser/pegen/parse.c @@ -7,8 +7,8 @@ static KeywordToken *reserved_keywords[] = { (KeywordToken[]) { {"if", 510}, {"in", 518}, - {"is", 526}, - {"as", 531}, + {"as", 520}, + {"is", 527}, {"or", 532}, {NULL, -1}, }, @@ -16,8 +16,8 @@ static KeywordToken *reserved_keywords[] = { {"del", 503}, {"try", 511}, {"for", 517}, - {"def", 522}, - {"not", 525}, + {"def", 523}, + {"not", 526}, {"and", 533}, {NULL, -1}, }, @@ -27,8 +27,8 @@ static KeywordToken *reserved_keywords[] = { {"elif", 515}, {"else", 516}, {"with", 519}, - {"True", 527}, - {"None", 529}, + {"True", 528}, + {"None", 530}, {NULL, -1}, }, (KeywordToken[]) { @@ -36,8 +36,8 @@ static KeywordToken *reserved_keywords[] = { {"yield", 504}, {"break", 506}, {"while", 512}, - {"class", 523}, - {"False", 528}, + {"class", 524}, + {"False", 529}, {NULL, -1}, }, (KeywordToken[]) { @@ -45,12 +45,12 @@ static KeywordToken *reserved_keywords[] = { {"assert", 505}, {"global", 508}, {"import", 513}, - {"except", 520}, - {"lambda", 524}, + {"except", 521}, + {"lambda", 525}, {NULL, -1}, }, (KeywordToken[]) { - {"finally", 521}, + {"finally", 522}, {NULL, -1}, }, (KeywordToken[]) { @@ -64,7 +64,7 @@ static KeywordToken *reserved_keywords[] = { NULL, NULL, (KeywordToken[]) { - {"__new_parser__", 530}, + {"__new_parser__", 531}, {NULL, -1}, }, }; @@ -220,7 +220,7 @@ static KeywordToken *reserved_keywords[] = { #define invalid_star_etc_type 1149 #define invalid_lambda_star_etc_type 1150 #define invalid_double_type_comments_type 1151 -#define invalid_with_target_type 1152 +#define invalid_with_item_type 1152 #define invalid_for_target_type 1153 #define invalid_group_type 1154 #define _loop0_1_type 1155 @@ -525,7 +525,7 @@ static void *invalid_parameters_rule(Parser *p); static void *invalid_star_etc_rule(Parser *p); static void *invalid_lambda_star_etc_rule(Parser *p); static void *invalid_double_type_comments_rule(Parser *p); -static void *invalid_with_target_rule(Parser *p); +static void *invalid_with_item_rule(Parser *p); static void *invalid_for_target_rule(Parser *p); static void *invalid_group_rule(Parser *p); static asdl_seq *_loop0_1_rule(Parser *p); @@ -3090,7 +3090,6 @@ for_stmt_rule(Parser *p) // | 'with' ','.with_item+ ':' TYPE_COMMENT? block // | ASYNC 'with' '(' ','.with_item+ ','? ')' ':' block // | ASYNC 'with' ','.with_item+ ':' TYPE_COMMENT? block -// | invalid_with_target static stmt_ty with_stmt_rule(Parser *p) { @@ -3267,23 +3266,12 @@ with_stmt_rule(Parser *p) } p->mark = _mark; } - { // invalid_with_target - void *invalid_with_target_var; - if ( - (invalid_with_target_var = invalid_with_target_rule(p)) // invalid_with_target - ) - { - _res = invalid_with_target_var; - goto done; - } - p->mark = _mark; - } _res = NULL; done: return _res; } -// with_item: expression ['as' target] +// with_item: expression 'as' target &(',' | ')' | ':') | invalid_with_item | expression static withitem_ty with_item_rule(Parser *p) { @@ -3292,16 +3280,47 @@ with_item_rule(Parser *p) } withitem_ty _res = NULL; int _mark = p->mark; - { // expression ['as' target] + { // expression 'as' target &(',' | ')' | ':') + Token * _keyword; expr_ty e; - void *o; + expr_ty t; if ( (e = expression_rule(p)) // expression && - (o = _tmp_47_rule(p), 1) // ['as' target] + (_keyword = _PyPegen_expect_token(p, 520)) // token='as' + && + (t = target_rule(p)) // target + && + _PyPegen_lookahead(1, _tmp_47_rule, p) + ) + { + _res = _Py_withitem ( e , t , p -> arena ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + return NULL; + } + goto done; + } + p->mark = _mark; + } + { // invalid_with_item + void *invalid_with_item_var; + if ( + (invalid_with_item_var = invalid_with_item_rule(p)) // invalid_with_item + ) + { + _res = invalid_with_item_var; + goto done; + } + p->mark = _mark; + } + { // expression + expr_ty e; + if ( + (e = expression_rule(p)) // expression ) { - _res = _Py_withitem ( e , o , p -> arena ); + _res = _Py_withitem ( e , NULL , p -> arena ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; return NULL; @@ -3433,7 +3452,7 @@ except_block_rule(Parser *p) expr_ty e; void *t; if ( - (_keyword = _PyPegen_expect_token(p, 520)) // token='except' + (_keyword = _PyPegen_expect_token(p, 521)) // token='except' && (e = expression_rule(p)) // expression && @@ -3466,7 +3485,7 @@ except_block_rule(Parser *p) Token * _literal; asdl_seq* b; if ( - (_keyword = _PyPegen_expect_token(p, 520)) // token='except' + (_keyword = _PyPegen_expect_token(p, 521)) // token='except' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -3509,7 +3528,7 @@ finally_block_rule(Parser *p) Token * _literal; asdl_seq* a; if ( - (_keyword = _PyPegen_expect_token(p, 521)) // token='finally' + (_keyword = _PyPegen_expect_token(p, 522)) // token='finally' && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -3725,7 +3744,7 @@ function_def_raw_rule(Parser *p) void *params; void *tc; if ( - (_keyword = _PyPegen_expect_token(p, 522)) // token='def' + (_keyword = _PyPegen_expect_token(p, 523)) // token='def' && (n = _PyPegen_name_token(p)) // NAME && @@ -3775,7 +3794,7 @@ function_def_raw_rule(Parser *p) if ( (async_var = _PyPegen_expect_token(p, ASYNC)) // token='ASYNC' && - (_keyword = _PyPegen_expect_token(p, 522)) // token='def' + (_keyword = _PyPegen_expect_token(p, 523)) // token='def' && (n = _PyPegen_name_token(p)) // NAME && @@ -4658,7 +4677,7 @@ class_def_raw_rule(Parser *p) void *b; asdl_seq* c; if ( - (_keyword = _PyPegen_expect_token(p, 523)) // token='class' + (_keyword = _PyPegen_expect_token(p, 524)) // token='class' && (a = _PyPegen_name_token(p)) // NAME && @@ -5342,7 +5361,7 @@ lambdef_rule(Parser *p) void *a; expr_ty b; if ( - (_keyword = _PyPegen_expect_token(p, 524)) // token='lambda' + (_keyword = _PyPegen_expect_token(p, 525)) // token='lambda' && (a = lambda_parameters_rule(p), 1) // lambda_parameters? && @@ -6086,7 +6105,7 @@ inversion_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 525)) // token='not' + (_keyword = _PyPegen_expect_token(p, 526)) // token='not' && (a = inversion_rule(p)) // inversion ) @@ -6524,7 +6543,7 @@ notin_bitwise_or_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 525)) // token='not' + (_keyword = _PyPegen_expect_token(p, 526)) // token='not' && (_keyword_1 = _PyPegen_expect_token(p, 518)) // token='in' && @@ -6591,9 +6610,9 @@ isnot_bitwise_or_rule(Parser *p) Token * _keyword_1; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 526)) // token='is' + (_keyword = _PyPegen_expect_token(p, 527)) // token='is' && - (_keyword_1 = _PyPegen_expect_token(p, 525)) // token='not' + (_keyword_1 = _PyPegen_expect_token(p, 526)) // token='not' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -6625,7 +6644,7 @@ is_bitwise_or_rule(Parser *p) Token * _keyword; expr_ty a; if ( - (_keyword = _PyPegen_expect_token(p, 526)) // token='is' + (_keyword = _PyPegen_expect_token(p, 527)) // token='is' && (a = bitwise_or_rule(p)) // bitwise_or ) @@ -7943,7 +7962,7 @@ atom_rule(Parser *p) { // 'True' Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 527)) // token='True' + (_keyword = _PyPegen_expect_token(p, 528)) // token='True' ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -7966,7 +7985,7 @@ atom_rule(Parser *p) { // 'False' Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 528)) // token='False' + (_keyword = _PyPegen_expect_token(p, 529)) // token='False' ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -7989,7 +8008,7 @@ atom_rule(Parser *p) { // 'None' Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 529)) // token='None' + (_keyword = _PyPegen_expect_token(p, 530)) // token='None' ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -8012,7 +8031,7 @@ atom_rule(Parser *p) { // '__new_parser__' Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 530)) // token='__new_parser__' + (_keyword = _PyPegen_expect_token(p, 531)) // token='__new_parser__' ) { _res = RAISE_SYNTAX_ERROR ( "You found it!" ); @@ -11147,35 +11166,25 @@ invalid_double_type_comments_rule(Parser *p) return _res; } -// invalid_with_target: ASYNC? 'with' expression 'as' expressions ':' +// invalid_with_item: expression 'as' expression static void * -invalid_with_target_rule(Parser *p) +invalid_with_item_rule(Parser *p) { if (p->error_indicator) { return NULL; } void * _res = NULL; int _mark = p->mark; - { // ASYNC? 'with' expression 'as' expressions ':' + { // expression 'as' expression Token * _keyword; - Token * _keyword_1; - Token * _literal; - void *_opt_var; - UNUSED(_opt_var); // Silence compiler warnings expr_ty a; expr_ty expression_var; if ( - (_opt_var = _PyPegen_expect_token(p, ASYNC), 1) // ASYNC? - && - (_keyword = _PyPegen_expect_token(p, 519)) // token='with' - && (expression_var = expression_rule(p)) // expression && - (_keyword_1 = _PyPegen_expect_token(p, 531)) // token='as' - && - (a = expressions_rule(p)) // expressions + (_keyword = _PyPegen_expect_token(p, 520)) // token='as' && - (_literal = _PyPegen_expect_token(p, 11)) // token=':' + (a = expression_rule(p)) // expression ) { _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_TARGET ( a ) , "cannot assign to %s" , _PyPegen_get_expr_name ( GET_INVALID_TARGET ( a ) ) ); @@ -11214,7 +11223,7 @@ invalid_for_target_rule(Parser *p) (a = comparison_rule(p)) // comparison ) { - _res = RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_TARGET ( a -> v . Compare . left ) , "cannot assign to %s" , _PyPegen_get_expr_name ( GET_INVALID_TARGET ( a -> v . Compare . left ) ) ); + _res = _PyPegen_get_invalid_for_target ( a ) != NULL ? RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( _PyPegen_get_invalid_for_target ( a ) , "cannot assign to %s" , _PyPegen_get_expr_name ( _PyPegen_get_invalid_for_target ( a ) ) ) : NULL; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; return NULL; @@ -11887,7 +11896,7 @@ _tmp_15_rule(Parser *p) { // 'def' Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 522)) // token='def' + (_keyword = _PyPegen_expect_token(p, 523)) // token='def' ) { _res = _keyword; @@ -11934,7 +11943,7 @@ _tmp_16_rule(Parser *p) { // 'class' Token * _keyword; if ( - (_keyword = _PyPegen_expect_token(p, 523)) // token='class' + (_keyword = _PyPegen_expect_token(p, 524)) // token='class' ) { _res = _keyword; @@ -12703,7 +12712,7 @@ _tmp_35_rule(Parser *p) Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 531)) // token='as' + (_keyword = _PyPegen_expect_token(p, 520)) // token='as' && (z = _PyPegen_name_token(p)) // NAME ) @@ -12820,7 +12829,7 @@ _tmp_38_rule(Parser *p) Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 531)) // token='as' + (_keyword = _PyPegen_expect_token(p, 520)) // token='as' && (z = _PyPegen_name_token(p)) // NAME ) @@ -13179,7 +13188,7 @@ _gather_45_rule(Parser *p) return _res; } -// _tmp_47: 'as' target +// _tmp_47: ',' | ')' | ':' static void * _tmp_47_rule(Parser *p) { @@ -13188,20 +13197,35 @@ _tmp_47_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // 'as' target - Token * _keyword; - expr_ty t; + { // ',' + Token * _literal; if ( - (_keyword = _PyPegen_expect_token(p, 531)) // token='as' - && - (t = target_rule(p)) // target + (_literal = _PyPegen_expect_token(p, 12)) // token=',' ) { - _res = t; - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - return NULL; - } + _res = _literal; + goto done; + } + p->mark = _mark; + } + { // ')' + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 8)) // token=')' + ) + { + _res = _literal; + goto done; + } + p->mark = _mark; + } + { // ':' + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + ) + { + _res = _literal; goto done; } p->mark = _mark; @@ -13277,7 +13301,7 @@ _tmp_49_rule(Parser *p) Token * _keyword; expr_ty z; if ( - (_keyword = _PyPegen_expect_token(p, 531)) // token='as' + (_keyword = _PyPegen_expect_token(p, 520)) // token='as' && (z = _PyPegen_name_token(p)) // NAME ) diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c index 67036e34736fcd..387b02424bfc96 100644 --- a/Parser/pegen/pegen.c +++ b/Parser/pegen/pegen.c @@ -2058,7 +2058,7 @@ _PyPegen_make_module(Parser *p, asdl_seq *a) { // Error reporting helpers expr_ty -_PyPegen_get_invalid_target(expr_ty e, int del_targets) +_PyPegen_get_invalid_target(expr_ty e, int is_del) { if (e == NULL) { return NULL; @@ -2068,7 +2068,7 @@ _PyPegen_get_invalid_target(expr_ty e, int del_targets) Py_ssize_t len = asdl_seq_LEN(CONTAINER->v.TYPE.elts);\ for (Py_ssize_t i = 0; i < len; i++) {\ expr_ty other = asdl_seq_GET(CONTAINER->v.TYPE.elts, i);\ - expr_ty child = _PyPegen_get_invalid_target(other, del_targets);\ + expr_ty child = _PyPegen_get_invalid_target(other, is_del);\ if (child != NULL) {\ return child;\ }\ @@ -2091,10 +2091,10 @@ _PyPegen_get_invalid_target(expr_ty e, int del_targets) return NULL; } case Starred_kind: - if (del_targets) { + if (is_del) { return e; } - return _PyPegen_get_invalid_target(e->v.Starred.value, del_targets); + return _PyPegen_get_invalid_target(e->v.Starred.value, is_del); case Name_kind: case Subscript_kind: case Attribute_kind: @@ -2103,3 +2103,14 @@ _PyPegen_get_invalid_target(expr_ty e, int del_targets) return e; } } + +expr_ty _PyPegen_get_invalid_for_target(expr_ty e) +{ + assert(e != NULL && e->kind == Compare_kind); + + cmpop_ty op = asdl_seq_GET(e->v.Compare.ops, 0); + if (op != In) { + return NULL; + } + return _PyPegen_get_invalid_target(e->v.Compare.left, 0); +} diff --git a/Parser/pegen/pegen.h b/Parser/pegen/pegen.h index f8db7f861f4fbf..22289fcde3e242 100644 --- a/Parser/pegen/pegen.h +++ b/Parser/pegen/pegen.h @@ -261,6 +261,7 @@ int _PyPegen_check_barry_as_flufl(Parser *); mod_ty _PyPegen_make_module(Parser *, asdl_seq *); // Error reporting helpers +expr_ty _PyPegen_get_invalid_for_target(expr_ty e); expr_ty _PyPegen_get_invalid_target(expr_ty e, int del_targets); #define GET_INVALID_TARGET(e) _PyPegen_get_invalid_target(e, 0) #define GET_INVALID_DEL_TARGET(e) _PyPegen_get_invalid_target(e, 1) From 17cc4bcd2827897b6408cd7613a1fb3898bda6a2 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sun, 17 May 2020 04:50:23 +0300 Subject: [PATCH 09/17] Inline _PyPegen_get_invalid_for_target --- Parser/pegen/pegen.c | 11 ----------- Parser/pegen/pegen.h | 14 +++++++++++++- 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c index 387b02424bfc96..ce2fe5cf2fa492 100644 --- a/Parser/pegen/pegen.c +++ b/Parser/pegen/pegen.c @@ -2103,14 +2103,3 @@ _PyPegen_get_invalid_target(expr_ty e, int is_del) return e; } } - -expr_ty _PyPegen_get_invalid_for_target(expr_ty e) -{ - assert(e != NULL && e->kind == Compare_kind); - - cmpop_ty op = asdl_seq_GET(e->v.Compare.ops, 0); - if (op != In) { - return NULL; - } - return _PyPegen_get_invalid_target(e->v.Compare.left, 0); -} diff --git a/Parser/pegen/pegen.h b/Parser/pegen/pegen.h index 22289fcde3e242..b36fd1f43afa1f 100644 --- a/Parser/pegen/pegen.h +++ b/Parser/pegen/pegen.h @@ -261,11 +261,23 @@ int _PyPegen_check_barry_as_flufl(Parser *); mod_ty _PyPegen_make_module(Parser *, asdl_seq *); // Error reporting helpers -expr_ty _PyPegen_get_invalid_for_target(expr_ty e); expr_ty _PyPegen_get_invalid_target(expr_ty e, int del_targets); #define GET_INVALID_TARGET(e) _PyPegen_get_invalid_target(e, 0) #define GET_INVALID_DEL_TARGET(e) _PyPegen_get_invalid_target(e, 1) +Py_LOCAL_INLINE(expr_ty) +_PyPegen_get_invalid_for_target(expr_ty e) +{ + assert(e != NULL && e->kind == Compare_kind); + + cmpop_ty op = asdl_seq_GET(e->v.Compare.ops, 0); + if (op != In) { + return NULL; + } + return _PyPegen_get_invalid_target(e->v.Compare.left, 0); +} + +// Generated function in parse.c - function definition in python.gram void *_PyPegen_parse(Parser *); #endif From def0f3d7aee446785d773aac566921464d76b9e4 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sun, 17 May 2020 05:23:52 +0300 Subject: [PATCH 10/17] Revert inlining --- Parser/pegen/pegen.c | 12 ++++++++++++ Parser/pegen/pegen.h | 13 +------------ 2 files changed, 13 insertions(+), 12 deletions(-) diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c index ce2fe5cf2fa492..190d08cb800687 100644 --- a/Parser/pegen/pegen.c +++ b/Parser/pegen/pegen.c @@ -2103,3 +2103,15 @@ _PyPegen_get_invalid_target(expr_ty e, int is_del) return e; } } + +expr_ty +_PyPegen_get_invalid_for_target(expr_ty e) +{ + assert(e != NULL && e->kind == Compare_kind); + + cmpop_ty op = asdl_seq_GET(e->v.Compare.ops, 0); + if (op != In) { + return NULL; + } + return _PyPegen_get_invalid_target(e->v.Compare.left, 0); +} diff --git a/Parser/pegen/pegen.h b/Parser/pegen/pegen.h index b36fd1f43afa1f..661fab935b4570 100644 --- a/Parser/pegen/pegen.h +++ b/Parser/pegen/pegen.h @@ -261,22 +261,11 @@ int _PyPegen_check_barry_as_flufl(Parser *); mod_ty _PyPegen_make_module(Parser *, asdl_seq *); // Error reporting helpers +expr_ty _PyPegen_get_invalid_for_target(expr_ty e); expr_ty _PyPegen_get_invalid_target(expr_ty e, int del_targets); #define GET_INVALID_TARGET(e) _PyPegen_get_invalid_target(e, 0) #define GET_INVALID_DEL_TARGET(e) _PyPegen_get_invalid_target(e, 1) -Py_LOCAL_INLINE(expr_ty) -_PyPegen_get_invalid_for_target(expr_ty e) -{ - assert(e != NULL && e->kind == Compare_kind); - - cmpop_ty op = asdl_seq_GET(e->v.Compare.ops, 0); - if (op != In) { - return NULL; - } - return _PyPegen_get_invalid_target(e->v.Compare.left, 0); -} - // Generated function in parse.c - function definition in python.gram void *_PyPegen_parse(Parser *); From 4959a12d71c95f23451c18c8ce235a96e203729d Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sun, 17 May 2020 13:31:36 +0300 Subject: [PATCH 11/17] Fix searching for invalid for targets, by visiting Compare nodes in _PyPegen_get_invalid_target --- Grammar/python.gram | 11 ++++------- Lib/test/test_syntax.py | 8 ++++++++ Parser/pegen/parse.c | 8 ++++---- Parser/pegen/pegen.c | 26 +++++++++++--------------- Parser/pegen/pegen.h | 7 ++++--- 5 files changed, 31 insertions(+), 29 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index c9319f24584732..8bec5c6f56cc02 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -684,15 +684,12 @@ invalid_with_item: "cannot assign to %s", _PyPegen_get_expr_name(GET_INVALID_TARGET(a)) ) } -# Comparison is used here, because the `a() in b` in `for a() in b: pass` is parsed -# as a comparison. Thus, we only need to search the left side of the comparison -# for invalid targets. invalid_for_target: - | ASYNC? 'for' a=comparison { - _PyPegen_get_invalid_for_target(a) != NULL ? + | ASYNC? 'for' a=star_expressions { + GET_INVALID_FOR_TARGET(a) != NULL ? RAISE_SYNTAX_ERROR_KNOWN_LOCATION( - _PyPegen_get_invalid_for_target(a), - "cannot assign to %s", _PyPegen_get_expr_name(_PyPegen_get_invalid_for_target(a)) + GET_INVALID_FOR_TARGET(a), + "cannot assign to %s", _PyPegen_get_expr_name(GET_INVALID_FOR_TARGET(a)) ) : NULL } diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py index 3bfe8fa5bf1346..854edf4eed17aa 100644 --- a/Lib/test/test_syntax.py +++ b/Lib/test/test_syntax.py @@ -171,6 +171,14 @@ Traceback (most recent call last): SyntaxError: cannot assign to function call +>>> for a, b() in c: pass +Traceback (most recent call last): +SyntaxError: cannot assign to function call + +>>> for a, b, (c + 1, d()): pass +Traceback (most recent call last): +SyntaxError: cannot assign to operator + >>> for i < (): pass Traceback (most recent call last): SyntaxError: invalid syntax diff --git a/Parser/pegen/parse.c b/Parser/pegen/parse.c index f3426c22450876..2a93f648a5388b 100644 --- a/Parser/pegen/parse.c +++ b/Parser/pegen/parse.c @@ -11201,7 +11201,7 @@ invalid_with_item_rule(Parser *p) return _res; } -// invalid_for_target: ASYNC? 'for' comparison +// invalid_for_target: ASYNC? 'for' star_expressions static void * invalid_for_target_rule(Parser *p) { @@ -11210,7 +11210,7 @@ invalid_for_target_rule(Parser *p) } void * _res = NULL; int _mark = p->mark; - { // ASYNC? 'for' comparison + { // ASYNC? 'for' star_expressions Token * _keyword; void *_opt_var; UNUSED(_opt_var); // Silence compiler warnings @@ -11220,10 +11220,10 @@ invalid_for_target_rule(Parser *p) && (_keyword = _PyPegen_expect_token(p, 517)) // token='for' && - (a = comparison_rule(p)) // comparison + (a = star_expressions_rule(p)) // star_expressions ) { - _res = _PyPegen_get_invalid_for_target ( a ) != NULL ? RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( _PyPegen_get_invalid_for_target ( a ) , "cannot assign to %s" , _PyPegen_get_expr_name ( _PyPegen_get_invalid_for_target ( a ) ) ) : NULL; + _res = GET_INVALID_FOR_TARGET ( a ) != NULL ? RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_FOR_TARGET ( a ) , "cannot assign to %s" , _PyPegen_get_expr_name ( GET_INVALID_FOR_TARGET ( a ) ) ) : NULL; if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; return NULL; diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c index 190d08cb800687..eec937f2455680 100644 --- a/Parser/pegen/pegen.c +++ b/Parser/pegen/pegen.c @@ -2058,7 +2058,7 @@ _PyPegen_make_module(Parser *p, asdl_seq *a) { // Error reporting helpers expr_ty -_PyPegen_get_invalid_target(expr_ty e, int is_del) +_PyPegen_get_invalid_target(expr_ty e, int is_del, int is_for) { if (e == NULL) { return NULL; @@ -2068,7 +2068,7 @@ _PyPegen_get_invalid_target(expr_ty e, int is_del) Py_ssize_t len = asdl_seq_LEN(CONTAINER->v.TYPE.elts);\ for (Py_ssize_t i = 0; i < len; i++) {\ expr_ty other = asdl_seq_GET(CONTAINER->v.TYPE.elts, i);\ - expr_ty child = _PyPegen_get_invalid_target(other, is_del);\ + expr_ty child = _PyPegen_get_invalid_target(other, is_del, is_for);\ if (child != NULL) {\ return child;\ }\ @@ -2094,7 +2094,15 @@ _PyPegen_get_invalid_target(expr_ty e, int is_del) if (is_del) { return e; } - return _PyPegen_get_invalid_target(e->v.Starred.value, is_del); + return _PyPegen_get_invalid_target(e->v.Starred.value, is_del, is_for); + case Compare_kind: + // This is needed, because the `a in b` in `for a in b` gets parsed + // as a comparison, and so we need to search the left side of the comparison + // for invalid targets. + if (is_for) { + return _PyPegen_get_invalid_target(e->v.Compare.left, is_del, is_for); + } + return e; case Name_kind: case Subscript_kind: case Attribute_kind: @@ -2103,15 +2111,3 @@ _PyPegen_get_invalid_target(expr_ty e, int is_del) return e; } } - -expr_ty -_PyPegen_get_invalid_for_target(expr_ty e) -{ - assert(e != NULL && e->kind == Compare_kind); - - cmpop_ty op = asdl_seq_GET(e->v.Compare.ops, 0); - if (op != In) { - return NULL; - } - return _PyPegen_get_invalid_target(e->v.Compare.left, 0); -} diff --git a/Parser/pegen/pegen.h b/Parser/pegen/pegen.h index 661fab935b4570..c3a79f2cdd70e4 100644 --- a/Parser/pegen/pegen.h +++ b/Parser/pegen/pegen.h @@ -262,9 +262,10 @@ mod_ty _PyPegen_make_module(Parser *, asdl_seq *); // Error reporting helpers expr_ty _PyPegen_get_invalid_for_target(expr_ty e); -expr_ty _PyPegen_get_invalid_target(expr_ty e, int del_targets); -#define GET_INVALID_TARGET(e) _PyPegen_get_invalid_target(e, 0) -#define GET_INVALID_DEL_TARGET(e) _PyPegen_get_invalid_target(e, 1) +expr_ty _PyPegen_get_invalid_target(expr_ty e, int is_del, int is_for); +#define GET_INVALID_TARGET(e) _PyPegen_get_invalid_target(e, 0, 0) +#define GET_INVALID_DEL_TARGET(e) _PyPegen_get_invalid_target(e, 1, 0) +#define GET_INVALID_FOR_TARGET(e) _PyPegen_get_invalid_target(e, 0, 1) // Generated function in parse.c - function definition in python.gram void *_PyPegen_parse(Parser *); From dd1d8c82d318e5d98978324c49fcbfb85cbcf0c2 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Sun, 17 May 2020 13:36:53 +0300 Subject: [PATCH 12/17] Call RAISE_SYNTAX_ERROR instead of returning NULL, when no invalid for target was found --- Grammar/python.gram | 2 +- Parser/pegen/parse.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Grammar/python.gram b/Grammar/python.gram index 8bec5c6f56cc02..0799dbac678b59 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -691,7 +691,7 @@ invalid_for_target: GET_INVALID_FOR_TARGET(a), "cannot assign to %s", _PyPegen_get_expr_name(GET_INVALID_FOR_TARGET(a)) ) : - NULL } + RAISE_SYNTAX_ERROR("invalid syntax") } invalid_group: | '(' a=starred_expression ')' { diff --git a/Parser/pegen/parse.c b/Parser/pegen/parse.c index 2a93f648a5388b..057b313347d44a 100644 --- a/Parser/pegen/parse.c +++ b/Parser/pegen/parse.c @@ -11223,7 +11223,7 @@ invalid_for_target_rule(Parser *p) (a = star_expressions_rule(p)) // star_expressions ) { - _res = GET_INVALID_FOR_TARGET ( a ) != NULL ? RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_FOR_TARGET ( a ) , "cannot assign to %s" , _PyPegen_get_expr_name ( GET_INVALID_FOR_TARGET ( a ) ) ) : NULL; + _res = GET_INVALID_FOR_TARGET ( a ) != NULL ? RAISE_SYNTAX_ERROR_KNOWN_LOCATION ( GET_INVALID_FOR_TARGET ( a ) , "cannot assign to %s" , _PyPegen_get_expr_name ( GET_INVALID_FOR_TARGET ( a ) ) ) : RAISE_SYNTAX_ERROR ( "invalid syntax" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; return NULL; From c1cf8e63562999fe2ad8fac6a327e04c49f17aef Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Tue, 19 May 2020 02:32:09 +0300 Subject: [PATCH 13/17] Replace is_del and is_for args with an enum --- Parser/pegen/pegen.c | 12 ++++++------ Parser/pegen/pegen.h | 13 +++++++++---- 2 files changed, 15 insertions(+), 10 deletions(-) diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c index 27a424b7cf471b..a99ce76ba52640 100644 --- a/Parser/pegen/pegen.c +++ b/Parser/pegen/pegen.c @@ -2039,7 +2039,7 @@ _PyPegen_make_module(Parser *p, asdl_seq *a) { // Error reporting helpers expr_ty -_PyPegen_get_invalid_target(expr_ty e, int is_del, int is_for) +_PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type) { if (e == NULL) { return NULL; @@ -2049,7 +2049,7 @@ _PyPegen_get_invalid_target(expr_ty e, int is_del, int is_for) Py_ssize_t len = asdl_seq_LEN(CONTAINER->v.TYPE.elts);\ for (Py_ssize_t i = 0; i < len; i++) {\ expr_ty other = asdl_seq_GET(CONTAINER->v.TYPE.elts, i);\ - expr_ty child = _PyPegen_get_invalid_target(other, is_del, is_for);\ + expr_ty child = _PyPegen_get_invalid_target(other, targets_type);\ if (child != NULL) {\ return child;\ }\ @@ -2072,16 +2072,16 @@ _PyPegen_get_invalid_target(expr_ty e, int is_del, int is_for) return NULL; } case Starred_kind: - if (is_del) { + if (targets_type == DEL_TARGETS) { return e; } - return _PyPegen_get_invalid_target(e->v.Starred.value, is_del, is_for); + return _PyPegen_get_invalid_target(e->v.Starred.value, targets_type); case Compare_kind: // This is needed, because the `a in b` in `for a in b` gets parsed // as a comparison, and so we need to search the left side of the comparison // for invalid targets. - if (is_for) { - return _PyPegen_get_invalid_target(e->v.Compare.left, is_del, is_for); + if (targets_type == FOR_TARGETS) { + return _PyPegen_get_invalid_target(e->v.Compare.left, targets_type); } return e; case Name_kind: diff --git a/Parser/pegen/pegen.h b/Parser/pegen/pegen.h index d9422fa2cc53de..2f827557ff82da 100644 --- a/Parser/pegen/pegen.h +++ b/Parser/pegen/pegen.h @@ -260,10 +260,15 @@ int _PyPegen_check_barry_as_flufl(Parser *); mod_ty _PyPegen_make_module(Parser *, asdl_seq *); // Error reporting helpers -expr_ty _PyPegen_get_invalid_target(expr_ty e, int is_del, int is_for); -#define GET_INVALID_TARGET(e) _PyPegen_get_invalid_target(e, 0, 0) -#define GET_INVALID_DEL_TARGET(e) _PyPegen_get_invalid_target(e, 1, 0) -#define GET_INVALID_FOR_TARGET(e) _PyPegen_get_invalid_target(e, 0, 1) +typedef enum { + STAR_TARGETS, + DEL_TARGETS, + FOR_TARGETS +} TARGETS_TYPE; +expr_ty _PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type); +#define GET_INVALID_TARGET(e) _PyPegen_get_invalid_target(e, STAR_TARGETS) +#define GET_INVALID_DEL_TARGET(e) _PyPegen_get_invalid_target(e, DEL_TARGETS) +#define GET_INVALID_FOR_TARGET(e) _PyPegen_get_invalid_target(e, FOR_TARGETS) void *_PyPegen_arguments_parsing_error(Parser *, expr_ty); From 06798ff0df60a912781be56a008b390409db9724 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 20 May 2020 03:51:57 +0300 Subject: [PATCH 14/17] Only return an invalid target, when the comparison is an In comparison --- Parser/pegen/pegen.c | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c index a99ce76ba52640..ee70a1dc07b52d 100644 --- a/Parser/pegen/pegen.c +++ b/Parser/pegen/pegen.c @@ -2063,14 +2063,12 @@ _PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type) // we don't need to visit it recursively. switch (e->kind) { - case List_kind: { + case List_kind: VISIT_CONTAINER(e, List); return NULL; - } - case Tuple_kind: { + case Tuple_kind: VISIT_CONTAINER(e, Tuple); return NULL; - } case Starred_kind: if (targets_type == DEL_TARGETS) { return e; @@ -2081,7 +2079,13 @@ _PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type) // as a comparison, and so we need to search the left side of the comparison // for invalid targets. if (targets_type == FOR_TARGETS) { - return _PyPegen_get_invalid_target(e->v.Compare.left, targets_type); + cmpop_ty cmpop = (cmpop_ty) asdl_seq_GET(e->v.Compare.comparators, 0); + if (cmpop == In) { + return _PyPegen_get_invalid_target(e->v.Compare.left, targets_type); + } + else { + return NULL; + } } return e; case Name_kind: From ef7fe3afb4d922e02e87d9a41e8e1d4d76815a35 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 20 May 2020 04:18:09 +0300 Subject: [PATCH 15/17] Fix bug --- Parser/pegen/pegen.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c index ee70a1dc07b52d..0fe011cea1d48f 100644 --- a/Parser/pegen/pegen.c +++ b/Parser/pegen/pegen.c @@ -2079,7 +2079,7 @@ _PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type) // as a comparison, and so we need to search the left side of the comparison // for invalid targets. if (targets_type == FOR_TARGETS) { - cmpop_ty cmpop = (cmpop_ty) asdl_seq_GET(e->v.Compare.comparators, 0); + cmpop_ty cmpop = (cmpop_ty) asdl_seq_GET(e->v.Compare.ops, 0); if (cmpop == In) { return _PyPegen_get_invalid_target(e->v.Compare.left, targets_type); } From 82486c1ca9618075ea0dfa65e034fb09997590c1 Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Wed, 27 May 2020 00:51:31 +0300 Subject: [PATCH 16/17] Minor refactoring --- Parser/pegen/pegen.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/Parser/pegen/pegen.c b/Parser/pegen/pegen.c index e4cf19c19ef82d..a129577416e6b9 100644 --- a/Parser/pegen/pegen.c +++ b/Parser/pegen/pegen.c @@ -2108,9 +2108,7 @@ _PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type) if (cmpop == In) { return _PyPegen_get_invalid_target(e->v.Compare.left, targets_type); } - else { - return NULL; - } + return NULL; } return e; case Name_kind: From 55b53270bf73e45d2ef1cf6fac8e652e137e2a9b Mon Sep 17 00:00:00 2001 From: Lysandros Nikolaou Date: Fri, 19 Jun 2020 01:09:20 +0300 Subject: [PATCH 17/17] Add CHECK* checks to GET_INVALID_*TARGET macros --- Parser/pegen.c | 1 - Parser/pegen.h | 6 +++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/Parser/pegen.c b/Parser/pegen.c index 4ce84250fee7a3..b374740308a363 100644 --- a/Parser/pegen.c +++ b/Parser/pegen.c @@ -380,7 +380,6 @@ _PyPegen_raise_error(Parser *p, PyObject *errtype, const char *errmsg, ...) return NULL; } - void * _PyPegen_raise_error_known_location(Parser *p, PyObject *errtype, Py_ssize_t lineno, Py_ssize_t col_offset, diff --git a/Parser/pegen.h b/Parser/pegen.h index 171b7fd0c3b854..43168074c35000 100644 --- a/Parser/pegen.h +++ b/Parser/pegen.h @@ -269,9 +269,9 @@ typedef enum { FOR_TARGETS } TARGETS_TYPE; expr_ty _PyPegen_get_invalid_target(expr_ty e, TARGETS_TYPE targets_type); -#define GET_INVALID_TARGET(e) _PyPegen_get_invalid_target(e, STAR_TARGETS) -#define GET_INVALID_DEL_TARGET(e) _PyPegen_get_invalid_target(e, DEL_TARGETS) -#define GET_INVALID_FOR_TARGET(e) _PyPegen_get_invalid_target(e, FOR_TARGETS) +#define GET_INVALID_TARGET(e) (expr_ty)CHECK(_PyPegen_get_invalid_target(e, STAR_TARGETS)) +#define GET_INVALID_DEL_TARGET(e) (expr_ty)CHECK_NULL_ALLOWED(_PyPegen_get_invalid_target(e, DEL_TARGETS)) +#define GET_INVALID_FOR_TARGET(e) (expr_ty)CHECK_NULL_ALLOWED(_PyPegen_get_invalid_target(e, FOR_TARGETS)) void *_PyPegen_arguments_parsing_error(Parser *, expr_ty); void *_PyPegen_nonparen_genexp_in_call(Parser *p, expr_ty args);