Fix negative literal handling in :: cast expressions

When parsing expressions like -0::Int16, ClickHouse keeps the minus
sign with the literal so it becomes CAST('-0', 'Int16'). Previously
we parsed this as negate(CAST(0, Int16)).

Changes:
- Modified parseUnaryMinus to detect -number::type pattern and keep
  them together as a signed literal
- Added Negative field to ast.Literal to track explicitly negative
  literals (needed for -0 which equals 0 numerically)
- Updated formatExprAsString to handle Negative flag and output the
  original signed representation

Author: claude

ast/ast.go

@@ -1059,6 +1059,7 @@ type Literal struct {
 	Position token.Position `json:"-"`
 	Type     LiteralType    `json:"type"`
 	Value    interface{}    `json:"value"`
+	Negative bool           `json:"negative,omitempty"` // True if literal was explicitly negative (for -0)
 }
 
 func (l *Literal) Pos() token.Position { return l.Position }

internal/explain/format.go

@@ -354,10 +354,34 @@ func UnaryOperatorToFunction(op string) string {
 func formatExprAsString(expr ast.Expression) string {
 	switch e := expr.(type) {
 	case *ast.Literal:
+		// Handle explicitly negative literals (like -0 in -0::Int16)
+		prefix := ""
+		if e.Negative {
+			prefix = "-"
+		}
 		switch e.Type {
 		case ast.LiteralInteger:
+			// For explicitly negative literals, show the absolute value with prefix
+			if e.Negative {
+				switch v := e.Value.(type) {
+				case int64:
+					if v <= 0 {
+						return fmt.Sprintf("-%d", -v)
+					}
+				case uint64:
+					return fmt.Sprintf("-%d", v)
+				}
+			}
 			return fmt.Sprintf("%d", e.Value)
 		case ast.LiteralFloat:
+			if e.Negative {
+				switch v := e.Value.(type) {
+				case float64:
+					if v <= 0 {
+						return fmt.Sprintf("%s%v", prefix, -v)
+					}
+				}
+			}
 			return fmt.Sprintf("%v", e.Value)
 		case ast.LiteralString:
 			return e.Value.(string)

internal/explain/functions.go

@@ -143,6 +143,9 @@ func explainCastExprWithAlias(sb *strings.Builder, n *ast.CastExpr, alias string
 				exprStr := formatExprAsString(lit)
 				fmt.Fprintf(sb, "%s  Literal \\'%s\\'\n", indent, exprStr)
 			}
+		} else if negatedLit := extractNegatedLiteral(n.Expr); negatedLit != "" {
+			// Handle negated literal like -0::Int16 -> CAST('-0', 'Int16')
+			fmt.Fprintf(sb, "%s  Literal \\'%s\\'\n", indent, negatedLit)
 		} else {
 			// Complex expression - use normal AST node
 			Node(sb, n.Expr, depth+2)
@@ -333,6 +336,27 @@ func exprToLiteral(expr ast.Expression) *ast.Literal {
 	return nil
 }
 
+// extractNegatedLiteral checks if expr is a negated literal (like -0, -12)
+// and returns its string representation (like "-0", "-12") for :: cast expressions.
+// Returns empty string if not a negated literal.
+func extractNegatedLiteral(expr ast.Expression) string {
+	unary, ok := expr.(*ast.UnaryExpr)
+	if !ok || unary.Op != "-" {
+		return ""
+	}
+	lit, ok := unary.Operand.(*ast.Literal)
+	if !ok {
+		return ""
+	}
+	switch lit.Type {
+	case ast.LiteralInteger:
+		return "-" + formatExprAsString(lit)
+	case ast.LiteralFloat:
+		return "-" + formatExprAsString(lit)
+	}
+	return ""
+}
+
 func explainInExpr(sb *strings.Builder, n *ast.InExpr, indent string, depth int) {
 	// IN is represented as Function in
 	fnName := "in"

parser/expression.go

@@ -835,11 +835,50 @@ func (p *Parser) parseSpecialNumber() ast.Expression {
 }
 
 func (p *Parser) parseUnaryMinus() ast.Expression {
+	pos := p.current.Pos
+	p.nextToken() // skip minus
+
+	// For negative number literals followed by ::, keep them together as a signed literal
+	// This matches ClickHouse's behavior where -0::Int16 becomes CAST('-0', 'Int16')
+	if p.currentIs(token.NUMBER) && p.peekIs(token.COLONCOLON) {
+		// Parse the number and create a "signed" literal
+		// We'll store the negative sign in the raw value
+		numVal := "-" + p.current.Value
+		lit := &ast.Literal{
+			Position: pos,
+			Type:     ast.LiteralInteger,
+			Negative: true, // Mark as explicitly negative for proper formatting
+		}
+		// Check if it's a float
+		if strings.Contains(numVal, ".") || strings.ContainsAny(numVal, "eE") {
+			f, _ := strconv.ParseFloat(numVal, 64)
+			lit.Type = ast.LiteralFloat
+			lit.Value = f
+		} else {
+			i, _ := strconv.ParseInt(numVal, 10, 64)
+			lit.Value = i
+		}
+		p.nextToken() // move past number
+		// Apply postfix operators like :: using the expression parsing loop
+		left := ast.Expression(lit)
+		for !p.currentIs(token.EOF) && LOWEST < p.precedenceForCurrent() {
+			startPos := p.current.Pos
+			left = p.parseInfixExpression(left)
+			if left == nil {
+				return nil
+			}
+			if p.current.Pos == startPos {
+				break
+			}
+		}
+		return left
+	}
+
+	// Standard unary minus handling
 	expr := &ast.UnaryExpr{
-		Position: p.current.Pos,
+		Position: pos,
 		Op:       "-",
 	}
-	p.nextToken()
 	expr.Operand = p.parseExpression(UNARY)
 	return expr
 }

parser/testdata/01852_cast_operator_3/metadata.json

@@ -1,10 +1 @@
-{
-  "explain_todo": {
-    "stmt1": true,
-    "stmt2": true,
-    "stmt3": true,
-    "stmt4": true,
-    "stmt5": true,
-    "stmt6": true
-  }
-}
+{}

parser/testdata/02277_full_sort_join_misc/metadata.json

@@ -1,6 +1,5 @@
 {
   "explain_todo": {
-    "stmt5": true,
-    "stmt7": true
+    "stmt5": true
   }
 }

parser/testdata/02560_count_digits/metadata.json

@@ -1,12 +1,5 @@
 {
   "explain_todo": {
-    "stmt12": true,
-    "stmt13": true,
-    "stmt14": true,
-    "stmt15": true,
-    "stmt16": true,
-    "stmt17": true,
-    "stmt18": true,
-    "stmt19": true
+    "stmt14": true
   }
 }

parser/testdata/02676_to_decimal_string/metadata.json

@@ -1 +1 @@
-{"explain_todo":{"stmt11":true,"stmt12":true,"stmt13":true}}
+{}

parser/testdata/02685_decimal256_various/metadata.json

@@ -2,8 +2,6 @@
   "explain_todo": {
     "stmt10": true,
     "stmt27": true,
-    "stmt28": true,
-    "stmt29": true,
     "stmt30": true,
     "stmt31": true,
     "stmt32": true,

parser/testdata/02708_dotProduct/metadata.json

@@ -12,10 +12,6 @@
     "stmt19": true,
     "stmt20": true,
     "stmt21": true,
-    "stmt27": true,
-    "stmt28": true,
-    "stmt29": true,
-    "stmt30": true,
     "stmt34": true,
     "stmt35": true,
     "stmt36": true,