Handle trailing comma in IN expressions as single-element tuple

When an IN expression has a trailing comma like `IN (2,)`, it should be
represented as a Function tuple with one element, not as a plain literal.

- Add TrailingComma field to InExpr to track trailing comma presence
- Add parseInList helper to detect trailing commas during parsing
- Update explainInExpr and explainInExprWithAlias to wrap single elements
  with trailing comma in Function tuple

Fixes stmt45 and stmt46 in 01756_optimize_skip_unused_shards_rewrite_in
and stmt5 in 01757_optimize_skip_unused_shards_limit.

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

Author: kyleconroy

ast/ast.go

@@ -1717,12 +1717,13 @@ func (b *BetweenExpr) expressionNode()     {}
 
 // InExpr represents an IN expression.
 type InExpr struct {
-	Position token.Position `json:"-"`
-	Expr     Expression     `json:"expr"`
-	Not      bool           `json:"not,omitempty"`
-	Global   bool           `json:"global,omitempty"`
-	List     []Expression   `json:"list,omitempty"`
-	Query    Statement      `json:"query,omitempty"`
+	Position      token.Position `json:"-"`
+	Expr          Expression     `json:"expr"`
+	Not           bool           `json:"not,omitempty"`
+	Global        bool           `json:"global,omitempty"`
+	List          []Expression   `json:"list,omitempty"`
+	Query         Statement      `json:"query,omitempty"`
+	TrailingComma bool           `json:"trailing_comma,omitempty"` // true if list had trailing comma like (2,)
 }
 
 func (i *InExpr) Pos() token.Position { return i.Position }

internal/explain/functions.go

@@ -1079,6 +1079,9 @@ func explainInExpr(sb *strings.Builder, n *ast.InExpr, indent string, depth int)
 			if lit, ok := n.List[0].(*ast.Literal); ok && lit.Type == ast.LiteralTuple {
 				// Single tuple literal gets wrapped in Function tuple, so count as 1
 				argCount++
+			} else if n.TrailingComma {
+				// Single element with trailing comma (e.g., (2,)) gets wrapped in Function tuple
+				argCount++
 			} else {
 				argCount += len(n.List)
 			}
@@ -1148,6 +1151,11 @@ func explainInExpr(sb *strings.Builder, n *ast.InExpr, indent string, depth int)
 					Node(sb, n.List[0], depth+4)
 				}
 			}
+		} else if n.TrailingComma {
+			// Single element with trailing comma (e.g., (2,)) - wrap in Function tuple
+			fmt.Fprintf(sb, "%s  Function tuple (children %d)\n", indent, 1)
+			fmt.Fprintf(sb, "%s   ExpressionList (children %d)\n", indent, 1)
+			Node(sb, n.List[0], depth+4)
 		} else {
 			// Single non-tuple element - output directly
 			Node(sb, n.List[0], depth+2)
@@ -1277,6 +1285,9 @@ func explainInExprWithAlias(sb *strings.Builder, n *ast.InExpr, alias string, in
 		if len(n.List) == 1 {
 			if lit, ok := n.List[0].(*ast.Literal); ok && lit.Type == ast.LiteralTuple {
 				argCount++
+			} else if n.TrailingComma {
+				// Single element with trailing comma (e.g., (2,)) gets wrapped in Function tuple
+				argCount++
 			} else {
 				argCount += len(n.List)
 			}
@@ -1315,6 +1326,11 @@ func explainInExprWithAlias(sb *strings.Builder, n *ast.InExpr, alias string, in
 			fmt.Fprintf(sb, "%s  Function tuple (children %d)\n", indent, 1)
 			fmt.Fprintf(sb, "%s   ExpressionList (children %d)\n", indent, 1)
 			Node(sb, n.List[0], depth+4)
+		} else if n.TrailingComma {
+			// Single element with trailing comma (e.g., (2,)) - wrap in Function tuple
+			fmt.Fprintf(sb, "%s  Function tuple (children %d)\n", indent, 1)
+			fmt.Fprintf(sb, "%s   ExpressionList (children %d)\n", indent, 1)
+			Node(sb, n.List[0], depth+4)
 		} else {
 			Node(sb, n.List[0], depth+2)
 		}

parser/expression.go

@@ -2110,7 +2110,8 @@ func (p *Parser) parseInExpression(left ast.Expression, not bool) ast.Expression
 		if p.currentIs(token.SELECT) || p.currentIs(token.WITH) {
 			expr.Query = p.parseSelectWithUnion()
 		} else {
-			expr.List = p.parseExpressionList()
+			// Parse IN list manually to detect trailing comma
+			expr.List, expr.TrailingComma = p.parseInList()
 		}
 		p.expect(token.RPAREN)
 	} else if p.currentIs(token.LBRACKET) {
@@ -2130,6 +2131,37 @@ func (p *Parser) parseInExpression(left ast.Expression, not bool) ast.Expression
 	return expr
 }
 
+// parseInList parses an expression list for IN expressions and returns
+// whether the list had a trailing comma (which indicates a single-element tuple).
+func (p *Parser) parseInList() ([]ast.Expression, bool) {
+	var exprs []ast.Expression
+	trailingComma := false
+
+	if p.currentIs(token.RPAREN) || p.currentIs(token.EOF) {
+		return exprs, false
+	}
+
+	expr := p.parseExpression(LOWEST)
+	if expr != nil {
+		exprs = append(exprs, expr)
+	}
+
+	for p.currentIs(token.COMMA) {
+		p.nextToken() // consume comma
+		// Check if this is a trailing comma (followed by RPAREN)
+		if p.currentIs(token.RPAREN) {
+			trailingComma = true
+			break
+		}
+		expr := p.parseExpression(LOWEST)
+		if expr != nil {
+			exprs = append(exprs, expr)
+		}
+	}
+
+	return exprs, trailingComma
+}
+
 func (p *Parser) parseBetweenExpression(left ast.Expression, not bool) ast.Expression {
 	expr := &ast.BetweenExpr{
 		Position: p.current.Pos,

parser/testdata/01756_optimize_skip_unused_shards_rewrite_in/metadata.json

@@ -1,6 +1 @@
-{
-  "explain_todo": {
-    "stmt45": true,
-    "stmt46": true
-  }
-}
+{}

parser/testdata/01757_optimize_skip_unused_shards_limit/metadata.json

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