perf: reuse cached tokens when probing PostgreSQL typed literals

The typed-literal lookahead copied the tokenizer and scanned the token after
an identifier, then scanned it again on the normal expression path. Ordinary
column references and function names paid this cost even when the following
token could not form a type-prefixed literal.

Consume the leading name once and reuse the real tokenizer's cached next
token. Only copy tokenizer state when a following string, modifier list,
qualification or multiword type prefix warrants a type probe. Let the type
parser accept an already-consumed leading token, retaining the original
source span without rescanning it. Failed probes resume the ordinary name
or function parser with the same token boundary and quoting information.

This changes allocation-free lookahead, not grammar, AST shape or ownership.
It reduces the observed simple SELECT, JOIN and complex SELECT costs relative
to the first expression implementation. The broader grammar still has a
measurable cost relative to the earlier selective parser; performance claims
remain scoped to measured workloads and allocation modes.

Validation: the forced full C++ build passes 1,370 active tests with 37
backend-dependent skips and builds the corpus harness. All 42 focused
expression/AST tests pass under AddressSanitizer and UndefinedBehaviorSanitizer.
The direct Rust API benchmark validates complete AST parsing and canonical
SQL equivalence before timing. Benchmark sources, results and build artifacts
remain uncommitted.

Author: renecannao

include/sql_parser/expression_parser.h

@@ -181,23 +181,25 @@ class ExpressionParser {
         Token t = tok_.peek();
         if constexpr (D == Dialect::PostgreSQL) {
             if (PgTypeParser::name_token(t) && !keyword(t, "INTERVAL")) {
-                auto lookahead = tok_;
-                lookahead.skip();
-                const Token next = lookahead.peek();
+                // Consume the name once. Ordinary references use the real
+                // tokenizer's cached next token rather than rescanning a copy.
+                tok_.skip();
+                const Token next = tok_.peek();
                 // Avoid scanning a complete type for ordinary column references.
                 if (next.type == TokenType::TK_STRING || next.type == TokenType::TK_LPAREN ||
                     next.type == TokenType::TK_DOT || keyword(t, "TIMESTAMP") ||
                     keyword(t, "TIME") || keyword(t, "DOUBLE") || keyword(t, "CHARACTER") ||
                     keyword(t, "CHAR") || keyword(t, "NCHAR") || keyword(t, "NATIONAL") || keyword(t, "BIT")) {
-                    lookahead = tok_;
-                    StringRef type = PgTypeParser(lookahead).parse(false, true);
+                    auto lookahead = tok_;
+                    StringRef type = PgTypeParser(lookahead).parse(false, true, &t);
                     if (!type.empty() && lookahead.peek().type == TokenType::TK_STRING) {
                         Token literal = lookahead.next_token();
                         tok_ = lookahead;
                         AstNode* value = make_node_from_token(arena_, NodeType::NODE_LITERAL_STRING, literal);
                         return make_cast(value, type);
                     }
                 }
+                return parse_identifier_or_function(t);
             }
         }
 

include/sql_parser/pg_type_parser.h

@@ -22,10 +22,11 @@ class PgTypeParser {
             token.type == TokenType::TK_DATA || token.type == TokenType::TK_SCHEMA;
     }
 
-    StringRef parse(bool arrays = true, bool constant = false) {
-        Token first = tok_.peek();
+    StringRef parse(bool arrays = true, bool constant = false, const Token* leading = nullptr) {
+        Token first = leading ? *leading : tok_.peek();
         if (!name_token(first)) return {};
-        take();
+        if (leading) last_ = first.source;
+        else take();
         bool qualified = false;
         while (tok_.peek().type == TokenType::TK_DOT) {
             qualified = true;