gh-153568: Skip the expression precedence chain for single-token atoms

A bare name or number followed by a token that cannot extend an
expression is now built directly, avoiding a dozen rule invocations
per atom.

Author: pablogsal

Grammar/python.gram

@@ -1,5 +1,7 @@
 # PEG grammar for Python
 
+@atom_fastpath 'disjunction inversion'
+
 @trailer '''
 void *
 _PyPegen_parse(Parser *p)

Misc/NEWS.d/next/Core_and_Builtins/2026-07-11-15-00-13.gh-issue-153568.atomfp.rst

@@ -0,0 +1,2 @@
+Speed up parsing of simple expressions by recognizing single-token atoms
+without descending the full precedence rule chain.

Parser/parser.c

@@ -159,6 +159,27 @@ expr_ty _PyPegen_soft_keyword_token(Parser *p);
 expr_ty _PyPegen_fstring_middle_token(Parser* p);
 Token *_PyPegen_get_last_nonnwhitespace_token(Parser *);
 int _PyPegen_fill_token(Parser *p);
+
+// Token types that cannot start or continue a binary/postfix expression:
+// a single-token atom followed by one of these is a complete expression.
+static inline int
+_PyPegen_atom_follow_token(int type)
+{
+    switch (type) {
+        case COMMA:
+        case RPAR:
+        case RSQB:
+        case RBRACE:
+        case COLON:
+        case NEWLINE:
+        case SEMI:
+        case EQUAL:
+        case ENDMARKER:
+            return 1;
+        default:
+            return 0;
+    }
+}
 expr_ty _PyPegen_name_token(Parser *p);
 expr_ty _PyPegen_number_token(Parser *p);
 void *_PyPegen_string_token(Parser *p);

Parser/pegen.h

@@ -598,12 +598,54 @@ def _set_up_rule_memoization(self, node: Rule, result_type: str) -> None:
     def _should_memoize(self, node: Rule) -> bool:
         return "memo" in node.flags and not node.left_recursive
 
+    def _atom_fast_path_rules(self) -> frozenset:
+        # Rules marked with the @atom_fastpath meta in the grammar: pure
+        # entry points into the expression precedence chain, for which a
+        # bare NAME/NUMBER atom followed by a token that cannot start or
+        # continue a binary/postfix expression parses to exactly that atom,
+        # so a two-token fast path is emitted that builds it directly.
+        meta = self.grammar.metas.get("atom_fastpath")
+        rules = frozenset(meta.split()) if meta else frozenset()
+        for rulename in rules:
+            if rulename not in self.rules:
+                raise ValueError(
+                    f"@atom_fastpath names unknown rule {rulename!r}"
+                )
+        return rules
+
+    def _emit_atom_fast_path(self) -> None:
+        # Only look one token ahead when the current token is NAME/NUMBER:
+        # the tower fills it too in that case, so error reporting (which
+        # keys off p->fill) is unperturbed.
+        self.print("if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {")
+        with self.indent():
+            self.print("p->error_indicator = 1;")
+            self.add_return("NULL")
+        self.print("}")
+        self.print("Token *_fast_tok = p->tokens[p->mark];")
+        self.print("if (_fast_tok->type == NAME || _fast_tok->type == NUMBER) {")
+        with self.indent():
+            self.print("if (p->mark + 1 == p->fill && _PyPegen_fill_token(p) < 0) {")
+            with self.indent():
+                self.print("p->error_indicator = 1;")
+                self.add_return("NULL")
+            self.print("}")
+            self.print("if (_PyPegen_atom_follow_token(p->tokens[p->mark + 1]->type)) {")
+            with self.indent():
+                self.print("expr_ty _fast_res = (_fast_tok->type == NAME)")
+                self.print("    ? _PyPegen_name_token(p) : _PyPegen_number_token(p);")
+                self.add_return("_fast_res")
+            self.print("}")
+        self.print("}")
+
     def _handle_default_rule_body(self, node: Rule, rhs: Rhs, result_type: str) -> None:
         memoize = self._should_memoize(node)
 
         with self.indent():
             self.add_level()
             self._check_for_errors()
+            if node.name in self._atom_fast_path_rules():
+                self._emit_atom_fast_path()
             self.print(f"{result_type} _res = NULL;")
             if memoize:
                 self.print(f"if (_PyPegen_is_memoized(p, {node.name}_type, &_res)) {{")