Add expression parsing improvements for COLLATE and pseudo columns

- Add Collation field to SimpleCaseExpression and SearchedCaseExpression
- Add Collation field to ScalarSubquery for subquery COLLATE support
- Handle multi-part pseudo columns (dbo.t2.$ROWGUID) correctly:
  - Set ColumnType to pseudo column type (PseudoColumnRowGuid, etc.)
  - Exclude pseudo column from MultiPartIdentifier
- Add CURRENT_DATE to ParameterlessCall types
- Parse COLLATE after CASE END and parenthesized subqueries

Enables: BaselinesCommon_ExpressionTests, ExpressionTests

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kyleconroy

ast/case_expression.go

@@ -4,6 +4,7 @@ package ast
 type SearchedCaseExpression struct {
 	WhenClauses    []*SearchedWhenClause
 	ElseExpression ScalarExpression
+	Collation      *Identifier
 }
 
 func (s *SearchedCaseExpression) node()             {}
@@ -20,6 +21,7 @@ type SimpleCaseExpression struct {
 	InputExpression ScalarExpression
 	WhenClauses     []*SimpleWhenClause
 	ElseExpression  ScalarExpression
+	Collation       *Identifier
 }
 
 func (s *SimpleCaseExpression) node()             {}

ast/nullif_coalesce.go

