fmt: keep authored shape for CREATE TABLE, CTEs and VALUES

Three layout regressions from the corpus sweep:

- A multi-line CREATE TABLE collapsed onto one line: its Format method
  had no layout tokens at all. It now models the column list the way
  DML lists are modeled — boundaries between (and before) the columns,
  so the author's breaks are kept and a one-liner stays a one-liner —
  and prints a space before the open parenthesis, matching how these
  statements are written.

- A multi-line CTE collapsed: the author's break after "AS (" sat
  inside the parenthesized body, where no boundary was modeled. The CTE
  body now has one, and each statement marks the boundary between its
  WITH clause and its own first keyword.

- A break before VALUES exploded the INSERT column list: the columns
  from convertColumnNames carried no source positions, so the break
  classifier had nothing to anchor the list's boundaries to and blamed
  them for the line change. The converter now stamps positions there
  and on CREATE TABLE column definitions.

Statements with a WITH clause also wrap their body in its own group, so
a break inside the WITH clause no longer forces the body apart clause
by clause. CREATE VIRTUAL TABLE now renders as nothing rather than as a
plain CREATE TABLE — its module arguments are parsed away, so no
faithful rendering exists and the verification net keeps the statement
as written. The fmt endtoend case pins all of these.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_018MTvpHqNMadH12pTtsgUq2

Author: claude

internal/endtoend/testdata/fmt/sqlite/query.sql

@@ -26,3 +26,19 @@ FROM "Events" WHERE id = ? LIMIT 1;
 -- name: CountSigils :one
 SELECT count(*) FROM authors
 WHERE id <> @at_param AND id <> :colon_param AND id <> $dollar_param;
+
+-- name: TopAuthors :many
+WITH ranked AS (
+  SELECT id, name FROM authors
+)
+SELECT * FROM ranked;
+
+-- name: AddAuthor :exec
+INSERT INTO authors (name, bio)
+VALUES (?, ?);
+
+-- name: MakeScratch :exec
+CREATE TABLE scratch (
+  id INTEGER NOT NULL,
+  label TEXT
+);

internal/endtoend/testdata/fmt/sqlite/stdout.txt

@@ -32,7 +32,7 @@
  ORDER BY name;
 
  -- name: GetEvent :one
-@@ -23,6 +27,9 @@
+@@ -23,8 +27,11 @@
  SELECT "EventName", "order"
 +FROM "Events"
 +WHERE id = ?
@@ -44,3 +44,5 @@
 +FROM authors
 -SELECT count(*) FROM authors
  WHERE id <> @at_param AND id <> :colon_param AND id <> $dollar_param;
+ 
+ -- name: TopAuthors :many

internal/engine/sqlite/convert.go

@@ -284,6 +284,7 @@ func (c *cc) convertCreateTableStmt(n *meyer.CreateTableStmt) ast.Node {
 			Colname:   identifier(def.Name),
 			IsNotNull: hasNotNullConstraint(def.Constraints),
 			TypeName:  &ast.TypeName{Name: columnTypeName(def.Type)},
+			Location:  def.Pos(),
 		})
 	}
 	return stmt
@@ -306,6 +307,7 @@ func (c *cc) convertCreateVirtualTableFTS5(n *meyer.CreateVirtualTableStmt) ast.
 	stmt := &ast.CreateTableStmt{
 		Name:        parseTableName(n.Name),
 		IfNotExists: n.IfNotExists,
+		Virtual:     true,
 	}
 
 	// The module arguments of a virtual table are an arbitrary token
