Rename parseIdentAnyKeyword to parseAnyKeyword, add kindClass bit set

TokenKind stays a string (its values are woven into the public AST and
error messages), so multi-kind membership checks get an internal bit
set instead: kindClass with classIdent/classKeyword bits and a
matchTokenKindIn(classIdent | classKeyword) helper, replacing the
repeated two-comparison ident-or-keyword checks. Unlike matchTokenKind,
matchTokenKindIn is a raw kind check with no keyword-to-identifier
coercion.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: git-hulk

parser/keyword.go

@@ -266,7 +266,7 @@ const (
 // Every other keyword is non-reserved and is accepted anywhere an identifier
 // is expected (see Parser.matchTokenKind). Positions where even a reserved
 // keyword is provably used as a name — after AS, after a dot in a qualified
-// name, or a lookahead-disambiguated select item — use parseIdentAnyKeyword.
+// name, or a lookahead-disambiguated select item — use parseAnyKeyword.
 //
 // Keywords that double as ClickHouse function or engine names (IF, LEFT,
 // RIGHT, ANY, MIN, MAX, TRIM, SET, JOIN...) must stay non-reserved.

parser/lexer.go

@@ -57,6 +57,31 @@ const (
 type Pos int
 type TokenKind string
 
+// kindClass is a bit set over token kinds, enabling multi-kind membership
+// checks in a single expression, e.g. matchTokenKindIn(classIdent | classKeyword).
+// TokenKind itself stays a string (its values are woven into the public AST
+// and error messages), so kinds that participate in such checks get a class
+// bit here instead.
+type kindClass uint8
+
+const (
+	classIdent kindClass = 1 << iota
+	classKeyword
+)
+
+// class maps a TokenKind to its kindClass bit; kinds without a class
+// (operators, punctuation, EOF) map to 0.
+func (k TokenKind) class() kindClass {
+	switch k {
+	case TokenKindIdent:
+		return classIdent
+	case TokenKindKeyword:
+		return classKeyword
+	default:
+		return 0
+	}
+}
+
 type Token struct {
 	Pos Pos
 	End Pos

parser/parse_system.go

@@ -1280,7 +1280,7 @@ func (p *Parser) parseGrantOption(_ Pos) (string, error) {
 	}
 	// Between WITH and OPTION the token can only be the option name, which may
 	// be a reserved keyword (e.g. `WITH GRANT OPTION`).
-	ident, err := p.parseIdentAnyKeyword()
+	ident, err := p.parseAnyKeyword()
 	if err != nil {
 		return "", err
 	}

parser/parser_column.go

@@ -152,10 +152,10 @@ func (p *Parser) parseInfix(expr Expr, precedence int) (Expr, error) {
 		// access column with dot notation
 		var rightExpr Expr
 		var err error
-		if p.lastTokenKind() == TokenKindIdent || p.lastTokenKind() == TokenKindKeyword {
+		if p.matchTokenKindIn(classIdent | classKeyword) {
 			// After a dot the token can only be a member name, so even
 			// reserved keywords are accepted (e.g. `t.from`).
-			rightExpr, err = p.parseIdentAnyKeyword()
+			rightExpr, err = p.parseAnyKeyword()
 		} else {
 			rightExpr, err = p.parseDecimal(p.Pos())
 		}
@@ -474,7 +474,7 @@ func (p *Parser) parseColumnExpr(pos Pos) (Expr, error) { //nolint:funlen
 	// terminator/alias check).
 	if p.keywordIsSelectItemIdentifier() ||
 		(p.matchTokenKind(TokenKindKeyword) && p.peekIsEndOfStatement()) {
-		return p.parseIdentAnyKeyword()
+		return p.parseAnyKeyword()
 	}
 	switch {
 	case p.matchKeyword(KeywordInterval):
@@ -681,7 +681,7 @@ func (p *Parser) parseFunctionExpr(_ Pos) (*FunctionExpr, error) {
 	// parse function name; callers gate entry (select-item modifiers match
 	// EXCEPT/APPLY/REPLACE first, INSERT INTO FUNCTION follows the FUNCTION
 	// keyword), so even reserved keywords are valid names here.
-	name, err := p.parseIdentAnyKeyword()
+	name, err := p.parseAnyKeyword()
 	if err != nil {
 		return nil, err
 	}
@@ -800,7 +800,7 @@ func (p *Parser) parseQueryParam(pos Pos) (*QueryParam, error) {
 
 	// Inside `{name:Type}` the token can only be the parameter name, so even
 	// reserved keywords are accepted (e.g. `{end:UInt32}`).
-	ident, err := p.parseIdentAnyKeyword()
+	ident, err := p.parseAnyKeyword()
 	if err != nil {
 		return nil, err
 	}
@@ -885,7 +885,7 @@ func (p *Parser) parseSelectItem() (*SelectItem, error) {
 	case p.tryConsumeKeywords(KeywordAs):
 		// `SELECT 1 AS <keyword>` works for any keyword, reserved or not:
 		// after AS the token can only be an alias name.
-		alias, err = p.parseIdentAnyKeyword()
+		alias, err = p.parseAnyKeyword()
 		if err != nil {
 			return nil, err
 		}

parser/parser_common.go

@@ -77,6 +77,13 @@ func (p *Parser) matchTokenKind(kind TokenKind) bool {
 		!reservedKeywords.Contains(strings.ToUpper(p.last().String))
 }
 
+// matchTokenKindIn reports whether the current token's kind is in the given
+// class set, e.g. matchTokenKindIn(classIdent | classKeyword). Unlike
+// matchTokenKind it is a raw kind check: no keyword-to-identifier coercion.
+func (p *Parser) matchTokenKindIn(classes kindClass) bool {
+	return p.lastTokenKind().class()&classes != 0
+}
+
 // expectTokenKind consumes the last token if it is the given kind.
 func (p *Parser) expectTokenKind(kind TokenKind) error {
 	if lastToken := p.tryConsumeTokenKind(kind); lastToken != nil {
@@ -149,14 +156,14 @@ func (p *Parser) tryParseIdent() *Ident {
 	}
 }
 
-// parseIdentAnyKeyword parses the current token as an identifier, accepting
+// parseAnyKeyword parses the current token as an identifier, accepting
 // any keyword token — reserved or not — as the name. Use it only in positions
 // where context has already proven the token is a name and not the start of a
 // clause or expression: after AS, after a dot in a qualified name, or a select
 // item the lookahead disambiguated.
-func (p *Parser) parseIdentAnyKeyword() (*Ident, error) {
+func (p *Parser) parseAnyKeyword() (*Ident, error) {
 	last := p.last()
-	if last == nil || (last.Kind != TokenKindIdent && last.Kind != TokenKindKeyword) {
+	if !p.matchTokenKindIn(classIdent | classKeyword) {
 		return nil, &ParseError{
 			Pos:      p.Pos(),
 			Got:      last,
@@ -227,7 +234,7 @@ func (p *Parser) tryParseDotIdent(_ Pos) (*Ident, error) {
 	}
 	// After a dot the token can only be a member name, so even reserved
 	// keywords are accepted (e.g. `db.from`, `t.limit`).
-	return p.parseIdentAnyKeyword()
+	return p.parseAnyKeyword()
 }
 
 func (p *Parser) tryParseDotIdentOrString(_ Pos) (*Ident, error) {
@@ -237,7 +244,7 @@ func (p *Parser) tryParseDotIdentOrString(_ Pos) (*Ident, error) {
 	// After a dot the token can only be a member name, so even reserved
 	// keywords are accepted (e.g. `db.from`).
 	if p.lastTokenKind() == TokenKindKeyword {
-		return p.parseIdentAnyKeyword()
+		return p.parseAnyKeyword()
 	}
 	return p.parseIdentOrString()
 }

parser/parser_query.go

@@ -401,7 +401,7 @@ func (p *Parser) parseTableExpr(pos Pos) (*TableExpr, error) {
 	if p.tryConsumeKeywords(KeywordAs) {
 		// After AS the token can only be an alias name, so even reserved
 		// keywords are accepted (e.g. `FROM t AS from`).
-		alias, err := p.parseIdentAnyKeyword()
+		alias, err := p.parseAnyKeyword()
 		if err != nil {
 			return nil, err
 		}
@@ -831,7 +831,7 @@ func (p *Parser) parseWindowCondition(pos Pos) (*WindowExpr, error) {
 		// canParseWindowNameInParens already disambiguated keyword tokens
 		// (e.g. `OVER (order)` vs `OVER (ORDER BY ...)`).
 		var err error
-		windowName, err = p.parseIdentAnyKeyword()
+		windowName, err = p.parseAnyKeyword()
 		if err != nil {
 			return nil, err
 		}
@@ -863,10 +863,10 @@ func (p *Parser) parseWindowCondition(pos Pos) (*WindowExpr, error) {
 }
 
 func (p *Parser) canParseWindowNameInParens() bool {
-	if p.lastTokenKind() != TokenKindIdent && p.lastTokenKind() != TokenKindKeyword {
+	if !p.matchTokenKindIn(classIdent | classKeyword) {
 		return false
 	}
-	if p.lastTokenKind() != TokenKindKeyword {
+	if !p.matchTokenKindIn(classKeyword) {
 		return true
 	}
 
@@ -899,7 +899,7 @@ func (p *Parser) parseWindowClause(pos Pos) (*WindowClause, error) {
 	for {
 		// After WINDOW (or a comma) the token can only be a window name, so
 		// even reserved keywords are accepted (e.g. `WINDOW order AS (...)`).
-		windowName, err := p.parseIdentAnyKeyword()
+		windowName, err := p.parseAnyKeyword()
 		if err != nil {
 			return nil, err
 		}

parser/parser_table.go

@@ -428,11 +428,11 @@ func (p *Parser) parseIdentOrFunction(_ Pos) (Expr, error) {
 		if p.tryConsumeKeywords(KeywordOver) {
 			var overExpr Expr
 			switch {
-			case p.matchTokenKind(TokenKindIdent), p.lastTokenKind() == TokenKindKeyword:
+			case p.matchTokenKindIn(classIdent | classKeyword):
 				// After OVER a bare token can only be a window name, so even
 				// reserved keywords are accepted (e.g. `OVER order`),
 				// mirroring the WINDOW clause definition side.
-				overExpr, err = p.parseIdentAnyKeyword()
+				overExpr, err = p.parseAnyKeyword()
 			case p.matchTokenKind(TokenKindLParen):
 				overExpr, err = p.parseWindowCondition(p.Pos())
 				if err != nil {
@@ -454,12 +454,12 @@ func (p *Parser) parseIdentOrFunction(_ Pos) (Expr, error) {
 		return funcExpr, nil
 	case p.tryConsumeTokenKind(TokenKindDot) != nil:
 		switch {
-		case p.matchTokenKind(TokenKindIdent), p.lastTokenKind() == TokenKindKeyword:
+		case p.matchTokenKindIn(classIdent | classKeyword):
 			fields := []*Ident{ident}
 			for {
 				// After a dot the token can only be a member name, so even
 				// reserved keywords are accepted (e.g. `t.from`).
-				child, err := p.parseIdentAnyKeyword()
+				child, err := p.parseAnyKeyword()
 				if err != nil {
 					return nil, err
 				}