fmt: model virtual tables instead of refusing to print them

CREATE VIRTUAL TABLE no longer falls back through the Incomplete guard:
meyer keeps a module's argument list as raw source text (the grammar
belongs to the module), so the statement can print faithfully.
ast.CreateTableStmt carries the module name and its arguments verbatim
alongside the catalog-facing columns, and prints as the declaration.
The arguments have no spans of their own, so the author's exact breaks
cannot be observed; a declaration written across lines keeps the
canonical broken form — one argument per line — and a one-liner stays
a one-liner, decided from the statement's source span.

Incomplete remains for what the node still cannot carry: column and
table constraints beyond plain NOT NULL and PRIMARY KEY, table options,
TEMP, and AS SELECT bodies.

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

@@ -56,3 +56,12 @@ CREATE TABLE   counters (id INTEGER PRIMARY KEY AUTOINCREMENT, hits INTEGER DEFA
 
 -- name: CastLabel :one
 SELECT CAST(bio AS VARYING CHARACTER(120)) FROM authors LIMIT 1;
+
+-- name: MakeSearchIndex :exec
+CREATE  VIRTUAL  TABLE IF NOT EXISTS notes_fts USING fts5(body, tag UNINDEXED, tokenize = 'porter');
+
+-- name: MakeRecipeIndex :exec
+CREATE VIRTUAL TABLE recipes_fts USING fts5(
+  name,
+  ingredients
+);

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

@@ -55,3 +55,12 @@
    ratio DECIMAL(10,5),
    note
  );
+@@ -58,7 +65,7 @@
+ SELECT CAST(bio AS VARYING CHARACTER(120)) FROM authors LIMIT 1;
+ 
+ -- name: MakeSearchIndex :exec
++CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(body, tag UNINDEXED, tokenize = 'porter');
+-CREATE  VIRTUAL  TABLE IF NOT EXISTS notes_fts USING fts5(body, tag UNINDEXED, tokenize = 'porter');
+ 
+ -- name: MakeRecipeIndex :exec
+ CREATE VIRTUAL TABLE recipes_fts USING fts5(

internal/engine/sqlite/convert.go

@@ -14,9 +14,10 @@ import (
 
 // cc converts a meyer syntax tree into sqlc's engine-independent AST. One
 // converter is used per statement; paramCount numbers the anonymous "?"
-// markers within it.
+// markers within it, and src is the source the statement was parsed from.
 type cc struct {
 	paramCount int
+	src        string
 }
 
 func todo(funcname string, n meyer.Node) *ast.TODO {
@@ -324,9 +325,19 @@ func (c *cc) convertCreateVirtualTableFTS5(n *meyer.CreateVirtualTableStmt) ast.
 	stmt := &ast.CreateTableStmt{
 		Name:        parseTableName(n.Name),
 		IfNotExists: n.IfNotExists,
-		// A virtual table's module arguments are parsed away, so the
-		// statement has no faithful rendering.
-		Incomplete: true,
+		Using:       identifier(n.Module),
+	}
+	if n.HasArgs {
+		stmt.ModuleArgs = n.Args
+		if stmt.ModuleArgs == nil {
+			stmt.ModuleArgs = []string{}
+		}
+		// The arguments carry no spans of their own, so the author's exact
+		// breaks cannot be kept; a declaration written across lines keeps
+		// the canonical broken form instead.
+		if n.Pos() >= 0 && n.End() <= len(c.src) {
+			stmt.ModuleArgsMultiline = strings.Contains(c.src[n.Pos():n.End()], "\n")
+		}
 	}
 
 	// The module arguments of a virtual table are an arbitrary token

internal/engine/sqlite/parse.go

@@ -54,7 +54,7 @@ func (p *Parser) ParseFile(r io.Reader) (*ast.File, error) {
 	// reads the "-- name:" annotation out of that range.
 	loc := 0
 	for _, raw := range parsed.Stmts {
-		converter := &cc{}
+		converter := &cc{src: src}
 		out := converter.convert(raw)
 		if _, ok := out.(*ast.TODO); !ok {
 			stmts = append(stmts, ast.Statement{

internal/sql/ast/create_table_stmt.go

@@ -9,10 +9,24 @@ type CreateTableStmt struct {
 	ReferTable  *TableName
 	Comment     string
 	Inherits    []*TableName
+	// Using names the module of a virtual table (SQLite's CREATE VIRTUAL
+	// TABLE ... USING module(...)), and ModuleArgs carries the module's
+	// argument list as written — its grammar belongs to the module, so the
+	// arguments pass through verbatim; nil means the declaration had no
+	// argument list at all. Cols still holds the columns sqlc derives from
+	// the arguments for the catalog; the statement prints as its
+	// declaration, not as those columns.
+	Using      string
+	ModuleArgs []string
+	// ModuleArgsMultiline records that the declaration was written across
+	// lines. The arguments carry no positions, so the printer cannot keep
+	// the author's exact breaks and prints the canonical broken form — one
+	// argument per line — instead.
+	ModuleArgsMultiline bool
 	// Incomplete marks a statement whose source carried syntax this node
-	// does not model — a virtual table's module arguments, column or table
-	// constraints beyond plain NOT NULL and PRIMARY KEY, table options,
-	// TEMP, or an AS SELECT body. No faithful rendering exists for it.
+	// does not model — column or table constraints beyond plain NOT NULL
+	// and PRIMARY KEY, table options, TEMP, or an AS SELECT body. No
+	// faithful rendering exists for it.
 	Incomplete bool
 }
 
@@ -24,6 +38,38 @@ func (n *CreateTableStmt) Format(buf *TrackedBuffer, d format.Dialect) {
 	if n == nil {
 		return
 	}
+	// A virtual table prints as its declaration: the module name and the
+	// argument list as written.
+	if n.Using != "" {
+		buf.WriteString("CREATE VIRTUAL TABLE ")
+		if n.IfNotExists {
+			buf.WriteString("IF NOT EXISTS ")
+		}
+		buf.astFormat(n.Name, d)
+		buf.WriteString(" USING ")
+		buf.WriteString(n.Using)
+		if n.ModuleArgs != nil {
+			buf.WriteString("(")
+			buf.Group()
+			buf.Indent()
+			if n.ModuleArgsMultiline {
+				buf.Breaker()
+			}
+			buf.Softline()
+			for i, arg := range n.ModuleArgs {
+				if i > 0 {
+					buf.WriteString(",")
+					buf.Line()
+				}
+				buf.WriteString(arg)
+			}
+			buf.EndIndent()
+			buf.Softline()
+			buf.EndGroup()
+			buf.WriteString(")")
+		}
+		return
+	}
 	// An incomplete statement cannot be printed back: part of its source
 	// was parsed away. Render nothing, which no verification accepts, so
 	// the formatter keeps the statement as written.