Strip epsilon markers and cache grammar refs on the parser

Two minor reductions in per-call work:

* Strip explicit EMPTY_RULE_ID symbols out of rule branches at grammar
  build time. The parser loop would have 'continue'd over them anyway, so
  removing them ahead of time lets the hot symbol loop drop the epsilon
  check. Pure-epsilon branches become empty branches and still match
  empty via the existing empty-children fast path.

* Cache the grammar's rules, fragment_ids, rule_names, branches_for_token,
  nullable_branches, and highest_terminal_id as direct parser instance
  fields so parse_recursive() no longer pays for a $this->grammar->...
  double hop on every call.

* Collapse the two-step node construction (new + set_children) into a
  single constructor call that takes the children array directly. This
  saves a method call per allocated node (~820k across the MySQL corpus).

End-to-end parser benchmark: ~27,500 QPS -> ~28,500 QPS (+3.5%).

Author: JanJakes

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

@@ -111,9 +111,39 @@ private function inflate( $grammar ) {
 		}
 
 		$this->inline_single_branch_fragments();
+		$this->strip_epsilon_markers();
 		$this->build_branch_selectors();
 	}
 
+	/**
+	 * Remove explicit `EMPTY_RULE_ID` markers from branches.
+	 *
+	 * The epsilon marker is a zero-width, always-matching symbol used in the
+	 * grammar to express optional productions. At parse time it would still
+	 * be walked and "continued" over for no effect, so stripping it ahead of
+	 * time removes a per-symbol branch in the hot loop.
+	 *
+	 * A pure-epsilon branch (`[EMPTY_RULE_ID]`) becomes an empty branch (`[]`)
+	 * which the parser already handles: the inner symbol loop does nothing and
+	 * the rule returns a successful empty match.
+	 */
+	private function strip_epsilon_markers() {
+		foreach ( $this->rules as $rule_id => $branches ) {
+			foreach ( $branches as $i => $branch ) {
+				if ( in_array( self::EMPTY_RULE_ID, $branch, true ) ) {
+					$this->rules[ $rule_id ][ $i ] = array_values(
+						array_filter(
+							$branch,
+							static function ( $s ) {
+								return self::EMPTY_RULE_ID !== $s;
+							}
+						)
+					);
+				}
+			}
+		}
+	}
+
 	/**
 	 * Inline single-branch fragment rules into their call sites.
 	 *

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

@@ -15,29 +15,18 @@ class WP_Parser_Node {
 	 */
 	public $rule_id;
 	public $rule_name;
-	private $children = array();
+	private $children;
 
-	public function __construct( $rule_id, $rule_name ) {
+	public function __construct( $rule_id, $rule_name, array $children = array() ) {
 		$this->rule_id   = $rule_id;
 		$this->rule_name = $rule_name;
+		$this->children  = $children;
 	}
 
 	public function append_child( $node ) {
 		$this->children[] = $node;
 	}
 
-	/**
-	 * Replace all children with the given array.
-	 *
-	 * This is used by the parser to attach a batch of children built up in a
-	 * local array while trying branches, without allocating a node per attempt.
-	 *
-	 * @param array<WP_Parser_Node|WP_Parser_Token> $children The new children.
-	 */
-	public function set_children( array $children ): void {
-		$this->children = $children;
-	}
-
 	/**
 	 * Return the children array by reference for efficient fragment inlining.
 	 *

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

@@ -14,11 +14,26 @@ class WP_Parser {
 	protected $token_count;
 	protected $position;
 
+	// Grammar data cached as instance fields so the hot path avoids an extra
+	// property hop via $this->grammar on every recursive call.
+	private $rules;
+	private $rule_names;
+	private $fragment_ids;
+	private $branches_for_token;
+	private $nullable_branches;
+	private $highest_terminal_id;
+
 	public function __construct( WP_Parser_Grammar $grammar, array $tokens ) {
-		$this->grammar     = $grammar;
-		$this->tokens      = $tokens;
-		$this->token_count = count( $tokens );
-		$this->position    = 0;
+		$this->grammar             = $grammar;
+		$this->tokens              = $tokens;
+		$this->token_count         = count( $tokens );
+		$this->position            = 0;
+		$this->rules               = $grammar->rules;
+		$this->rule_names          = $grammar->rule_names;
+		$this->fragment_ids        = $grammar->fragment_ids ?? array();
+		$this->branches_for_token  = $grammar->branches_for_token;
+		$this->nullable_branches   = $grammar->nullable_branches;
+		$this->highest_terminal_id = $grammar->highest_terminal_id;
 	}
 
 	public function parse() {
@@ -36,7 +51,6 @@ public function parse() {
 	 * round trip per consumed token.
 	 */
 	private function parse_recursive( $rule_id ) {
-		$grammar     = $this->grammar;
 		$tokens      = $this->tokens;
 		$token_count = $this->token_count;
 		$position    = $this->position;
@@ -45,21 +59,19 @@ private function parse_recursive( $rule_id ) {
 		// sets. When no entry exists for the current token but the rule is
 		// nullable, all candidate branches would match empty, so we return
 		// immediately without entering any branch.
-		$branch_selector = $grammar->branches_for_token[ $rule_id ];
-		$tid             = $position < $token_count ? $tokens[ $position ]->id : WP_Parser_Grammar::EMPTY_RULE_ID;
-		if ( isset( $branch_selector[ $tid ] ) ) {
-			$candidate_branches = $branch_selector[ $tid ];
-		} elseif ( isset( $grammar->nullable_branches[ $rule_id ] ) ) {
+		$tid = $position < $token_count ? $tokens[ $position ]->id : WP_Parser_Grammar::EMPTY_RULE_ID;
+		if ( isset( $this->branches_for_token[ $rule_id ][ $tid ] ) ) {
+			$candidate_branches = $this->branches_for_token[ $rule_id ][ $tid ];
+		} elseif ( isset( $this->nullable_branches[ $rule_id ] ) ) {
 			return true;
 		} else {
 			return false;
 		}
 
-		$highest_terminal_id = $grammar->highest_terminal_id;
-		$branches            = $grammar->rules[ $rule_id ];
-
-		$rule_name           = $grammar->rule_names[ $rule_id ];
-		$fragment_ids        = $grammar->fragment_ids;
+		$highest_terminal_id = $this->highest_terminal_id;
+		$branches            = $this->rules[ $rule_id ];
+		$fragment_ids        = $this->fragment_ids;
+		$rule_name           = $this->rule_names[ $rule_id ];
 		$is_select_statement = 'selectStatement' === $rule_name;
 		$branch_matches      = false;
 		$children            = array();
@@ -70,9 +82,6 @@ private function parse_recursive( $rule_id ) {
 			$branch_matches = true;
 			foreach ( $branch as $subrule_id ) {
 				if ( $subrule_id <= $highest_terminal_id ) {
-					if ( WP_Parser_Grammar::EMPTY_RULE_ID === $subrule_id ) {
-						continue;
-					}
 					if (
 						$this->position < $token_count
 						&& $tokens[ $this->position ]->id === $subrule_id
@@ -132,8 +141,6 @@ private function parse_recursive( $rule_id ) {
 			return true;
 		}
 
-		$node = new WP_Parser_Node( $rule_id, $rule_name );
-		$node->set_children( $children );
-		return $node;
+		return new WP_Parser_Node( $rule_id, $rule_name, $children );
 	}
 }