@@ -437,7 +439,8 @@ func (c *cc) convertColumnNames(cols []*meyer.Ident) *ast.List {
 	for _, col := range cols {
 		name := identifier(col)
 		list.Items = append(list.Items, &ast.ResTarget{
-			Name: &name,
+			Name:     &name,
+			Location: col.Pos(),
 		})
 	}
 	return list

internal/sql/ast/common_table_expr.go

@@ -34,6 +34,10 @@ func (n *CommonTableExpr) Format(buf *TrackedBuffer, d format.Dialect) {
 	buf.WriteString(" AS (")
 	buf.Group()
 	buf.Indent()
+	// The body's boundary: a comment at the top of the CTE prints here, and
+	// an author who broke the line after the parenthesis keeps the CTE — and
+	// therefore the statement around it — broken open.
+	buf.boundary(n.Ctequery)
 	buf.Softline()
 	buf.astFormat(n.Ctequery, d)
 	buf.EndIndent()

internal/sql/ast/create_table_stmt.go

@@ -9,6 +9,10 @@ type CreateTableStmt struct {
 	ReferTable  *TableName
 	Comment     string
 	Inherits    []*TableName
+	// Virtual marks a table backed by a module (SQLite's CREATE VIRTUAL
+	// TABLE). The statement's argument list cannot be reconstructed from
+	// this node, so it has no faithful rendering.
+	Virtual bool
 }
 
 func (n *CreateTableStmt) Pos() int {
@@ -19,15 +23,32 @@ func (n *CreateTableStmt) Format(buf *TrackedBuffer, d format.Dialect) {
 	if n == nil {
 		return
 	}
+	// A virtual table cannot be printed back: its module arguments were
+	// parsed away. Render nothing, which no verification accepts, so the
+	// formatter keeps the statement as written.
+	if n.Virtual {
+		return
+	}
 	buf.WriteString("CREATE TABLE ")
 	buf.astFormat(n.Name, d)
 
-	buf.WriteString("(")
+	buf.WriteString(" (")
+	buf.Group()
+	buf.Indent()
+	if len(n.Cols) > 0 {
+		buf.boundary(n.Cols[0])
+	}
+	buf.Softline()
 	for i, col := range n.Cols {
 		if i > 0 {
-			buf.WriteString(", ")
+			buf.WriteString(",")
+			buf.boundary(col)
+			buf.Line()
 		}
 		buf.astFormat(col, d)
 	}
+	buf.EndIndent()
+	buf.Softline()
+	buf.EndGroup()
 	buf.WriteString(")")
 }

internal/sql/ast/delete_stmt.go

@@ -31,7 +31,13 @@ func (n *DeleteStmt) Format(buf *TrackedBuffer, d format.Dialect) {
 
 	if n.WithClause != nil {
 		buf.astFormat(n.WithClause, d)
+		// The boundary between the WITH clause and the statement's own
+		// first keyword; the group keeps a break inside the WITH clause
+		// from forcing the statement body apart clause by clause.
+		buf.boundary(n.Relations)
 		buf.Line()
+		buf.Group()
+		defer buf.EndGroup()
 	}
 
 	buf.WriteString("DELETE ")

internal/sql/ast/insert_stmt.go

@@ -31,7 +31,13 @@ func (n *InsertStmt) Format(buf *TrackedBuffer, d format.Dialect) {
 
 	if n.WithClause != nil {
 		buf.astFormat(n.WithClause, d)
+		// The boundary between the WITH clause and the statement's own
+		// first keyword; the group keeps a break inside the WITH clause
+		// from forcing the statement body apart clause by clause.
+		buf.boundary(n.Relation)
 		buf.Line()
+		buf.Group()
+		defer buf.EndGroup()
 	}
 
 	buf.WriteString("INSERT INTO ")

internal/sql/ast/select_stmt.go

@@ -63,7 +63,17 @@ func (n *SelectStmt) Format(buf *TrackedBuffer, d format.Dialect) {
 
 	if n.WithClause != nil {
 		buf.astFormat(n.WithClause, d)
+		// The boundary between the WITH clause and the statement's own
+		// first keyword; the group keeps a break inside the WITH clause
+		// from forcing the statement body apart clause by clause.
+		if n.Larg != nil {
+			buf.boundary(n.Larg)
+		} else {
+			buf.boundary(n.TargetList)
+		}
 		buf.Line()
+		buf.Group()
+		defer buf.EndGroup()
 	}
 
 	if n.Larg != nil && n.Rarg != nil {

internal/sql/ast/update_stmt.go

@@ -32,7 +32,13 @@ func (n *UpdateStmt) Format(buf *TrackedBuffer, d format.Dialect) {
 
 	if n.WithClause != nil {
 		buf.astFormat(n.WithClause, d)
+		// The boundary between the WITH clause and the statement's own
+		// first keyword; the group keeps a break inside the WITH clause
+		// from forcing the statement body apart clause by clause.
+		buf.boundary(n.Relations)
 		buf.Line()
+		buf.Group()
+		defer buf.EndGroup()
 	}
 
 	buf.WriteString("UPDATE ")