Embed branch symbol sequences directly in the per-token selector

Previously the per-(rule, token) selector stored a list of branch
indexes that the parser then had to look up in $rules[$rule_id] on
every branch attempt. Store the branch symbol sequences themselves so
the hot loop can iterate candidate branches directly.

PHP arrays are copy-on-write, so sharing the same branch sequence
across selector entries for many tokens costs negligible extra memory.
The nullable_branches map shrinks to a bool marker since the parser
only uses it for existence checks.

Also cache the start rule id on the grammar so parse() skips its
array_search() across rule_names on every call.

End-to-end parser benchmark:
  Before: ~29,800 QPS (avg)   After: ~31,700 QPS (+6%).

Author: JanJakes

packages/mysql-on-sqlite/src/parser/class-wp-parser-grammar.php

@@ -34,27 +34,40 @@ class WP_Parser_Grammar {
 	 * Per-rule branch selector keyed by the next token id.
 	 *
 	 * When set, `$branches_for_token[$rule_id][$token_id]` is the ordered list
-	 * of branch indexes in `$rules[$rule_id]` that can possibly match when the
-	 * current token has the given id. Nullable branches appear in every entry.
+	 * of candidate branch symbol sequences (drawn from `$rules[$rule_id]`)
+	 * that can possibly match when the current token has the given id.
+	 * Nullable branches appear in every entry.
 	 *
 	 * If an entry does not exist for the current token, `$nullable_branches`
 	 * is consulted. If neither has an entry for this rule, the rule cannot
 	 * match and the parser returns immediately.
 	 *
-	 * @var array<int,array<int,int[]>>
+	 * @var array<int,array<int,int[][]>>
 	 */
 	public $branches_for_token = array();
 
 	/**
-	 * Per-rule list of nullable branch indexes.
+	 * Per-rule marker indicating the rule has at least one nullable branch.
 	 *
-	 * @var array<int,int[]>
+	 * @var array<int,true>
 	 */
 	public $nullable_branches = array();
 
 	public $lowest_non_terminal_id;
 	public $highest_terminal_id;
 
+	/**
+	 * Memoized rule-id lookups, keyed by rule name.
+	 *
+	 * `get_rule_id()` is a linear `array_search` over `$rule_names` and
+	 * costs a few microseconds per call on the MySQL grammar. The parser
+	 * looks up its start rule and the `selectStatement` rule on a hot path,
+	 * so the results are memoized via `get_or_cache_rule_id()`.
+	 *
+	 * @var array<string,int|false>
+	 */
+	private $cached_rule_ids = array();
+
 	public function __construct( array $rules ) {
 		$this->inflate( $rules );
 	}
@@ -67,6 +80,25 @@ public function get_rule_id( $rule_name ) {
 		return array_search( $rule_name, $this->rule_names, true );
 	}
 
+	/**
+	 * Return the rule id for a given rule name, memoizing the result.
+	 *
+	 * Equivalent to `get_rule_id()` but caches the lookup so repeated
+	 * queries for the same rule name (typically the start rule and a few
+	 * grammar-specific rules consulted on the parser hot path) avoid
+	 * the linear scan over `$rule_names`. Returns `false` for unknown
+	 * rule names, mirroring `get_rule_id()`.
+	 *
+	 * @param  string    $rule_name
+	 * @return int|false
+	 */
+	public function get_or_cache_rule_id( $rule_name ) {
+		if ( ! array_key_exists( $rule_name, $this->cached_rule_ids ) ) {
+			$this->cached_rule_ids[ $rule_name ] = $this->get_rule_id( $rule_name );
+		}
+		return $this->cached_rule_ids[ $rule_name ];
+	}
+
 	/**
 	 * Inflate the grammar to an internal representation optimized for parsing.
 	 *
@@ -316,10 +348,20 @@ private function build_branch_selectors() {
 				foreach ( $selector as $tid => $idx_list ) {
 					$merged[ $tid ] = self::merge_sorted( $idx_list, $nullable_branch_ids );
 				}
-				$selector                             = $merged;
-				$this->nullable_branches[ $rule_id ]  = $nullable_branch_ids;
+				$selector                            = $merged;
+				$this->nullable_branches[ $rule_id ] = true;
 			}
 			if ( $selector ) {
+				// Store the candidate branch sequences directly so the parser
+				// can foreach over them without an extra $branches[$idx]
+				// indirection on every branch attempt.
+				foreach ( $selector as $tid => $idx_list ) {
+					$seqs = array();
+					foreach ( $idx_list as $idx ) {
+						$seqs[] = $branches[ $idx ];
+					}
+					$selector[ $tid ] = $seqs;
+				}
 				$this->branches_for_token[ $rule_id ] = $selector;
 			}
 		}

packages/mysql-on-sqlite/src/parser/class-wp-parser.php

@@ -58,8 +58,7 @@ public function __construct( WP_Parser_Grammar $grammar, array $tokens ) {
 
 	public function parse() {
 		// @TODO: Make the starting rule lookup non-grammar-specific.
-		$query_rule_id = $this->grammar->get_rule_id( 'query' );
-		$ast           = $this->parse_recursive( $query_rule_id );
+		$ast = $this->parse_recursive( $this->grammar->get_or_cache_rule_id( 'query' ) );
 		return false === $ast ? null : $ast;
 	}
 
@@ -88,14 +87,12 @@ private function parse_recursive( $rule_id ) {
 		}
 
 		$highest_terminal_id = $this->highest_terminal_id;
-		$branches            = $this->rules[ $rule_id ];
 		$rule_name           = $this->rule_names[ $rule_id ];
 		$is_fragment         = isset( $this->fragment_ids[ $rule_id ] );
 		$is_select_statement = 'selectStatement' === $rule_name;
 		$branch_matches      = false;
 		$children            = array();
-		foreach ( $candidate_branches as $idx ) {
-			$branch         = $branches[ $idx ];
+		foreach ( $candidate_branches as $branch ) {
 			$this->position = $position;
 			$children       = array();
 			$branch_matches = true;