Add support for MoneyLiteral, RealLiteral and IdentifierLiteral in procedures

- Add TokenMoney lexer support with currency symbol detection ($, £, ¥, etc.)
- Add RealLiteral for scientific notation (2e, 1.5e3, etc.)
- Add MoneyLiteral AST type and marshaling
- Add RealLiteral AST type and marshaling
- Handle scientific notation in lexer's readNumber()
- Convert single-identifier defaults to IdentifierLiteral in proc params

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

Author: kyleconroy

ast/money_literal.go

@@ -0,0 +1,10 @@
+package ast
+
+// MoneyLiteral represents a money/currency literal.
+type MoneyLiteral struct {
+	LiteralType string `json:"LiteralType,omitempty"`
+	Value       string `json:"Value,omitempty"`
+}
+
+func (*MoneyLiteral) node()             {}
+func (*MoneyLiteral) scalarExpression() {}

ast/real_literal.go

@@ -0,0 +1,10 @@
+package ast
+
+// RealLiteral represents a real (scientific notation) literal.
+type RealLiteral struct {
+	LiteralType string `json:"LiteralType,omitempty"`
+	Value       string `json:"Value,omitempty"`
+}
+
+func (*RealLiteral) node()             {}
+func (*RealLiteral) scalarExpression() {}

parser/lexer.go