@@ -16,3 +16,12 @@ type CoalesceExpression struct {
 
 func (*CoalesceExpression) node()             {}
 func (*CoalesceExpression) scalarExpression() {}
+
+// ParameterlessCall represents a parameterless function call like USER, CURRENT_USER, etc.
+type ParameterlessCall struct {
+	ParameterlessCallType string
+	Collation             *Identifier
+}
+
+func (*ParameterlessCall) node()             {}
+func (*ParameterlessCall) scalarExpression() {}

ast/scalar_subquery.go

@@ -3,6 +3,7 @@ package ast
 // ScalarSubquery represents a scalar subquery expression.
 type ScalarSubquery struct {
 	QueryExpression QueryExpression
+	Collation       *Identifier
 }
 
 func (s *ScalarSubquery) node()             {}

parser/marshal.go

@@ -2298,6 +2298,17 @@ func scalarExpressionToJSON(expr ast.ScalarExpression) jsonNode {
 			node["Expressions"] = exprs
 		}
 		return node
+	case *ast.ParameterlessCall:
+		node := jsonNode{
+			"$type": "ParameterlessCall",
+		}
+		if e.ParameterlessCallType != "" {
+			node["ParameterlessCallType"] = e.ParameterlessCallType
+		}
+		if e.Collation != nil {
+			node["Collation"] = identifierToJSON(e.Collation)
+		}
+		return node
 	case *ast.IdentityFunctionCall:
 		node := jsonNode{
 			"$type": "IdentityFunctionCall",
@@ -2550,6 +2561,9 @@ func scalarExpressionToJSON(expr ast.ScalarExpression) jsonNode {
 		if e.QueryExpression != nil {
 			node["QueryExpression"] = queryExpressionToJSON(e.QueryExpression)
 		}
+		if e.Collation != nil {
+			node["Collation"] = identifierToJSON(e.Collation)
+		}
 		return node
 	case *ast.SearchedCaseExpression:
 		node := jsonNode{
@@ -2574,6 +2588,9 @@ func scalarExpressionToJSON(expr ast.ScalarExpression) jsonNode {
 		if e.ElseExpression != nil {
 			node["ElseExpression"] = scalarExpressionToJSON(e.ElseExpression)
 		}
+		if e.Collation != nil {
+			node["Collation"] = identifierToJSON(e.Collation)
+		}
 		return node
 	case *ast.SimpleCaseExpression:
 		node := jsonNode{
@@ -2601,6 +2618,9 @@ func scalarExpressionToJSON(expr ast.ScalarExpression) jsonNode {
 		if e.ElseExpression != nil {
 			node["ElseExpression"] = scalarExpressionToJSON(e.ElseExpression)
 		}
+		if e.Collation != nil {
+			node["Collation"] = identifierToJSON(e.Collation)
+		}
 		return node
 	case *ast.SourceDeclaration:
 		node := jsonNode{

parser/parse_select.go

@@ -1288,6 +1288,20 @@ func (p *Parser) parsePrimaryExpression() (ast.ScalarExpression, error) {
 		if upper == "NEXT" && strings.ToUpper(p.peekTok.Literal) == "VALUE" {
 			return p.parseNextValueForExpression()
 		}
+		// Check for parameterless calls (USER, CURRENT_USER, etc.) without parentheses
+		if p.peekTok.Type != TokenLParen {
+			parameterlessType := getParameterlessCallType(upper)
+			if parameterlessType != "" {
+				p.nextToken()
+				call := &ast.ParameterlessCall{ParameterlessCallType: parameterlessType}
+				// Check for optional COLLATE clause
+				if strings.ToUpper(p.curTok.Literal) == "COLLATE" {
+					p.nextToken() // consume COLLATE
+					call.Collation = p.parseIdentifier()
+				}
+				return call, nil
+			}
+		}
 		return p.parseColumnReferenceOrFunctionCall()
 	case TokenNumber:
 		val := p.curTok.Literal
@@ -1333,7 +1347,13 @@ func (p *Parser) parsePrimaryExpression() (ast.ScalarExpression, error) {
 				return nil, fmt.Errorf("expected ), got %s", p.curTok.Literal)
 			}
 			p.nextToken()
-			return &ast.ScalarSubquery{QueryExpression: qe}, nil
+			ss := &ast.ScalarSubquery{QueryExpression: qe}
+			// Check for optional COLLATE clause
+			if strings.ToUpper(p.curTok.Literal) == "COLLATE" {
+				p.nextToken() // consume COLLATE
+				ss.Collation = p.parseIdentifier()
+			}
+			return ss, nil
 		}
 		expr, err := p.parseScalarExpression()
 		if err != nil {
@@ -1355,7 +1375,13 @@ func (p *Parser) parsePrimaryExpression() (ast.ScalarExpression, error) {
 					return nil, fmt.Errorf("expected ), got %s", p.curTok.Literal)
 				}
 				p.nextToken()
-				return &ast.ScalarSubquery{QueryExpression: qe}, nil
+				ss := &ast.ScalarSubquery{QueryExpression: qe}
+				// Check for optional COLLATE clause
+				if strings.ToUpper(p.curTok.Literal) == "COLLATE" {
+					p.nextToken() // consume COLLATE
+					ss.Collation = p.parseIdentifier()
+				}
+				return ss, nil
 			}
 		}
 		if p.curTok.Type != TokenRParen {
@@ -1374,9 +1400,22 @@ func (p *Parser) parsePrimaryExpression() (ast.ScalarExpression, error) {
 		// Multi-part identifier starting with empty parts (e.g., ..t1.c1)
 		return p.parseColumnReferenceWithLeadingDots()
 	case TokenMaster, TokenDatabase, TokenKey, TokenTable, TokenIndex,
-		TokenSchema, TokenUser, TokenView, TokenTime:
+		TokenSchema, TokenView, TokenTime:
 		// Keywords that can be used as identifiers in column/table references
 		return p.parseColumnReferenceOrFunctionCall()
+	case TokenUser:
+		// USER without parentheses is a ParameterlessCall
+		if p.peekTok.Type != TokenLParen && p.peekTok.Type != TokenDot {
+			p.nextToken()
+			call := &ast.ParameterlessCall{ParameterlessCallType: "User"}
+			// Check for optional COLLATE clause
+			if strings.ToUpper(p.curTok.Literal) == "COLLATE" {
+				p.nextToken() // consume COLLATE
+				call.Collation = p.parseIdentifier()
+			}
+			return call, nil
+		}
+		return p.parseColumnReferenceOrFunctionCall()
 	default:
 		return nil, fmt.Errorf("unexpected token in expression: %s", p.curTok.Literal)
 	}
@@ -1436,6 +1475,12 @@ func (p *Parser) parseSearchedCaseExpression() (*ast.SearchedCaseExpression, err
 	}
 	p.nextToken() // consume END
 
+	// Check for optional COLLATE clause
+	if strings.ToUpper(p.curTok.Literal) == "COLLATE" {
+		p.nextToken() // consume COLLATE
+		expr.Collation = p.parseIdentifier()
+	}
+
 	return expr, nil
 }
 
@@ -1488,6 +1533,12 @@ func (p *Parser) parseSimpleCaseExpression() (*ast.SimpleCaseExpression, error)
 	}
 	p.nextToken() // consume END
 
+	// Check for optional COLLATE clause
+	if strings.ToUpper(p.curTok.Literal) == "COLLATE" {
+		p.nextToken() // consume COLLATE
+		expr.Collation = p.parseIdentifier()
+	}
+
 	return expr, nil
 }
 
@@ -1842,6 +1893,12 @@ func (p *Parser) parseColumnReferenceOrFunctionCall() (ast.ScalarExpression, err
 			}
 			p.nextToken()
 			break
+		} else if pseudoType := getPseudoColumnType(upper); pseudoType != "" {
+			// Pseudo columns like $ROWGUID, $IDENTITY at end of multi-part identifier
+			// set column type and are not included in the identifier list
+			colType = pseudoType
+			p.nextToken()
+			break
 		}
 
 		id := &ast.Identifier{
@@ -6680,6 +6737,26 @@ func getPseudoColumnType(value string) string {
 	}
 }
 
+// getParameterlessCallType returns the ParameterlessCallType for keywords like USER, CURRENT_USER, etc.
+func getParameterlessCallType(value string) string {
+	switch value {
+	case "USER":
+		return "User"
+	case "CURRENT_USER":
+		return "CurrentUser"
+	case "SESSION_USER":
+		return "SessionUser"
+	case "SYSTEM_USER":
+		return "SystemUser"
+	case "CURRENT_TIMESTAMP":
+		return "CurrentTimestamp"
+	case "CURRENT_DATE":
+		return "CurrentDate"
+	default:
+		return ""
+	}
+}
+
 // parseFullTextPredicate parses CONTAINS or FREETEXT predicates
 func (p *Parser) parseFullTextPredicate(funcType string) (*ast.FullTextPredicate, error) {
 	// Convert to PascalCase: "CONTAINS" -> "Contains", "FREETEXT" -> "FreeText"

parser/testdata/BaselinesCommon_ExpressionTests/metadata.json

@@ -1 +1 @@
-{"todo": true}
+{}

parser/testdata/ExpressionTests/metadata.json

@@ -1 +1 @@
-{"todo": true}
+{}