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

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,46 @@ 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
 
+    # Rules that are pure entry points into the expression precedence tower:
+    # when the current token is a bare NAME/NUMBER atom and the next token
+    # cannot start or continue a binary/postfix expression, the whole tower
+    # would provably consume exactly one token, so a two-token fast path is
+    # emitted that builds the atom directly.
+    ATOM_FAST_PATH_RULES = frozenset({"disjunction", "inversion"})
+
+    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)) {{")