@@ -18,6 +18,7 @@ const (
 	TokenString
 	TokenNationalString
 	TokenBinary
+	TokenMoney
 	TokenStar
 	TokenComma
 	TokenDot
@@ -491,8 +492,11 @@ func (l *Lexer) NextToken() Token {
 	case '"':
 		tok = l.readDoubleQuotedIdentifier()
 	default:
-		// Handle $ only if followed by a letter (for pseudo-columns like $ROWGUID)
-		if l.ch == '$' && isLetter(l.peekChar()) {
+		// Handle currency symbols for money literals
+		if l.isCurrencySymbol() {
+			tok = l.readMoneyLiteral()
+		} else if l.ch == '$' && isLetter(l.peekChar()) {
+			// Handle $ only if followed by a letter (for pseudo-columns like $ROWGUID)
 			tok = l.readIdentifier()
 		} else if isLetter(l.ch) || l.ch == '_' || l.ch == '@' || l.ch == '#' {
 			tok = l.readIdentifier()
@@ -817,6 +821,19 @@ func (l *Lexer) readNumber() Token {
 			}
 		}
 	}
+	// Handle scientific notation (e.g., 2e, 2e+5, 2E-10, 1.5e3)
+	// T-SQL allows 'e' without exponent digits (e.g., "2e" is a valid real literal)
+	if l.ch == 'e' || l.ch == 'E' {
+		l.readChar() // consume e/E
+		// Optional sign
+		if l.ch == '+' || l.ch == '-' {
+			l.readChar()
+		}
+		// Optional exponent digits (T-SQL allows just "2e" with no exponent)
+		for isDigit(l.ch) {
+			l.readChar()
+		}
+	}
 	return Token{
 		Type:    TokenNumber,
 		Literal: l.input[startPos:l.pos],
@@ -837,6 +854,72 @@ func isDigit(ch byte) bool {
 	return ch >= '0' && ch <= '9'
 }
 
+// isCurrencySymbol checks if current position is a currency symbol for money literals
+func (l *Lexer) isCurrencySymbol() bool {
+	if l.ch == '$' {
+		// Check if followed by digit, space+digit, or +/- then digit
+		next := l.peekChar()
+		if isDigit(next) || next == ' ' || next == '+' || next == '-' {
+			return true
+		}
+		return false
+	}
+	// Check for Unicode currency symbols
+	if l.ch >= 0x80 {
+		r, _ := l.peekRune()
+		// Common currency symbols: £ (U+00A3), ¤ (U+00A4), ¥ (U+00A5)
+		// and various others in the Currency Symbols block
+		if r == '£' || r == '¤' || r == '¥' || r == '৲' || r == '৳' ||
+			r == '฿' || r == '₡' || r == '₢' || r == '₣' || r == '₤' ||
+			r == '₦' || r == '₧' || r == '₨' || r == '₩' || r == '₪' || r == '₫' {
+			return true
+		}
+	}
+	return false
+}
+
+// readMoneyLiteral reads a money literal starting with a currency symbol
+func (l *Lexer) readMoneyLiteral() Token {
+	startPos := l.pos
+
+	// Read currency symbol (may be multi-byte)
+	if l.ch >= 0x80 {
+		_, size := l.peekRune()
+		for i := 0; i < size; i++ {
+			l.readChar()
+		}
+	} else {
+		l.readChar() // consume $
+	}
+
+	// Skip optional +/- after currency symbol
+	if l.ch == '+' || l.ch == '-' {
+		l.readChar()
+	}
+
+	// Skip optional whitespace after currency symbol
+	for l.ch == ' ' || l.ch == '\t' {
+		l.readChar()
+	}
+
+	// Read digits and decimal point
+	for isDigit(l.ch) {
+		l.readChar()
+	}
+	if l.ch == '.' {
+		l.readChar()
+		for isDigit(l.ch) {
+			l.readChar()
+		}
+	}
+
+	return Token{
+		Type:    TokenMoney,
+		Literal: l.input[startPos:l.pos],
+		Pos:     startPos,
+	}
+}
+
 var keywords = map[string]TokenType{
 	"SELECT":        TokenSelect,
 	"FROM":          TokenFrom,

parser/marshal.go

@@ -2034,6 +2034,28 @@ func scalarExpressionToJSON(expr ast.ScalarExpression) jsonNode {
 			node["Value"] = e.Value
 		}
 		return node
+	case *ast.RealLiteral:
+		node := jsonNode{
+			"$type": "RealLiteral",
+		}
+		if e.LiteralType != "" {
+			node["LiteralType"] = e.LiteralType
+		}
+		if e.Value != "" {
+			node["Value"] = e.Value
+		}
+		return node
+	case *ast.MoneyLiteral:
+		node := jsonNode{
+			"$type": "MoneyLiteral",
+		}
+		if e.LiteralType != "" {
+			node["LiteralType"] = e.LiteralType
+		}
+		if e.Value != "" {
+			node["Value"] = e.Value
+		}
+		return node
 	case *ast.StringLiteral:
 		node := jsonNode{
 			"$type": "StringLiteral",

parser/parse_select.go

@@ -1128,11 +1128,19 @@ func (p *Parser) parsePrimaryExpression() (ast.ScalarExpression, error) {
 	case TokenNumber:
 		val := p.curTok.Literal
 		p.nextToken()
+		// Check if it's scientific notation (real literal)
+		if strings.ContainsAny(val, "eE") {
+			return &ast.RealLiteral{LiteralType: "Real", Value: val}, nil
+		}
 		// Check if it's a decimal number
 		if strings.Contains(val, ".") {
 			return &ast.NumericLiteral{LiteralType: "Numeric", Value: val}, nil
 		}
 		return &ast.IntegerLiteral{LiteralType: "Integer", Value: val}, nil
+	case TokenMoney:
+		val := p.curTok.Literal
+		p.nextToken()
+		return &ast.MoneyLiteral{LiteralType: "Money", Value: val}, nil
 	case TokenBinary:
 		val := p.curTok.Literal
 		p.nextToken()

parser/parse_statements.go

@@ -4686,6 +4686,19 @@ func (p *Parser) parseProcedureParameters() ([]*ast.ProcedureParameter, error) {
 			if err != nil {
 				return nil, err
 			}
+			// Convert single-identifier ColumnReferenceExpression to IdentifierLiteral
+			// (e.g., for default values like false, true, null)
+			if colRef, ok := val.(*ast.ColumnReferenceExpression); ok {
+				if colRef.MultiPartIdentifier != nil && colRef.MultiPartIdentifier.Count == 1 &&
+					len(colRef.MultiPartIdentifier.Identifiers) == 1 {
+					ident := colRef.MultiPartIdentifier.Identifiers[0]
+					val = &ast.IdentifierLiteral{
+						LiteralType: "Identifier",
+						QuoteType:   ident.QuoteType,
+						Value:       ident.Value,
+					}
+				}
+			}
 			param.Value = val
 		}
 

parser/testdata/BaselinesCommon_CreateProcedureStatementTests/metadata.json

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

parser/testdata/CreateProcedureStatementTests/metadata.json

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