Fix two parser generator bugs exposed by inlined error alternatives

Two groups with the same syntax but different actions or variable
names were deduplicated into a single artificial rule, because the
cache key was based on str(), which ignores actions and variable
names.  With the error alternatives inlined before the base
alternatives, the artificial rule for the group in an error
alternative (without an action) could shadow the artificial rule for
the same-looking group in a base alternative (with an action), e.g.
"class C(B): ..." lost its bases.  Use repr() in the cache key.

The action of an alternative inserted by a rule extension can return
NULL without setting an error (a conditional action which only
sometimes reports the error, e.g. in invalid_legacy_expression).  The
generated code treated this as a result of the whole rule, so the
rule failed (and the failure was memoized) instead of trying the
remaining alternatives.  Generate a NULL check which continues with
the next alternative, like a reference to an invalid_* rule returning
NULL behaves.

Also do not insert new alternatives before alternatives inserted by
preceding extensions: they raise an error rather than succeed, so
they cannot shadow the new alternative, and the order of extensions
should define their relative order ("'in' expected after for-loop
variables" must be reported before descending into the for targets).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: serhiy-storchaka

Grammar/python_errors.gram

@@ -429,14 +429,14 @@ strings (extend):
 dict (extend):
     | '{' invalid_double_starred_kvpairs '}'
 
-(for_stmt | for_if_clause) (extend):
-    | 'async'? 'for' a=star_expressions {
-        RAISE_SYNTAX_ERROR_INVALID_TARGET(FOR_TARGETS, a) }
-
 for_if_clause (extend):
     | 'async'? 'for' (bitwise_or (',' bitwise_or)* [',']) !'in' {
         RAISE_SYNTAX_ERROR("'in' expected after for-loop variables") }
 
+(for_stmt | for_if_clause) (extend):
+    | 'async'? 'for' a=star_expressions {
+        RAISE_SYNTAX_ERROR_INVALID_TARGET(FOR_TARGETS, a) }
+
 (listcomp | setcomp | genexp) (extend):
     | '[' a='**' b=expression for_if_clauses {
         RAISE_SYNTAX_ERROR_KNOWN_RANGE(a, b, "cannot use dict unpacking in list comprehension") }

Lib/test/test_peg_generator/test_pegen.py

@@ -98,6 +98,18 @@ def test_merge_grammars_repeated_meta(self) -> None:
         with self.assertRaisesRegex(GrammarError, "Repeated meta 'header'"):
             merge_grammars([first_grammar, second_grammar])
 
+    def test_same_group_with_different_actions(self) -> None:
+        # Two groups with the same syntax but different actions must
+        # not share an artificial rule.
+        grammar_source = """
+        start: a=rule_a b=rule_b NEWLINE { (a, b) }
+        rule_a: ('a' 'b' { 1 })
+        rule_b: ('a' 'b' { 2 })
+        """
+        parser_class = make_parser(grammar_source)
+        node = parse_string("a b a b\n", parser_class)
+        self.assertEqual(node[:2], (1, 2))
+
     def test_extend_rule_append_and_prepend(self) -> None:
         base_grammar_source = """
         start: rule_a NEWLINE