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. The rules are marked in the grammar with the new @fastpath
meta, which attaches a hand-written entry hook to a rule; the
generator knows nothing about tokens or expressions.

Author: pablogsal

Grammar/python.gram

@@ -1,5 +1,8 @@
 # PEG grammar for Python
 
+@fastpath_disjunction _PyPegen_atom_fast_path
+@fastpath_inversion _PyPegen_atom_fast_path
+
 @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

@@ -241,6 +241,52 @@ _resize_tokens_array(Parser *p) {
     return 0;
 }
 
+// Fast path attached to the expression precedence chain's entry rules via
+// the @fastpath meta in the grammar. A bare NAME/NUMBER atom followed by a
+// token that cannot start or continue a binary/postfix expression is a
+// complete expression, so it is built directly instead of descending the
+// whole chain. Returns 1 if it produced a result (stored in *result), 0 to
+// fall through to the rule's alternatives. The second token is only
+// examined when the first is NAME/NUMBER: the precedence chain fills it
+// too in that case, so error reporting (which keys off p->fill) observes
+// an identical token fill state.
+int
+_PyPegen_atom_fast_path(Parser *p, void *result)
+{
+    if (p->mark == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        *(void **)result = NULL;
+        return 1;
+    }
+    Token *t = p->tokens[p->mark];
+    if (t->type != NAME && t->type != NUMBER) {
+        return 0;
+    }
+    if (p->mark + 1 == p->fill && _PyPegen_fill_token(p) < 0) {
+        p->error_indicator = 1;
+        *(void **)result = NULL;
+        return 1;
+    }
+    switch (p->tokens[p->mark + 1]->type) {
+        case COMMA:
+        case RPAR:
+        case RSQB:
+        case RBRACE:
+        case COLON:
+        case NEWLINE:
+        case SEMI:
+        case EQUAL:
+        case ENDMARKER:
+            break;
+        default:
+            return 0;
+    }
+    expr_ty res = (t->type == NAME)
+        ? _PyPegen_name_token(p) : _PyPegen_number_token(p);
+    *(void **)result = res;
+    return 1;
+}
+
 int
 _PyPegen_fill_token(Parser *p)
 {

Parser/pegen.c

@@ -159,6 +159,7 @@ 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);
+int _PyPegen_atom_fast_path(Parser *p, void *result);
 expr_ty _PyPegen_name_token(Parser *p);
 expr_ty _PyPegen_number_token(Parser *p);
 void *_PyPegen_string_token(Parser *p);

Parser/pegen.h

@@ -598,13 +598,36 @@ 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 _rule_fast_paths(self) -> dict:
+        # A "@fastpath_<rule> <function>" meta attaches a hand-written C
+        # hook to a rule, one meta per rule. The hook is called on rule
+        # entry and returns 1 if it handled the parse (storing its result),
+        # 0 to fall through to the rule's alternatives.
+        hooks = {}
+        for key, func in self.grammar.metas.items():
+            if not key.startswith("fastpath_"):
+                continue
+            rulename = key[len("fastpath_"):]
+            if rulename not in self.rules:
+                raise ValueError(f"@{key} names unknown rule {rulename!r}")
+            if not func:
+                raise ValueError(f"@{key} is missing its hook function")
+            hooks[rulename] = func
+        return hooks
+
     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()
             self.print(f"{result_type} _res = NULL;")
+            fastpath = self._rule_fast_paths().get(node.name)
+            if fastpath:
+                self.print(f"if ({fastpath}(p, &_res)) {{")
+                with self.indent():
+                    self.add_return("_res")
+                self.print("}")
             if memoize:
                 self.print(f"if (_PyPegen_is_memoized(p, {node.name}_type, &_res)) {{")
                 with self.indent():