diff --git a/Grammar/python.gram b/Grammar/python.gram index 0542107cac3e6b..30a20be6d56211 100644 --- a/Grammar/python.gram +++ b/Grammar/python.gram @@ -60,7 +60,7 @@ simple_stmt[asdl_seq*]: # will throw a SyntaxError. small_stmt[stmt_ty] (memo): | assignment - | e=star_expressions { _Py_Expr(e, EXTRA) } + | e=star_expressions !('=' | augassign) { _Py_Expr(e, EXTRA) } | &'return' return_stmt | &('import' | 'from') import_stmt | &'raise' raise_stmt @@ -72,6 +72,7 @@ small_stmt[stmt_ty] (memo): | 'continue' { _Py_Continue(EXTRA) } | &'global' global_stmt | &'nonlocal' nonlocal_stmt + | targets_with_invalid compound_stmt[stmt_ty]: | &('def' | '@' | ASYNC) function_def | &'if' if_stmt @@ -96,7 +97,7 @@ assignment[stmt_ty]: _Py_Assign(a, b, NEW_TYPE_COMMENT(p, tc), EXTRA) } | a=target b=augassign c=(yield_expr | star_expressions) { _Py_AugAssign(a, b->kind, c, EXTRA) } - | invalid_assignment + | invalid_ann_assignment augassign[AugOperator*]: | '+=' { _PyPegen_augoperator(p, Add) } @@ -564,14 +565,15 @@ star_targets_seq[asdl_seq*]: a=','.star_target+ [','] { a } star_target[expr_ty] (memo): | '*' a=(!'*' star_target) { _Py_Starred(CHECK(_PyPegen_set_expr_context(p, a, Store)), Store, EXTRA) } - | a=t_primary '.' b=NAME !t_lookahead { _Py_Attribute(a, b->v.Name.id, Store, EXTRA) } - | a=t_primary '[' b=slices ']' !t_lookahead { _Py_Subscript(a, b, Store, EXTRA) } + | a=t_primary '.' b=NAME &star_target_end { _Py_Attribute(a, b->v.Name.id, Store, EXTRA) } + | a=t_primary '[' b=slices ']' &star_target_end { _Py_Subscript(a, b, Store, EXTRA) } | star_atom star_atom[expr_ty]: - | a=NAME { _PyPegen_set_expr_context(p, a, Store) } + | a=NAME &star_target_end { _PyPegen_set_expr_context(p, a, Store) } | '(' a=star_target ')' { _PyPegen_set_expr_context(p, a, Store) } | '(' a=[star_targets_seq] ')' { _Py_Tuple(a, Store, EXTRA) } | '[' a=[star_targets_seq] ']' { _Py_List(a, Store, EXTRA) } +star_target_end: ')' | ']' | ',' | '=' | 'in' inside_paren_ann_assign_target[expr_ty]: | ann_assign_subscript_attribute_target @@ -599,8 +601,8 @@ del_target_end: ')' | ']' | ',' | ';' | NEWLINE targets[asdl_seq*]: a=','.target+ [','] { a } target[expr_ty] (memo): - | a=t_primary '.' b=NAME !t_lookahead { _Py_Attribute(a, b->v.Name.id, Store, EXTRA) } - | a=t_primary '[' b=slices ']' !t_lookahead { _Py_Subscript(a, b, Store, EXTRA) } + | a=t_primary '.' b=NAME &target_end { _Py_Attribute(a, b->v.Name.id, Store, EXTRA) } + | a=t_primary '[' b=slices ']' &target_end { _Py_Subscript(a, b, Store, EXTRA) } | t_atom t_primary[expr_ty]: | a=t_primary '.' b=NAME &t_lookahead { _Py_Attribute(a, b->v.Name.id, Load, EXTRA) } @@ -614,11 +616,11 @@ t_primary[expr_ty]: | a=atom &t_lookahead { a } t_lookahead: '(' | '[' | '.' t_atom[expr_ty]: - | a=NAME { _PyPegen_set_expr_context(p, a, Store) } + | a=NAME &target_end { _PyPegen_set_expr_context(p, a, Store) } | '(' a=target ')' { _PyPegen_set_expr_context(p, a, Store) } | '(' b=[targets] ')' { _Py_Tuple(b, Store, EXTRA) } | '[' b=[targets] ']' { _Py_List(b, Store, EXTRA) } - +target_end: ')' | ']' | ',' | augassign | ':' # From here on, there are rules for invalid syntax with specialised error messages incorrect_arguments: @@ -627,17 +629,16 @@ incorrect_arguments: RAISE_SYNTAX_ERROR("Generator expression must be parenthesized") } | a=args ',' args { _PyPegen_arguments_parsing_error(p, a) } invalid_kwarg: - | expression '=' { RAISE_SYNTAX_ERROR("expression cannot contain assignment, perhaps you meant \"==\"?") } + | expression '=' { + RAISE_SYNTAX_ERROR_NO_COL_OFFSET("expression cannot contain assignment, perhaps you meant \"==\"?") } invalid_named_expression: | a=expression ':=' expression { RAISE_SYNTAX_ERROR("cannot use assignment expressions with %s", _PyPegen_get_expr_name(a)) } -invalid_assignment: +invalid_ann_assignment: | list ':' { RAISE_SYNTAX_ERROR("only single target (not list) can be annotated") } | tuple ':' { RAISE_SYNTAX_ERROR("only single target (not tuple) can be annotated") } | expression ':' expression ['=' annotated_rhs] { RAISE_SYNTAX_ERROR("illegal target for annotation") } - | a=expression ('=' | augassign) (yield_expr | star_expressions) { - RAISE_SYNTAX_ERROR_NO_COL_OFFSET("cannot assign to %s", _PyPegen_get_expr_name(a)) } invalid_block: | NEWLINE !INDENT { RAISE_INDENTATION_ERROR("expected an indented block") } invalid_comprehension: @@ -656,3 +657,22 @@ invalid_double_type_comments: invalid_del_target: | a=star_expression &del_target_end { RAISE_SYNTAX_ERROR("cannot delete %s", _PyPegen_get_expr_name(a)) } + +targets_with_invalid: + | target_with_invalid !',' + | target_with_invalid (',' target_with_invalid)* [','] +target_with_invalid: + | '*' a=(!'*' target_with_invalid) + | a=t_primary '.' b=NAME &(star_target_end | target_end) + | a=t_primary '[' b=slices ']' &(star_target_end | target_end) + | target_atom_with_invalid + | invalid_target +target_atom_with_invalid: + | a=NAME &(star_target_end | target_end) { _PyPegen_set_expr_context(p, a, Store) } + | '(' a=target_with_invalid ')' { _PyPegen_set_expr_context(p, a, Store) } + | '(' a=[targets_with_invalid] ')' { _Py_Tuple(a, Store, EXTRA) } + | '[' a=[targets_with_invalid] ']' { _Py_List(a, Store, EXTRA) } + | invalid_target +invalid_target: + | a=star_expression &(star_target_end | target_end) { + RAISE_SYNTAX_ERROR_NO_COL_OFFSET("cannot assign to %s", _PyPegen_get_expr_name(a)) } diff --git a/Lib/test/test_peg_parser.py b/Lib/test/test_peg_parser.py index df2d46d8827f0e..a2f27bd4e2d454 100644 --- a/Lib/test/test_peg_parser.py +++ b/Lib/test/test_peg_parser.py @@ -724,7 +724,7 @@ def test_incorrect_ast_generation_with_specialized_errors(self) -> None: peg_parser.parse_string(source) self.assertTrue( error_text in se.exception.msg, - f"Actual error message does not match expexted for {source}" + f"Actual error message does not match expected for {source}" ) @unittest.expectedFailure diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py index 06636ae8a149a4..db1e397214de05 100644 --- a/Lib/test/test_syntax.py +++ b/Lib/test/test_syntax.py @@ -100,30 +100,29 @@ This test just checks a couple of cases rather than enumerating all of them. -# All of the following also produce different error messages with pegen -# >>> (a, "b", c) = (1, 2, 3) -# Traceback (most recent call last): -# SyntaxError: cannot assign to literal +>>> (a, "b", c) = (1, 2, 3) +Traceback (most recent call last): +SyntaxError: cannot assign to literal -# >>> (a, True, c) = (1, 2, 3) -# Traceback (most recent call last): -# SyntaxError: cannot assign to True +>>> (a, True, c) = (1, 2, 3) +Traceback (most recent call last): +SyntaxError: cannot assign to True >>> (a, __debug__, c) = (1, 2, 3) Traceback (most recent call last): SyntaxError: cannot assign to __debug__ -# >>> (a, *True, c) = (1, 2, 3) -# Traceback (most recent call last): -# SyntaxError: cannot assign to True +>>> (a, *True, c) = (1, 2, 3) +Traceback (most recent call last): +SyntaxError: cannot assign to True >>> (a, *__debug__, c) = (1, 2, 3) Traceback (most recent call last): SyntaxError: cannot assign to __debug__ -# >>> [a, b, c + 1] = [1, 2, 3] -# Traceback (most recent call last): -# SyntaxError: cannot assign to operator +>>> [a, b, c + 1] = [1, 2, 3] +Traceback (most recent call last): +SyntaxError: cannot assign to operator >>> a if 1 else b = 1 Traceback (most recent call last): @@ -300,28 +299,25 @@ ... 290, 291, 292, 293, 294, 295, 296, 297, 298, 299) # doctest: +ELLIPSIS (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ..., 297, 298, 299) -# >>> f(lambda x: x[0] = 3) -# Traceback (most recent call last): -# SyntaxError: expression cannot contain assignment, perhaps you meant "=="? +>>> f(lambda x: x[0] = 3) +Traceback (most recent call last): +SyntaxError: expression cannot contain assignment, perhaps you meant "=="? The grammar accepts any test (basically, any expression) in the keyword slot of a call site. Test a few different options. -# >>> f(x()=2) -# Traceback (most recent call last): -# SyntaxError: expression cannot contain assignment, perhaps you meant "=="? -# >>> f(a or b=1) -# Traceback (most recent call last): -# SyntaxError: expression cannot contain assignment, perhaps you meant "=="? -# >>> f(x.y=1) -# Traceback (most recent call last): -# SyntaxError: expression cannot contain assignment, perhaps you meant "=="? -# >>> f((x)=2) -# Traceback (most recent call last): -# SyntaxError: expression cannot contain assignment, perhaps you meant "=="? -# >>> f(True=2) -# Traceback (most recent call last): -# SyntaxError: cannot assign to True +>>> f(x()=2) +Traceback (most recent call last): +SyntaxError: expression cannot contain assignment, perhaps you meant "=="? +>>> f(a or b=1) +Traceback (most recent call last): +SyntaxError: expression cannot contain assignment, perhaps you meant "=="? +>>> f(x.y=1) +Traceback (most recent call last): +SyntaxError: expression cannot contain assignment, perhaps you meant "=="? +>>> f((x)=2) +Traceback (most recent call last): +SyntaxError: expression cannot contain assignment, perhaps you meant "=="? >>> f(__debug__=1) Traceback (most recent call last): SyntaxError: cannot assign to __debug__ diff --git a/Parser/pegen/parse.c b/Parser/pegen/parse.c index a1a6f4c06bf63d..aedbc340997abf 100644 --- a/Parser/pegen/parse.c +++ b/Parser/pegen/parse.c @@ -199,175 +199,187 @@ static KeywordToken *reserved_keywords[] = { #define star_targets_seq_type 1128 #define star_target_type 1129 #define star_atom_type 1130 -#define inside_paren_ann_assign_target_type 1131 -#define ann_assign_subscript_attribute_target_type 1132 -#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 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 _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 _tmp_126_type 1278 -#define _tmp_127_type 1279 -#define _tmp_128_type 1280 -#define _tmp_129_type 1281 -#define _loop0_130_type 1282 -#define _tmp_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 _loop1_145_type 1297 -#define _tmp_146_type 1298 -#define _tmp_147_type 1299 +#define star_target_end_type 1131 +#define inside_paren_ann_assign_target_type 1132 +#define ann_assign_subscript_attribute_target_type 1133 +#define del_targets_type 1134 +#define del_target_type 1135 +#define del_t_atom_type 1136 +#define del_target_end_type 1137 +#define targets_type 1138 +#define target_type 1139 +#define t_primary_type 1140 // Left-recursive +#define t_lookahead_type 1141 +#define t_atom_type 1142 +#define target_end_type 1143 +#define incorrect_arguments_type 1144 +#define invalid_kwarg_type 1145 +#define invalid_named_expression_type 1146 +#define invalid_ann_assignment_type 1147 +#define invalid_block_type 1148 +#define invalid_comprehension_type 1149 +#define invalid_parameters_type 1150 +#define invalid_star_etc_type 1151 +#define invalid_lambda_star_etc_type 1152 +#define invalid_double_type_comments_type 1153 +#define invalid_del_target_type 1154 +#define targets_with_invalid_type 1155 +#define target_with_invalid_type 1156 +#define target_atom_with_invalid_type 1157 +#define invalid_target_type 1158 +#define _loop0_1_type 1159 +#define _loop0_2_type 1160 +#define _loop0_4_type 1161 +#define _gather_3_type 1162 +#define _loop0_6_type 1163 +#define _gather_5_type 1164 +#define _loop0_8_type 1165 +#define _gather_7_type 1166 +#define _loop0_10_type 1167 +#define _gather_9_type 1168 +#define _loop1_11_type 1169 +#define _loop0_13_type 1170 +#define _gather_12_type 1171 +#define _tmp_14_type 1172 +#define _tmp_15_type 1173 +#define _tmp_16_type 1174 +#define _tmp_17_type 1175 +#define _tmp_18_type 1176 +#define _tmp_19_type 1177 +#define _tmp_20_type 1178 +#define _tmp_21_type 1179 +#define _tmp_22_type 1180 +#define _loop1_23_type 1181 +#define _tmp_24_type 1182 +#define _tmp_25_type 1183 +#define _loop0_27_type 1184 +#define _gather_26_type 1185 +#define _loop0_29_type 1186 +#define _gather_28_type 1187 +#define _tmp_30_type 1188 +#define _loop0_31_type 1189 +#define _loop1_32_type 1190 +#define _loop0_34_type 1191 +#define _gather_33_type 1192 +#define _tmp_35_type 1193 +#define _loop0_37_type 1194 +#define _gather_36_type 1195 +#define _tmp_38_type 1196 +#define _loop0_40_type 1197 +#define _gather_39_type 1198 +#define _loop0_42_type 1199 +#define _gather_41_type 1200 +#define _loop0_44_type 1201 +#define _gather_43_type 1202 +#define _loop0_46_type 1203 +#define _gather_45_type 1204 +#define _tmp_47_type 1205 +#define _loop1_48_type 1206 +#define _tmp_49_type 1207 +#define _tmp_50_type 1208 +#define _tmp_51_type 1209 +#define _tmp_52_type 1210 +#define _tmp_53_type 1211 +#define _loop0_54_type 1212 +#define _loop0_55_type 1213 +#define _loop0_56_type 1214 +#define _loop1_57_type 1215 +#define _loop0_58_type 1216 +#define _loop1_59_type 1217 +#define _loop1_60_type 1218 +#define _loop1_61_type 1219 +#define _loop0_62_type 1220 +#define _loop1_63_type 1221 +#define _loop0_64_type 1222 +#define _loop1_65_type 1223 +#define _loop0_66_type 1224 +#define _loop1_67_type 1225 +#define _loop1_68_type 1226 +#define _tmp_69_type 1227 +#define _loop0_71_type 1228 +#define _gather_70_type 1229 +#define _loop1_72_type 1230 +#define _loop0_74_type 1231 +#define _gather_73_type 1232 +#define _loop1_75_type 1233 +#define _loop0_76_type 1234 +#define _loop0_77_type 1235 +#define _loop0_78_type 1236 +#define _loop1_79_type 1237 +#define _loop0_80_type 1238 +#define _loop1_81_type 1239 +#define _loop1_82_type 1240 +#define _loop1_83_type 1241 +#define _loop0_84_type 1242 +#define _loop1_85_type 1243 +#define _loop0_86_type 1244 +#define _loop1_87_type 1245 +#define _loop0_88_type 1246 +#define _loop1_89_type 1247 +#define _loop1_90_type 1248 +#define _loop1_91_type 1249 +#define _loop1_92_type 1250 +#define _tmp_93_type 1251 +#define _loop0_95_type 1252 +#define _gather_94_type 1253 +#define _tmp_96_type 1254 +#define _tmp_97_type 1255 +#define _tmp_98_type 1256 +#define _tmp_99_type 1257 +#define _loop1_100_type 1258 +#define _tmp_101_type 1259 +#define _tmp_102_type 1260 +#define _loop0_104_type 1261 +#define _gather_103_type 1262 +#define _loop1_105_type 1263 +#define _loop0_106_type 1264 +#define _loop0_107_type 1265 +#define _tmp_108_type 1266 +#define _tmp_109_type 1267 +#define _loop0_111_type 1268 +#define _gather_110_type 1269 +#define _loop0_113_type 1270 +#define _gather_112_type 1271 +#define _loop0_115_type 1272 +#define _gather_114_type 1273 +#define _loop0_117_type 1274 +#define _gather_116_type 1275 +#define _loop0_118_type 1276 +#define _loop0_120_type 1277 +#define _gather_119_type 1278 +#define _tmp_121_type 1279 +#define _loop0_123_type 1280 +#define _gather_122_type 1281 +#define _loop0_125_type 1282 +#define _gather_124_type 1283 +#define _tmp_126_type 1284 +#define _tmp_127_type 1285 +#define _tmp_128_type 1286 +#define _loop0_129_type 1287 +#define _tmp_130_type 1288 +#define _tmp_131_type 1289 +#define _tmp_132_type 1290 +#define _loop0_133_type 1291 +#define _tmp_134_type 1292 +#define _tmp_135_type 1293 +#define _tmp_136_type 1294 +#define _tmp_137_type 1295 +#define _tmp_138_type 1296 +#define _tmp_139_type 1297 +#define _tmp_140_type 1298 +#define _tmp_141_type 1299 +#define _tmp_142_type 1300 +#define _tmp_143_type 1301 +#define _tmp_144_type 1302 +#define _tmp_145_type 1303 +#define _tmp_146_type 1304 +#define _tmp_147_type 1305 +#define _tmp_148_type 1306 +#define _tmp_149_type 1307 +#define _loop1_150_type 1308 +#define _tmp_151_type 1309 +#define _tmp_152_type 1310 +#define _tmp_153_type 1311 static mod_ty file_rule(Parser *p); static mod_ty interactive_rule(Parser *p); @@ -500,6 +512,7 @@ static expr_ty star_targets_rule(Parser *p); static asdl_seq* star_targets_seq_rule(Parser *p); static expr_ty star_target_rule(Parser *p); static expr_ty star_atom_rule(Parser *p); +static void *star_target_end_rule(Parser *p); static expr_ty inside_paren_ann_assign_target_rule(Parser *p); static expr_ty ann_assign_subscript_attribute_target_rule(Parser *p); static asdl_seq* del_targets_rule(Parser *p); @@ -511,10 +524,11 @@ static expr_ty target_rule(Parser *p); static expr_ty t_primary_rule(Parser *p); static void *t_lookahead_rule(Parser *p); static expr_ty t_atom_rule(Parser *p); +static void *target_end_rule(Parser *p); 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_ann_assignment_rule(Parser *p); static void *invalid_block_rule(Parser *p); static void *invalid_comprehension_rule(Parser *p); static void *invalid_parameters_rule(Parser *p); @@ -522,6 +536,10 @@ 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 *targets_with_invalid_rule(Parser *p); +static void *target_with_invalid_rule(Parser *p); +static void *target_atom_with_invalid_rule(Parser *p); +static void *invalid_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); @@ -543,118 +561,118 @@ static void *_tmp_18_rule(Parser *p); static void *_tmp_19_rule(Parser *p); static void *_tmp_20_rule(Parser *p); static void *_tmp_21_rule(Parser *p); -static asdl_seq *_loop1_22_rule(Parser *p); -static void *_tmp_23_rule(Parser *p); +static void *_tmp_22_rule(Parser *p); +static asdl_seq *_loop1_23_rule(Parser *p); static void *_tmp_24_rule(Parser *p); -static asdl_seq *_loop0_26_rule(Parser *p); -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_25_rule(Parser *p); +static asdl_seq *_loop0_27_rule(Parser *p); +static asdl_seq *_gather_26_rule(Parser *p); +static asdl_seq *_loop0_29_rule(Parser *p); +static asdl_seq *_gather_28_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 *_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 void *_tmp_127_rule(Parser *p); static void *_tmp_128_rule(Parser *p); -static void *_tmp_129_rule(Parser *p); -static asdl_seq *_loop0_130_rule(Parser *p); +static asdl_seq *_loop0_129_rule(Parser *p); +static void *_tmp_130_rule(Parser *p); static void *_tmp_131_rule(Parser *p); static void *_tmp_132_rule(Parser *p); -static void *_tmp_133_rule(Parser *p); +static asdl_seq *_loop0_133_rule(Parser *p); static void *_tmp_134_rule(Parser *p); static void *_tmp_135_rule(Parser *p); static void *_tmp_136_rule(Parser *p); @@ -666,9 +684,15 @@ static void *_tmp_141_rule(Parser *p); static void *_tmp_142_rule(Parser *p); static void *_tmp_143_rule(Parser *p); static void *_tmp_144_rule(Parser *p); -static asdl_seq *_loop1_145_rule(Parser *p); +static void *_tmp_145_rule(Parser *p); static void *_tmp_146_rule(Parser *p); static void *_tmp_147_rule(Parser *p); +static void *_tmp_148_rule(Parser *p); +static void *_tmp_149_rule(Parser *p); +static asdl_seq *_loop1_150_rule(Parser *p); +static void *_tmp_151_rule(Parser *p); +static void *_tmp_152_rule(Parser *p); +static void *_tmp_153_rule(Parser *p); // file: statements? $ @@ -1231,7 +1255,7 @@ simple_stmt_rule(Parser *p) // small_stmt: // | assignment -// | star_expressions +// | star_expressions !('=' | augassign) // | &'return' return_stmt // | &('import' | 'from') import_stmt // | &'raise' raise_stmt @@ -1243,6 +1267,7 @@ simple_stmt_rule(Parser *p) // | 'continue' // | &'global' global_stmt // | &'nonlocal' nonlocal_stmt +// | targets_with_invalid static stmt_ty small_stmt_rule(Parser *p) { @@ -1272,10 +1297,12 @@ small_stmt_rule(Parser *p) } p->mark = _mark; } - { // star_expressions + { // star_expressions !('=' | augassign) expr_ty e; if ( (e = star_expressions_rule(p)) // star_expressions + && + _PyPegen_lookahead(0, _tmp_14_rule, p) ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -1311,7 +1338,7 @@ small_stmt_rule(Parser *p) { // &('import' | 'from') import_stmt stmt_ty import_stmt_var; if ( - _PyPegen_lookahead(1, _tmp_14_rule, p) + _PyPegen_lookahead(1, _tmp_15_rule, p) && (import_stmt_var = import_stmt_rule(p)) // import_stmt ) @@ -1468,6 +1495,17 @@ small_stmt_rule(Parser *p) } p->mark = _mark; } + { // targets_with_invalid + void *targets_with_invalid_var; + if ( + (targets_with_invalid_var = targets_with_invalid_rule(p)) // targets_with_invalid + ) + { + _res = targets_with_invalid_var; + goto done; + } + p->mark = _mark; + } _res = NULL; done: _PyPegen_insert_memo(p, _mark, small_stmt_type, _res); @@ -1493,7 +1531,7 @@ compound_stmt_rule(Parser *p) { // &('def' | '@' | ASYNC) function_def stmt_ty function_def_var; if ( - _PyPegen_lookahead(1, _tmp_15_rule, p) + _PyPegen_lookahead(1, _tmp_16_rule, p) && (function_def_var = function_def_rule(p)) // function_def ) @@ -1519,7 +1557,7 @@ compound_stmt_rule(Parser *p) { // &('class' | '@') class_def stmt_ty class_def_var; if ( - _PyPegen_lookahead(1, _tmp_16_rule, p) + _PyPegen_lookahead(1, _tmp_17_rule, p) && (class_def_var = class_def_rule(p)) // class_def ) @@ -1532,7 +1570,7 @@ compound_stmt_rule(Parser *p) { // &('with' | ASYNC) with_stmt stmt_ty with_stmt_var; if ( - _PyPegen_lookahead(1, _tmp_17_rule, p) + _PyPegen_lookahead(1, _tmp_18_rule, p) && (with_stmt_var = with_stmt_rule(p)) // with_stmt ) @@ -1545,7 +1583,7 @@ compound_stmt_rule(Parser *p) { // &('for' | ASYNC) for_stmt stmt_ty for_stmt_var; if ( - _PyPegen_lookahead(1, _tmp_18_rule, p) + _PyPegen_lookahead(1, _tmp_19_rule, p) && (for_stmt_var = for_stmt_rule(p)) // for_stmt ) @@ -1591,7 +1629,7 @@ compound_stmt_rule(Parser *p) // | ('(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target) ':' expression ['=' annotated_rhs] // | ((star_targets '='))+ (yield_expr | star_expressions) TYPE_COMMENT? // | target augassign (yield_expr | star_expressions) -// | invalid_assignment +// | invalid_ann_assignment static stmt_ty assignment_rule(Parser *p) { @@ -1620,7 +1658,7 @@ assignment_rule(Parser *p) && (b = expression_rule(p)) // expression && - (c = _tmp_19_rule(p), 1) // ['=' annotated_rhs] + (c = _tmp_20_rule(p), 1) // ['=' annotated_rhs] ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -1646,13 +1684,13 @@ assignment_rule(Parser *p) expr_ty b; void *c; if ( - (a = _tmp_20_rule(p)) // '(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target + (a = _tmp_21_rule(p)) // '(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && (b = expression_rule(p)) // expression && - (c = _tmp_21_rule(p), 1) // ['=' annotated_rhs] + (c = _tmp_22_rule(p), 1) // ['=' annotated_rhs] ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -1677,9 +1715,9 @@ assignment_rule(Parser *p) void *b; void *tc; if ( - (a = _loop1_22_rule(p)) // ((star_targets '='))+ + (a = _loop1_23_rule(p)) // ((star_targets '='))+ && - (b = _tmp_23_rule(p)) // yield_expr | star_expressions + (b = _tmp_24_rule(p)) // yield_expr | star_expressions && (tc = _PyPegen_expect_token(p, TYPE_COMMENT), 1) // TYPE_COMMENT? ) @@ -1710,7 +1748,7 @@ assignment_rule(Parser *p) && (b = augassign_rule(p)) // augassign && - (c = _tmp_24_rule(p)) // yield_expr | star_expressions + (c = _tmp_25_rule(p)) // yield_expr | star_expressions ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -1730,13 +1768,13 @@ assignment_rule(Parser *p) } p->mark = _mark; } - { // invalid_assignment - void *invalid_assignment_var; + { // invalid_ann_assignment + void *invalid_ann_assignment_var; if ( - (invalid_assignment_var = invalid_assignment_rule(p)) // invalid_assignment + (invalid_ann_assignment_var = invalid_ann_assignment_rule(p)) // invalid_ann_assignment ) { - _res = invalid_assignment_var; + _res = invalid_ann_assignment_var; goto done; } p->mark = _mark; @@ -1991,7 +2029,7 @@ global_stmt_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 508)) // token='global' && - (a = _gather_25_rule(p)) // ','.NAME+ + (a = _gather_26_rule(p)) // ','.NAME+ ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -2039,7 +2077,7 @@ nonlocal_stmt_rule(Parser *p) if ( (_keyword = _PyPegen_expect_token(p, 509)) // token='nonlocal' && - (a = _gather_27_rule(p)) // ','.NAME+ + (a = _gather_28_rule(p)) // ','.NAME+ ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -2135,7 +2173,7 @@ assert_stmt_rule(Parser *p) && (a = expression_rule(p)) // expression && - (b = _tmp_29_rule(p), 1) // [',' expression] + (b = _tmp_30_rule(p), 1) // [',' expression] ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -2320,7 +2358,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 && @@ -2354,7 +2392,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' && @@ -2460,7 +2498,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; @@ -2492,7 +2530,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 ); @@ -2521,7 +2559,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; @@ -2553,7 +2591,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 ); @@ -3071,7 +3109,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) // ','? && @@ -3108,7 +3146,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=':' && @@ -3151,7 +3189,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) // ','? && @@ -3191,7 +3229,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=':' && @@ -3237,7 +3275,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 ); @@ -3319,7 +3357,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? && @@ -3376,7 +3414,7 @@ except_block_rule(Parser *p) && (e = expression_rule(p)) // expression && - (t = _tmp_48_rule(p), 1) // ['as' target] + (t = _tmp_49_rule(p), 1) // ['as' target] && (_literal = _PyPegen_expect_token(p, 11)) // token=':' && @@ -3543,7 +3581,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); @@ -3674,7 +3712,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=':' && @@ -3724,7 +3762,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=':' && @@ -3775,7 +3813,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; @@ -3872,9 +3910,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? ) @@ -3895,7 +3933,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? ) @@ -3914,9 +3952,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? ) @@ -3934,7 +3972,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? ) @@ -3982,7 +4020,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='/' && @@ -4002,7 +4040,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='/' && @@ -4040,9 +4078,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='/' && @@ -4063,9 +4101,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='/' && @@ -4109,7 +4147,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? ) @@ -4133,7 +4171,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? ) @@ -4513,7 +4551,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; @@ -4601,7 +4639,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=':' && @@ -4707,7 +4745,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) // ','? ) @@ -4754,7 +4792,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) // ','? ) @@ -4894,7 +4932,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) // ','? ) @@ -5108,7 +5146,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) // ','? ) @@ -5330,9 +5368,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? ) @@ -5353,7 +5391,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? ) @@ -5372,9 +5410,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? ) @@ -5392,7 +5430,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? ) @@ -5442,7 +5480,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='/' && @@ -5462,7 +5500,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='/' && @@ -5500,9 +5538,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='/' && @@ -5523,9 +5561,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='/' && @@ -5569,7 +5607,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? ) @@ -5593,7 +5631,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? ) @@ -5899,7 +5937,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); @@ -5961,7 +5999,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); @@ -6083,7 +6121,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); @@ -6295,10 +6333,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 ) @@ -7740,7 +7778,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) // ','? ) @@ -7796,7 +7834,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); @@ -7984,40 +8022,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; @@ -8064,7 +8102,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 ); @@ -8222,7 +8260,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=')' ) @@ -8265,7 +8303,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=')' ) @@ -8584,7 +8622,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) // ','? ) @@ -8666,12 +8704,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; @@ -8710,7 +8748,7 @@ for_if_clause_rule(Parser *p) && (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 ) ); @@ -8737,7 +8775,7 @@ for_if_clause_rule(Parser *p) && (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 ); @@ -8903,7 +8941,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); @@ -8952,7 +8990,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); @@ -8994,11 +9032,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 ); @@ -9011,23 +9049,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; @@ -9292,7 +9330,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) // ','? ) @@ -9333,7 +9371,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) // ','? ) @@ -9354,8 +9392,8 @@ star_targets_seq_rule(Parser *p) // star_target: // | '*' (!'*' star_target) -// | t_primary '.' NAME !t_lookahead -// | t_primary '[' slices ']' !t_lookahead +// | t_primary '.' NAME &star_target_end +// | t_primary '[' slices ']' &star_target_end // | star_atom static expr_ty star_target_rule(Parser *p) @@ -9381,7 +9419,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); @@ -9401,7 +9439,7 @@ star_target_rule(Parser *p) } p->mark = _mark; } - { // t_primary '.' NAME !t_lookahead + { // t_primary '.' NAME &star_target_end Token * _literal; expr_ty a; expr_ty b; @@ -9412,7 +9450,7 @@ star_target_rule(Parser *p) && (b = _PyPegen_name_token(p)) // NAME && - _PyPegen_lookahead(0, t_lookahead_rule, p) + _PyPegen_lookahead(1, star_target_end_rule, p) ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -9432,7 +9470,7 @@ star_target_rule(Parser *p) } p->mark = _mark; } - { // t_primary '[' slices ']' !t_lookahead + { // t_primary '[' slices ']' &star_target_end Token * _literal; Token * _literal_1; expr_ty a; @@ -9446,7 +9484,7 @@ star_target_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' && - _PyPegen_lookahead(0, t_lookahead_rule, p) + _PyPegen_lookahead(1, star_target_end_rule, p) ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -9484,7 +9522,7 @@ star_target_rule(Parser *p) } // star_atom: -// | NAME +// | NAME &star_target_end // | '(' star_target ')' // | '(' star_targets_seq? ')' // | '[' star_targets_seq? ']' @@ -9504,10 +9542,12 @@ star_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 + { // NAME &star_target_end expr_ty a; if ( (a = _PyPegen_name_token(p)) // NAME + && + _PyPegen_lookahead(1, star_target_end_rule, p) ) { _res = _PyPegen_set_expr_context ( p , a , Store ); @@ -9603,6 +9643,75 @@ star_atom_rule(Parser *p) return _res; } +// star_target_end: ')' | ']' | ',' | '=' | 'in' +static void * +star_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, 22)) // token='=' + ) + { + _res = _literal; + goto done; + } + p->mark = _mark; + } + { // 'in' + Token * _keyword; + if ( + (_keyword = _PyPegen_expect_token(p, 518)) // token='in' + ) + { + _res = _keyword; + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + // inside_paren_ann_assign_target: // | ann_assign_subscript_attribute_target // | NAME @@ -9770,7 +9879,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) // ','? ) @@ -10110,7 +10219,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) // ','? ) @@ -10129,10 +10238,7 @@ targets_rule(Parser *p) return _res; } -// target: -// | t_primary '.' NAME !t_lookahead -// | t_primary '[' slices ']' !t_lookahead -// | t_atom +// target: t_primary '.' NAME &target_end | t_primary '[' slices ']' &target_end | t_atom static expr_ty target_rule(Parser *p) { @@ -10151,7 +10257,7 @@ 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 !t_lookahead + { // t_primary '.' NAME &target_end Token * _literal; expr_ty a; expr_ty b; @@ -10162,7 +10268,7 @@ target_rule(Parser *p) && (b = _PyPegen_name_token(p)) // NAME && - _PyPegen_lookahead(0, t_lookahead_rule, p) + _PyPegen_lookahead(1, target_end_rule, p) ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -10182,7 +10288,7 @@ target_rule(Parser *p) } p->mark = _mark; } - { // t_primary '[' slices ']' !t_lookahead + { // t_primary '[' slices ']' &target_end Token * _literal; Token * _literal_1; expr_ty a; @@ -10196,7 +10302,7 @@ target_rule(Parser *p) && (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' && - _PyPegen_lookahead(0, t_lookahead_rule, p) + _PyPegen_lookahead(1, target_end_rule, p) ) { Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); @@ -10476,7 +10582,7 @@ t_lookahead_rule(Parser *p) return _res; } -// t_atom: NAME | '(' target ')' | '(' targets? ')' | '[' targets? ']' +// t_atom: NAME &target_end | '(' target ')' | '(' targets? ')' | '[' targets? ']' static expr_ty t_atom_rule(Parser *p) { @@ -10493,10 +10599,12 @@ 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 + { // NAME &target_end expr_ty a; if ( (a = _PyPegen_name_token(p)) // NAME + && + _PyPegen_lookahead(1, target_end_rule, p) ) { _res = _PyPegen_set_expr_context ( p , a , Store ); @@ -10592,6 +10700,75 @@ t_atom_rule(Parser *p) return _res; } +// target_end: ')' | ']' | ',' | augassign | ':' +static void * +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; + } + { // augassign + AugOperator* augassign_var; + if ( + (augassign_var = augassign_rule(p)) // augassign + ) + { + _res = augassign_var; + goto done; + } + p->mark = _mark; + } + { // ':' + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 11)) // token=':' + ) + { + _res = _literal; + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + // incorrect_arguments: // | args ',' '*' // | expression for_if_clauses ',' [args | expression for_if_clauses] @@ -10638,7 +10815,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 ( "Generator expression must be parenthesized" ); @@ -10694,7 +10871,7 @@ invalid_kwarg_rule(Parser *p) (_literal = _PyPegen_expect_token(p, 22)) // token='=' ) { - _res = RAISE_SYNTAX_ERROR ( "expression cannot contain assignment, perhaps you meant \"==\"?" ); + _res = RAISE_SYNTAX_ERROR_NO_COL_OFFSET ( "expression cannot contain assignment, perhaps you meant \"==\"?" ); if (_res == NULL && PyErr_Occurred()) { p->error_indicator = 1; return NULL; @@ -10743,13 +10920,12 @@ invalid_named_expression_rule(Parser *p) return _res; } -// invalid_assignment: +// invalid_ann_assignment: // | list ':' // | tuple ':' // | expression ':' expression ['=' annotated_rhs] -// | expression ('=' | augassign) (yield_expr | star_expressions) static void * -invalid_assignment_rule(Parser *p) +invalid_ann_assignment_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -10805,7 +10981,7 @@ invalid_assignment_rule(Parser *p) && (expression_var_1 = expression_rule(p)) // expression && - (_opt_var = _tmp_126_rule(p), 1) // ['=' annotated_rhs] + (_opt_var = _tmp_127_rule(p), 1) // ['=' annotated_rhs] ) { _res = RAISE_SYNTAX_ERROR ( "illegal target for annotation" ); @@ -10817,27 +10993,6 @@ invalid_assignment_rule(Parser *p) } p->mark = _mark; } - { // expression ('=' | augassign) (yield_expr | star_expressions) - void *_tmp_127_var; - void *_tmp_128_var; - expr_ty a; - if ( - (a = expression_rule(p)) // expression - && - (_tmp_127_var = _tmp_127_rule(p)) // '=' | augassign - && - (_tmp_128_var = _tmp_128_rule(p)) // yield_expr | star_expressions - ) - { - _res = RAISE_SYNTAX_ERROR_NO_COL_OFFSET ( "cannot assign to %s" , _PyPegen_get_expr_name ( a ) ); - if (_res == NULL && PyErr_Occurred()) { - p->error_indicator = 1; - return NULL; - } - goto done; - } - p->mark = _mark; - } _res = NULL; done: return _res; @@ -10885,11 +11040,11 @@ invalid_comprehension_rule(Parser *p) int _mark = p->mark; { // ('[' | '(' | '{') '*' expression for_if_clauses Token * _literal; - void *_tmp_129_var; + void *_tmp_128_var; expr_ty expression_var; asdl_seq* for_if_clauses_var; if ( - (_tmp_129_var = _tmp_129_rule(p)) // '[' | '(' | '{' + (_tmp_128_var = _tmp_128_rule(p)) // '[' | '(' | '{' && (_literal = _PyPegen_expect_token(p, 16)) // token='*' && @@ -10923,13 +11078,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_130_var; - void *_tmp_131_var; + asdl_seq * _loop0_129_var; + void *_tmp_130_var; arg_ty param_no_default_var; if ( - (_loop0_130_var = _loop0_130_rule(p)) // param_no_default* + (_loop0_129_var = _loop0_129_rule(p)) // param_no_default* && - (_tmp_131_var = _tmp_131_rule(p)) // slash_with_default | param_with_default+ + (_tmp_130_var = _tmp_130_rule(p)) // slash_with_default | param_with_default+ && (param_no_default_var = param_no_default_rule(p)) // param_no_default ) @@ -10959,11 +11114,11 @@ invalid_star_etc_rule(Parser *p) int _mark = p->mark; { // '*' (')' | ',' (')' | '**')) Token * _literal; - void *_tmp_132_var; + void *_tmp_131_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_132_var = _tmp_132_rule(p)) // ')' | ',' (')' | '**') + (_tmp_131_var = _tmp_131_rule(p)) // ')' | ',' (')' | '**') ) { _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" ); @@ -10991,11 +11146,11 @@ invalid_lambda_star_etc_rule(Parser *p) int _mark = p->mark; { // '*' (':' | ',' (':' | '**')) Token * _literal; - void *_tmp_133_var; + void *_tmp_132_var; if ( (_literal = _PyPegen_expect_token(p, 16)) // token='*' && - (_tmp_133_var = _tmp_133_rule(p)) // ':' | ',' (':' | '**') + (_tmp_132_var = _tmp_132_rule(p)) // ':' | ',' (':' | '**') ) { _res = RAISE_SYNTAX_ERROR ( "named arguments must follow bare *" ); @@ -11084,48 +11239,356 @@ invalid_del_target_rule(Parser *p) return _res; } -// _loop0_1: NEWLINE -static asdl_seq * -_loop0_1_rule(Parser *p) +// targets_with_invalid: +// | target_with_invalid !',' +// | target_with_invalid ((',' target_with_invalid))* ','? +static void * +targets_with_invalid_rule(Parser *p) { if (p->error_indicator) { return NULL; } - void *_res = NULL; + void * _res = NULL; int _mark = p->mark; - int _start_mark = p->mark; - void **_children = PyMem_Malloc(sizeof(void *)); - if (!_children) { - PyErr_Format(PyExc_MemoryError, "Parser out of memory"); - return NULL; - } - ssize_t _children_capacity = 1; - ssize_t _n = 0; - { // NEWLINE - Token * newline_var; - while ( - (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + { // target_with_invalid !',' + void *target_with_invalid_var; + if ( + (target_with_invalid_var = target_with_invalid_rule(p)) // target_with_invalid + && + _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 12) // token=',' ) { - _res = newline_var; - if (_n == _children_capacity) { - _children_capacity *= 2; - _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); - if (!_children) { - PyErr_Format(PyExc_MemoryError, "realloc None"); - return NULL; - } - } - _children[_n++] = _res; - _mark = p->mark; + _res = target_with_invalid_var; + goto done; } p->mark = _mark; } - asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); - if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_1"); - PyMem_Free(_children); - return NULL; + { // target_with_invalid ((',' target_with_invalid))* ','? + asdl_seq * _loop0_133_var; + void *_opt_var; + UNUSED(_opt_var); // Silence compiler warnings + void *target_with_invalid_var; + if ( + (target_with_invalid_var = target_with_invalid_rule(p)) // target_with_invalid + && + (_loop0_133_var = _loop0_133_rule(p)) // ((',' target_with_invalid))* + && + (_opt_var = _PyPegen_expect_token(p, 12), 1) // ','? + ) + { + _res = _PyPegen_dummy_name(p, target_with_invalid_var, _loop0_133_var, _opt_var); + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + +// target_with_invalid: +// | '*' (!'*' target_with_invalid) +// | t_primary '.' NAME &(star_target_end | target_end) +// | t_primary '[' slices ']' &(star_target_end | target_end) +// | target_atom_with_invalid +// | invalid_target +static void * +target_with_invalid_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '*' (!'*' target_with_invalid) + Token * _literal; + void *a; + if ( + (_literal = _PyPegen_expect_token(p, 16)) // token='*' + && + (a = _tmp_134_rule(p)) // !'*' target_with_invalid + ) + { + _res = _PyPegen_dummy_name(p, _literal, a); + goto done; + } + p->mark = _mark; + } + { // t_primary '.' NAME &(star_target_end | target_end) + Token * _literal; + expr_ty a; + expr_ty b; + if ( + (a = t_primary_rule(p)) // t_primary + && + (_literal = _PyPegen_expect_token(p, 23)) // token='.' + && + (b = _PyPegen_name_token(p)) // NAME + && + _PyPegen_lookahead(1, _tmp_135_rule, p) + ) + { + _res = _PyPegen_dummy_name(p, a, _literal, b); + goto done; + } + p->mark = _mark; + } + { // t_primary '[' slices ']' &(star_target_end | target_end) + Token * _literal; + Token * _literal_1; + expr_ty a; + expr_ty b; + if ( + (a = t_primary_rule(p)) // t_primary + && + (_literal = _PyPegen_expect_token(p, 9)) // token='[' + && + (b = slices_rule(p)) // slices + && + (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' + && + _PyPegen_lookahead(1, _tmp_136_rule, p) + ) + { + _res = _PyPegen_dummy_name(p, a, _literal, b, _literal_1); + goto done; + } + p->mark = _mark; + } + { // target_atom_with_invalid + void *target_atom_with_invalid_var; + if ( + (target_atom_with_invalid_var = target_atom_with_invalid_rule(p)) // target_atom_with_invalid + ) + { + _res = target_atom_with_invalid_var; + goto done; + } + p->mark = _mark; + } + { // invalid_target + void *invalid_target_var; + if ( + (invalid_target_var = invalid_target_rule(p)) // invalid_target + ) + { + _res = invalid_target_var; + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + +// target_atom_with_invalid: +// | NAME &(star_target_end | target_end) +// | '(' target_with_invalid ')' +// | '(' targets_with_invalid? ')' +// | '[' targets_with_invalid? ']' +// | invalid_target +static void * +target_atom_with_invalid_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) { + p->error_indicator = 1; + return NULL; + } + int _start_lineno = p->tokens[_mark]->lineno; + 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 &(star_target_end | target_end) + expr_ty a; + if ( + (a = _PyPegen_name_token(p)) // NAME + && + _PyPegen_lookahead(1, _tmp_137_rule, p) + ) + { + _res = _PyPegen_set_expr_context ( p , a , Store ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + return NULL; + } + goto done; + } + p->mark = _mark; + } + { // '(' target_with_invalid ')' + Token * _literal; + Token * _literal_1; + void *a; + if ( + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (a = target_with_invalid_rule(p)) // target_with_invalid + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + ) + { + _res = _PyPegen_set_expr_context ( p , a , Store ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + return NULL; + } + goto done; + } + p->mark = _mark; + } + { // '(' targets_with_invalid? ')' + Token * _literal; + Token * _literal_1; + void *a; + if ( + (_literal = _PyPegen_expect_token(p, 7)) // token='(' + && + (a = targets_with_invalid_rule(p), 1) // targets_with_invalid? + && + (_literal_1 = _PyPegen_expect_token(p, 8)) // token=')' + ) + { + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _Py_Tuple ( a , Store , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + return NULL; + } + goto done; + } + p->mark = _mark; + } + { // '[' targets_with_invalid? ']' + Token * _literal; + Token * _literal_1; + void *a; + if ( + (_literal = _PyPegen_expect_token(p, 9)) // token='[' + && + (a = targets_with_invalid_rule(p), 1) // targets_with_invalid? + && + (_literal_1 = _PyPegen_expect_token(p, 10)) // token=']' + ) + { + Token *_token = _PyPegen_get_last_nonnwhitespace_token(p); + if (_token == NULL) { + return NULL; + } + int _end_lineno = _token->end_lineno; + UNUSED(_end_lineno); // Only used by EXTRA macro + int _end_col_offset = _token->end_col_offset; + UNUSED(_end_col_offset); // Only used by EXTRA macro + _res = _Py_List ( a , Store , EXTRA ); + if (_res == NULL && PyErr_Occurred()) { + p->error_indicator = 1; + return NULL; + } + goto done; + } + p->mark = _mark; + } + { // invalid_target + void *invalid_target_var; + if ( + (invalid_target_var = invalid_target_rule(p)) // invalid_target + ) + { + _res = invalid_target_var; + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + +// invalid_target: star_expression &(star_target_end | target_end) +static void * +invalid_target_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // star_expression &(star_target_end | target_end) + expr_ty a; + if ( + (a = star_expression_rule(p)) // star_expression + && + _PyPegen_lookahead(1, _tmp_138_rule, p) + ) + { + _res = RAISE_SYNTAX_ERROR_NO_COL_OFFSET ( "cannot assign to %s" , _PyPegen_get_expr_name ( a ) ); + 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) +{ + if (p->error_indicator) { + return NULL; + } + void *_res = NULL; + int _mark = p->mark; + int _start_mark = p->mark; + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { + PyErr_Format(PyExc_MemoryError, "Parser out of memory"); + return NULL; + } + ssize_t _children_capacity = 1; + ssize_t _n = 0; + { // NEWLINE + Token * newline_var; + while ( + (newline_var = _PyPegen_expect_token(p, NEWLINE)) // token='NEWLINE' + ) + { + _res = newline_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_children) { + PyErr_Format(PyExc_MemoryError, "realloc None"); + return NULL; + } + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + } + asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); + if (!_seq) { + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_1"); + PyMem_Free(_children); + return NULL; } for (int i = 0; i < _n; i++) asdl_seq_SET(_seq, i, _children[i]); PyMem_Free(_children); @@ -11660,9 +12123,45 @@ _gather_12_rule(Parser *p) return _res; } -// _tmp_14: 'import' | 'from' +// _tmp_14: '=' | augassign static void * _tmp_14_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // '=' + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 22)) // token='=' + ) + { + _res = _literal; + goto done; + } + p->mark = _mark; + } + { // augassign + AugOperator* augassign_var; + if ( + (augassign_var = augassign_rule(p)) // augassign + ) + { + _res = augassign_var; + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + +// _tmp_15: 'import' | 'from' +static void * +_tmp_15_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -11696,9 +12195,9 @@ _tmp_14_rule(Parser *p) return _res; } -// _tmp_15: 'def' | '@' | ASYNC +// _tmp_16: 'def' | '@' | ASYNC static void * -_tmp_15_rule(Parser *p) +_tmp_16_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -11743,9 +12242,9 @@ _tmp_15_rule(Parser *p) return _res; } -// _tmp_16: 'class' | '@' +// _tmp_17: 'class' | '@' static void * -_tmp_16_rule(Parser *p) +_tmp_17_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -11779,9 +12278,9 @@ _tmp_16_rule(Parser *p) return _res; } -// _tmp_17: 'with' | ASYNC +// _tmp_18: 'with' | ASYNC static void * -_tmp_17_rule(Parser *p) +_tmp_18_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -11815,9 +12314,9 @@ _tmp_17_rule(Parser *p) return _res; } -// _tmp_18: 'for' | ASYNC +// _tmp_19: 'for' | ASYNC static void * -_tmp_18_rule(Parser *p) +_tmp_19_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -11851,9 +12350,9 @@ _tmp_18_rule(Parser *p) return _res; } -// _tmp_19: '=' annotated_rhs +// _tmp_20: '=' annotated_rhs static void * -_tmp_19_rule(Parser *p) +_tmp_20_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -11883,9 +12382,9 @@ _tmp_19_rule(Parser *p) return _res; } -// _tmp_20: '(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target +// _tmp_21: '(' inside_paren_ann_assign_target ')' | ann_assign_subscript_attribute_target static void * -_tmp_20_rule(Parser *p) +_tmp_21_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -11929,9 +12428,9 @@ _tmp_20_rule(Parser *p) return _res; } -// _tmp_21: '=' annotated_rhs +// _tmp_22: '=' annotated_rhs static void * -_tmp_21_rule(Parser *p) +_tmp_22_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -11961,9 +12460,9 @@ _tmp_21_rule(Parser *p) return _res; } -// _loop1_22: (star_targets '=') +// _loop1_23: (star_targets '=') static asdl_seq * -_loop1_22_rule(Parser *p) +_loop1_23_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -11979,12 +12478,12 @@ _loop1_22_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // (star_targets '=') - void *_tmp_134_var; + void *_tmp_139_var; while ( - (_tmp_134_var = _tmp_134_rule(p)) // star_targets '=' + (_tmp_139_var = _tmp_139_rule(p)) // star_targets '=' ) { - _res = _tmp_134_var; + _res = _tmp_139_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -12004,19 +12503,19 @@ _loop1_22_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_22"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_23"); 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_22_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_23_type, _seq); return _seq; } -// _tmp_23: yield_expr | star_expressions +// _tmp_24: yield_expr | star_expressions static void * -_tmp_23_rule(Parser *p) +_tmp_24_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12050,9 +12549,9 @@ _tmp_23_rule(Parser *p) return _res; } -// _tmp_24: yield_expr | star_expressions +// _tmp_25: yield_expr | star_expressions static void * -_tmp_24_rule(Parser *p) +_tmp_25_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12086,9 +12585,9 @@ _tmp_24_rule(Parser *p) return _res; } -// _loop0_26: ',' NAME +// _loop0_27: ',' NAME static asdl_seq * -_loop0_26_rule(Parser *p) +_loop0_27_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12133,32 +12632,32 @@ _loop0_26_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_26"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_27"); 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_26_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_27_type, _seq); return _seq; } -// _gather_25: NAME _loop0_26 +// _gather_26: NAME _loop0_27 static asdl_seq * -_gather_25_rule(Parser *p) +_gather_26_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // NAME _loop0_26 + { // NAME _loop0_27 expr_ty elem; asdl_seq * seq; if ( (elem = _PyPegen_name_token(p)) // NAME && - (seq = _loop0_26_rule(p)) // _loop0_26 + (seq = _loop0_27_rule(p)) // _loop0_27 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -12171,9 +12670,9 @@ _gather_25_rule(Parser *p) return _res; } -// _loop0_28: ',' NAME +// _loop0_29: ',' NAME static asdl_seq * -_loop0_28_rule(Parser *p) +_loop0_29_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12218,32 +12717,32 @@ _loop0_28_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_28"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_29"); 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_28_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_29_type, _seq); return _seq; } -// _gather_27: NAME _loop0_28 +// _gather_28: NAME _loop0_29 static asdl_seq * -_gather_27_rule(Parser *p) +_gather_28_rule(Parser *p) { if (p->error_indicator) { return NULL; } asdl_seq * _res = NULL; int _mark = p->mark; - { // NAME _loop0_28 + { // NAME _loop0_29 expr_ty elem; asdl_seq * seq; if ( (elem = _PyPegen_name_token(p)) // NAME && - (seq = _loop0_28_rule(p)) // _loop0_28 + (seq = _loop0_29_rule(p)) // _loop0_29 ) { _res = _PyPegen_seq_insert_in_front(p, elem, seq); @@ -12256,9 +12755,9 @@ _gather_27_rule(Parser *p) return _res; } -// _tmp_29: ',' expression +// _tmp_30: ',' expression static void * -_tmp_29_rule(Parser *p) +_tmp_30_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12288,9 +12787,9 @@ _tmp_29_rule(Parser *p) return _res; } -// _loop0_30: ('.' | '...') +// _loop0_31: ('.' | '...') static asdl_seq * -_loop0_30_rule(Parser *p) +_loop0_31_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -12306,12 +12805,12 @@ _loop0_30_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('.' | '...') - void *_tmp_135_var; + void *_tmp_140_var; while ( - (_tmp_135_var = _tmp_135_rule(p)) // '.' | '...' + (_tmp_140_var = _tmp_140_rule(p)) // '.' | '...' ) { - _res = _tmp_135_var; + _res = _tmp_140_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -12327,19 +12826,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; @@ -12355,12 +12854,12 @@ _loop1_31_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('.' | '...') - void *_tmp_136_var; + void *_tmp_141_var; while ( - (_tmp_136_var = _tmp_136_rule(p)) // '.' | '...' + (_tmp_141_var = _tmp_141_rule(p)) // '.' | '...' ) { - _res = _tmp_136_var; + _res = _tmp_141_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -12380,19 +12879,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; @@ -12437,32 +12936,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); @@ -12475,9 +12974,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; @@ -12507,9 +13006,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; @@ -12554,32 +13053,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); @@ -12592,9 +13091,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; @@ -12624,9 +13123,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; @@ -12671,32 +13170,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); @@ -12709,9 +13208,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; @@ -12756,32 +13255,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); @@ -12794,9 +13293,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; @@ -12841,32 +13340,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); @@ -12879,9 +13378,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; @@ -12926,32 +13425,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); @@ -12964,9 +13463,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; @@ -12996,9 +13495,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; @@ -13039,19 +13538,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' target +// _tmp_49: 'as' target static void * -_tmp_48_rule(Parser *p) +_tmp_49_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -13081,9 +13580,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; @@ -13113,9 +13612,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; @@ -13145,9 +13644,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; @@ -13177,9 +13676,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; @@ -13205,9 +13704,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; @@ -13244,19 +13743,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; @@ -13293,19 +13792,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; @@ -13342,19 +13841,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; @@ -13395,19 +13894,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; @@ -13444,19 +13943,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; @@ -13497,19 +13996,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; @@ -13550,19 +14049,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; @@ -13603,19 +14102,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; @@ -13652,19 +14151,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; @@ -13705,19 +14204,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; @@ -13754,19 +14253,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; @@ -13807,19 +14306,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; @@ -13856,19 +14355,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; @@ -13909,19 +14408,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; @@ -13937,12 +14436,12 @@ _loop1_67_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('@' named_expression NEWLINE) - void *_tmp_137_var; + void *_tmp_142_var; while ( - (_tmp_137_var = _tmp_137_rule(p)) // '@' named_expression NEWLINE + (_tmp_142_var = _tmp_142_rule(p)) // '@' named_expression NEWLINE ) { - _res = _tmp_137_var; + _res = _tmp_142_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -13962,19 +14461,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; @@ -14007,9 +14506,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; @@ -14054,32 +14553,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); @@ -14092,9 +14591,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; @@ -14110,12 +14609,12 @@ _loop1_71_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // (',' star_expression) - void *_tmp_138_var; + void *_tmp_143_var; while ( - (_tmp_138_var = _tmp_138_rule(p)) // ',' star_expression + (_tmp_143_var = _tmp_143_rule(p)) // ',' star_expression ) { - _res = _tmp_138_var; + _res = _tmp_143_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -14135,19 +14634,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; @@ -14192,32 +14691,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); @@ -14230,9 +14729,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; @@ -14248,12 +14747,12 @@ _loop1_74_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // (',' expression) - void *_tmp_139_var; + void *_tmp_144_var; while ( - (_tmp_139_var = _tmp_139_rule(p)) // ',' expression + (_tmp_144_var = _tmp_144_rule(p)) // ',' expression ) { - _res = _tmp_139_var; + _res = _tmp_144_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -14273,19 +14772,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; @@ -14322,19 +14821,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; @@ -14371,19 +14870,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; @@ -14420,19 +14919,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; @@ -14473,19 +14972,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; @@ -14522,19 +15021,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; @@ -14575,19 +15074,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; @@ -14628,19 +15127,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; @@ -14681,19 +15180,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; @@ -14730,19 +15229,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; @@ -14783,19 +15282,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; @@ -14832,19 +15331,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; @@ -14885,19 +15384,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; @@ -14934,19 +15433,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; @@ -14987,19 +15486,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; @@ -15015,12 +15514,12 @@ _loop1_89_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('or' conjunction) - void *_tmp_140_var; + void *_tmp_145_var; while ( - (_tmp_140_var = _tmp_140_rule(p)) // 'or' conjunction + (_tmp_145_var = _tmp_145_rule(p)) // 'or' conjunction ) { - _res = _tmp_140_var; + _res = _tmp_145_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -15040,19 +15539,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; @@ -15068,12 +15567,12 @@ _loop1_90_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('and' inversion) - void *_tmp_141_var; + void *_tmp_146_var; while ( - (_tmp_141_var = _tmp_141_rule(p)) // 'and' inversion + (_tmp_146_var = _tmp_146_rule(p)) // 'and' inversion ) { - _res = _tmp_141_var; + _res = _tmp_146_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -15093,19 +15592,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; @@ -15146,19 +15645,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; @@ -15185,9 +15684,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; @@ -15232,32 +15731,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); @@ -15270,9 +15769,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; @@ -15302,9 +15801,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; @@ -15349,9 +15848,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; @@ -15385,9 +15884,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; @@ -15443,9 +15942,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; @@ -15486,19 +15985,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; @@ -15531,9 +16030,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; @@ -15567,9 +16066,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; @@ -15614,32 +16113,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); @@ -15652,9 +16151,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; @@ -15695,19 +16194,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; @@ -15723,12 +16222,12 @@ _loop0_105_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('if' disjunction) - void *_tmp_142_var; + void *_tmp_147_var; while ( - (_tmp_142_var = _tmp_142_rule(p)) // 'if' disjunction + (_tmp_147_var = _tmp_147_rule(p)) // 'if' disjunction ) { - _res = _tmp_142_var; + _res = _tmp_147_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -15744,19 +16243,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; @@ -15772,12 +16271,12 @@ _loop0_106_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // ('if' disjunction) - void *_tmp_143_var; + void *_tmp_148_var; while ( - (_tmp_143_var = _tmp_143_rule(p)) // 'if' disjunction + (_tmp_148_var = _tmp_148_rule(p)) // 'if' disjunction ) { - _res = _tmp_143_var; + _res = _tmp_148_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -15793,19 +16292,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; @@ -15835,9 +16334,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; @@ -15867,9 +16366,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; @@ -15914,32 +16413,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); @@ -15952,9 +16451,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; @@ -15999,32 +16498,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); @@ -16037,9 +16536,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; @@ -16084,32 +16583,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); @@ -16122,9 +16621,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; @@ -16169,32 +16668,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); @@ -16207,9 +16706,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; @@ -16225,12 +16724,12 @@ _loop0_117_rule(Parser *p) ssize_t _children_capacity = 1; ssize_t _n = 0; { // (',' star_target) - void *_tmp_144_var; + void *_tmp_149_var; while ( - (_tmp_144_var = _tmp_144_rule(p)) // ',' star_target + (_tmp_149_var = _tmp_149_rule(p)) // ',' star_target ) { - _res = _tmp_144_var; + _res = _tmp_149_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -16246,19 +16745,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; @@ -16303,32 +16802,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); @@ -16341,9 +16840,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; @@ -16368,9 +16867,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; @@ -16415,32 +16914,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); @@ -16453,9 +16952,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; @@ -16500,32 +16999,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); @@ -16538,9 +17037,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; @@ -16577,9 +17076,9 @@ _tmp_125_rule(Parser *p) return _res; } -// _tmp_126: '=' annotated_rhs +// _tmp_127: '=' annotated_rhs static void * -_tmp_126_rule(Parser *p) +_tmp_127_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16605,19 +17104,19 @@ _tmp_126_rule(Parser *p) return _res; } -// _tmp_127: '=' | augassign +// _tmp_128: '[' | '(' | '{' static void * -_tmp_127_rule(Parser *p) +_tmp_128_rule(Parser *p) { if (p->error_indicator) { return NULL; } void * _res = NULL; int _mark = p->mark; - { // '=' + { // '[' Token * _literal; if ( - (_literal = _PyPegen_expect_token(p, 22)) // token='=' + (_literal = _PyPegen_expect_token(p, 9)) // token='[' ) { _res = _literal; @@ -16625,13 +17124,24 @@ _tmp_127_rule(Parser *p) } p->mark = _mark; } - { // augassign - AugOperator* augassign_var; + { // '(' + Token * _literal; if ( - (augassign_var = augassign_rule(p)) // augassign + (_literal = _PyPegen_expect_token(p, 7)) // token='(' ) { - _res = augassign_var; + _res = _literal; + goto done; + } + p->mark = _mark; + } + { // '{' + Token * _literal; + if ( + (_literal = _PyPegen_expect_token(p, 25)) // token='{' + ) + { + _res = _literal; goto done; } p->mark = _mark; @@ -16641,33 +17151,82 @@ _tmp_127_rule(Parser *p) return _res; } -// _tmp_128: yield_expr | star_expressions +// _loop0_129: param_no_default +static asdl_seq * +_loop0_129_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void *_res = NULL; + int _mark = p->mark; + int _start_mark = p->mark; + void **_children = PyMem_Malloc(sizeof(void *)); + if (!_children) { + PyErr_Format(PyExc_MemoryError, "Parser out of memory"); + return NULL; + } + ssize_t _children_capacity = 1; + ssize_t _n = 0; + { // param_no_default + arg_ty param_no_default_var; + while ( + (param_no_default_var = param_no_default_rule(p)) // param_no_default + ) + { + _res = param_no_default_var; + if (_n == _children_capacity) { + _children_capacity *= 2; + _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); + if (!_children) { + PyErr_Format(PyExc_MemoryError, "realloc None"); + return NULL; + } + } + _children[_n++] = _res; + _mark = p->mark; + } + p->mark = _mark; + } + asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); + if (!_seq) { + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_129"); + 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_129_type, _seq); + return _seq; +} + +// _tmp_130: slash_with_default | param_with_default+ static void * -_tmp_128_rule(Parser *p) +_tmp_130_rule(Parser *p) { if (p->error_indicator) { return NULL; } void * _res = NULL; int _mark = p->mark; - { // yield_expr - expr_ty yield_expr_var; + { // slash_with_default + SlashWithDefault* slash_with_default_var; if ( - (yield_expr_var = yield_expr_rule(p)) // yield_expr + (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default ) { - _res = yield_expr_var; + _res = slash_with_default_var; goto done; } p->mark = _mark; } - { // star_expressions - expr_ty star_expressions_var; + { // param_with_default+ + asdl_seq * _loop1_150_var; if ( - (star_expressions_var = star_expressions_rule(p)) // star_expressions + (_loop1_150_var = _loop1_150_rule(p)) // param_with_default+ ) { - _res = star_expressions_var; + _res = _loop1_150_var; goto done; } p->mark = _mark; @@ -16677,19 +17236,19 @@ _tmp_128_rule(Parser *p) return _res; } -// _tmp_129: '[' | '(' | '{' +// _tmp_131: ')' | ',' (')' | '**') static void * -_tmp_129_rule(Parser *p) +_tmp_131_rule(Parser *p) { if (p->error_indicator) { return NULL; } void * _res = NULL; int _mark = p->mark; - { // '[' + { // ')' Token * _literal; if ( - (_literal = _PyPegen_expect_token(p, 9)) // token='[' + (_literal = _PyPegen_expect_token(p, 8)) // token=')' ) { _res = _literal; @@ -16697,21 +17256,38 @@ _tmp_129_rule(Parser *p) } p->mark = _mark; } - { // '(' + { // ',' (')' | '**') Token * _literal; + void *_tmp_151_var; if ( - (_literal = _PyPegen_expect_token(p, 7)) // token='(' + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (_tmp_151_var = _tmp_151_rule(p)) // ')' | '**' ) { - _res = _literal; + _res = _PyPegen_dummy_name(p, _literal, _tmp_151_var); goto done; } p->mark = _mark; } - { // '{' + _res = NULL; + done: + return _res; +} + +// _tmp_132: ':' | ',' (':' | '**') +static void * +_tmp_132_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // ':' Token * _literal; if ( - (_literal = _PyPegen_expect_token(p, 25)) // token='{' + (_literal = _PyPegen_expect_token(p, 11)) // token=':' ) { _res = _literal; @@ -16719,14 +17295,28 @@ _tmp_129_rule(Parser *p) } p->mark = _mark; } + { // ',' (':' | '**') + Token * _literal; + void *_tmp_152_var; + if ( + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (_tmp_152_var = _tmp_152_rule(p)) // ':' | '**' + ) + { + _res = _PyPegen_dummy_name(p, _literal, _tmp_152_var); + goto done; + } + p->mark = _mark; + } _res = NULL; done: return _res; } -// _loop0_130: param_no_default +// _loop0_133: (',' target_with_invalid) static asdl_seq * -_loop0_130_rule(Parser *p) +_loop0_133_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16741,13 +17331,13 @@ _loop0_130_rule(Parser *p) } ssize_t _children_capacity = 1; ssize_t _n = 0; - { // param_no_default - arg_ty param_no_default_var; + { // (',' target_with_invalid) + void *_tmp_153_var; while ( - (param_no_default_var = param_no_default_rule(p)) // param_no_default + (_tmp_153_var = _tmp_153_rule(p)) // ',' target_with_invalid ) { - _res = param_no_default_var; + _res = _tmp_153_var; if (_n == _children_capacity) { _children_capacity *= 2; _children = PyMem_Realloc(_children, _children_capacity*sizeof(void *)); @@ -16763,43 +17353,70 @@ _loop0_130_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_130"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop0_133"); 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_130_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop0_133_type, _seq); return _seq; } -// _tmp_131: slash_with_default | param_with_default+ +// _tmp_134: !'*' target_with_invalid static void * -_tmp_131_rule(Parser *p) +_tmp_134_rule(Parser *p) { if (p->error_indicator) { return NULL; } void * _res = NULL; int _mark = p->mark; - { // slash_with_default - SlashWithDefault* slash_with_default_var; + { // !'*' target_with_invalid + void *target_with_invalid_var; if ( - (slash_with_default_var = slash_with_default_rule(p)) // slash_with_default + _PyPegen_lookahead_with_int(0, _PyPegen_expect_token, p, 16) // token='*' + && + (target_with_invalid_var = target_with_invalid_rule(p)) // target_with_invalid ) { - _res = slash_with_default_var; + _res = target_with_invalid_var; goto done; } p->mark = _mark; } - { // param_with_default+ - asdl_seq * _loop1_145_var; + _res = NULL; + done: + return _res; +} + +// _tmp_135: star_target_end | target_end +static void * +_tmp_135_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // star_target_end + void *star_target_end_var; + if ( + (star_target_end_var = star_target_end_rule(p)) // star_target_end + ) + { + _res = star_target_end_var; + goto done; + } + p->mark = _mark; + } + { // target_end + void *target_end_var; if ( - (_loop1_145_var = _loop1_145_rule(p)) // param_with_default+ + (target_end_var = target_end_rule(p)) // target_end ) { - _res = _loop1_145_var; + _res = target_end_var; goto done; } p->mark = _mark; @@ -16809,36 +17426,33 @@ _tmp_131_rule(Parser *p) return _res; } -// _tmp_132: ')' | ',' (')' | '**') +// _tmp_136: star_target_end | target_end static void * -_tmp_132_rule(Parser *p) +_tmp_136_rule(Parser *p) { if (p->error_indicator) { return NULL; } void * _res = NULL; int _mark = p->mark; - { // ')' - Token * _literal; + { // star_target_end + void *star_target_end_var; if ( - (_literal = _PyPegen_expect_token(p, 8)) // token=')' + (star_target_end_var = star_target_end_rule(p)) // star_target_end ) { - _res = _literal; + _res = star_target_end_var; goto done; } p->mark = _mark; } - { // ',' (')' | '**') - Token * _literal; - void *_tmp_146_var; + { // target_end + void *target_end_var; if ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - && - (_tmp_146_var = _tmp_146_rule(p)) // ')' | '**' + (target_end_var = target_end_rule(p)) // target_end ) { - _res = _PyPegen_dummy_name(p, _literal, _tmp_146_var); + _res = target_end_var; goto done; } p->mark = _mark; @@ -16848,36 +17462,33 @@ _tmp_132_rule(Parser *p) return _res; } -// _tmp_133: ':' | ',' (':' | '**') +// _tmp_137: star_target_end | target_end static void * -_tmp_133_rule(Parser *p) +_tmp_137_rule(Parser *p) { if (p->error_indicator) { return NULL; } void * _res = NULL; int _mark = p->mark; - { // ':' - Token * _literal; + { // star_target_end + void *star_target_end_var; if ( - (_literal = _PyPegen_expect_token(p, 11)) // token=':' + (star_target_end_var = star_target_end_rule(p)) // star_target_end ) { - _res = _literal; + _res = star_target_end_var; goto done; } p->mark = _mark; } - { // ',' (':' | '**') - Token * _literal; - void *_tmp_147_var; + { // target_end + void *target_end_var; if ( - (_literal = _PyPegen_expect_token(p, 12)) // token=',' - && - (_tmp_147_var = _tmp_147_rule(p)) // ':' | '**' + (target_end_var = target_end_rule(p)) // target_end ) { - _res = _PyPegen_dummy_name(p, _literal, _tmp_147_var); + _res = target_end_var; goto done; } p->mark = _mark; @@ -16887,9 +17498,45 @@ _tmp_133_rule(Parser *p) return _res; } -// _tmp_134: star_targets '=' +// _tmp_138: star_target_end | target_end static void * -_tmp_134_rule(Parser *p) +_tmp_138_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // star_target_end + void *star_target_end_var; + if ( + (star_target_end_var = star_target_end_rule(p)) // star_target_end + ) + { + _res = star_target_end_var; + goto done; + } + p->mark = _mark; + } + { // target_end + void *target_end_var; + if ( + (target_end_var = target_end_rule(p)) // target_end + ) + { + _res = target_end_var; + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + +// _tmp_139: star_targets '=' +static void * +_tmp_139_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16919,9 +17566,9 @@ _tmp_134_rule(Parser *p) return _res; } -// _tmp_135: '.' | '...' +// _tmp_140: '.' | '...' static void * -_tmp_135_rule(Parser *p) +_tmp_140_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16955,9 +17602,9 @@ _tmp_135_rule(Parser *p) return _res; } -// _tmp_136: '.' | '...' +// _tmp_141: '.' | '...' static void * -_tmp_136_rule(Parser *p) +_tmp_141_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -16991,9 +17638,9 @@ _tmp_136_rule(Parser *p) return _res; } -// _tmp_137: '@' named_expression NEWLINE +// _tmp_142: '@' named_expression NEWLINE static void * -_tmp_137_rule(Parser *p) +_tmp_142_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17026,9 +17673,9 @@ _tmp_137_rule(Parser *p) return _res; } -// _tmp_138: ',' star_expression +// _tmp_143: ',' star_expression static void * -_tmp_138_rule(Parser *p) +_tmp_143_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17058,9 +17705,9 @@ _tmp_138_rule(Parser *p) return _res; } -// _tmp_139: ',' expression +// _tmp_144: ',' expression static void * -_tmp_139_rule(Parser *p) +_tmp_144_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17090,9 +17737,9 @@ _tmp_139_rule(Parser *p) return _res; } -// _tmp_140: 'or' conjunction +// _tmp_145: 'or' conjunction static void * -_tmp_140_rule(Parser *p) +_tmp_145_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17122,9 +17769,9 @@ _tmp_140_rule(Parser *p) return _res; } -// _tmp_141: 'and' inversion +// _tmp_146: 'and' inversion static void * -_tmp_141_rule(Parser *p) +_tmp_146_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17154,9 +17801,9 @@ _tmp_141_rule(Parser *p) return _res; } -// _tmp_142: 'if' disjunction +// _tmp_147: 'if' disjunction static void * -_tmp_142_rule(Parser *p) +_tmp_147_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17186,9 +17833,9 @@ _tmp_142_rule(Parser *p) return _res; } -// _tmp_143: 'if' disjunction +// _tmp_148: 'if' disjunction static void * -_tmp_143_rule(Parser *p) +_tmp_148_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17218,9 +17865,9 @@ _tmp_143_rule(Parser *p) return _res; } -// _tmp_144: ',' star_target +// _tmp_149: ',' star_target static void * -_tmp_144_rule(Parser *p) +_tmp_149_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17250,9 +17897,9 @@ _tmp_144_rule(Parser *p) return _res; } -// _loop1_145: param_with_default +// _loop1_150: param_with_default static asdl_seq * -_loop1_145_rule(Parser *p) +_loop1_150_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17293,19 +17940,19 @@ _loop1_145_rule(Parser *p) } asdl_seq *_seq = _Py_asdl_seq_new(_n, p->arena); if (!_seq) { - PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_145"); + PyErr_Format(PyExc_MemoryError, "asdl_seq_new _loop1_150"); 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_145_type, _seq); + _PyPegen_insert_memo(p, _start_mark, _loop1_150_type, _seq); return _seq; } -// _tmp_146: ')' | '**' +// _tmp_151: ')' | '**' static void * -_tmp_146_rule(Parser *p) +_tmp_151_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17339,9 +17986,9 @@ _tmp_146_rule(Parser *p) return _res; } -// _tmp_147: ':' | '**' +// _tmp_152: ':' | '**' static void * -_tmp_147_rule(Parser *p) +_tmp_152_rule(Parser *p) { if (p->error_indicator) { return NULL; @@ -17375,6 +18022,34 @@ _tmp_147_rule(Parser *p) return _res; } +// _tmp_153: ',' target_with_invalid +static void * +_tmp_153_rule(Parser *p) +{ + if (p->error_indicator) { + return NULL; + } + void * _res = NULL; + int _mark = p->mark; + { // ',' target_with_invalid + Token * _literal; + void *target_with_invalid_var; + if ( + (_literal = _PyPegen_expect_token(p, 12)) // token=',' + && + (target_with_invalid_var = target_with_invalid_rule(p)) // target_with_invalid + ) + { + _res = _PyPegen_dummy_name(p, _literal, target_with_invalid_var); + goto done; + } + p->mark = _mark; + } + _res = NULL; + done: + return _res; +} + void * _PyPegen_parse(Parser *p) {