Apply the rest of the review: fewer allocations, less repetition

Efficiency, measured with alloc profiles over the corpus tests:

- internal/dump dominated the harness, not the parser. It rebuilt each
  node type's field layout per instance and formatted every scalar
  through fmt. The layout is cached per type and the leaves go straight
  to the builder; TestRoundTrip drops from 1.5s to 0.55s.
- regenerate-parse started and tore down a pool of oracle processes per
  script, forking a few thousand times over a run. One pool for the
  whole run takes regeneration from 19s to 2.5s, corpus byte-identical.
- parseTypeToken built a slice and joined it for every column type, when
  a type is almost always one word.
- The %fallback set and the infix operator table are Kind-indexed arrays
  rather than maps; both are consulted per token.
- Children() allocates only when a node has children, and the parser's
  named-parameter map only when there is a named parameter.

Repetition:

- parseOperators stated the precedence guard seventeen times, once per
  case, with half the operators tabled and half inline. One table, one
  guard; the operators with syntax of their own keep their cases.
- The trigger body re-implemented UPDATE, INSERT and DELETE. It shares
  their cores now, so the three real differences -- no WITH, where_opt
  instead of where_opt_ret, no DEFAULT VALUES -- are visible lines
  rather than absences.
- CreateTableStmt held Options and WithoutOpt as index-parallel slices,
  an invariant only the parser knew and only the renderer could break.
- 27 Children() methods spelled out the same append loop; writeOnConflict
  and writeOrConflict differed only in a keyword.

And the shift-then-decide rule that five comments were each re-arguing
is now stated once in the package doc.

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

Author: claude

ast/ddl.go

@@ -14,23 +14,28 @@ type CreateTableStmt struct {
 	Name        *QualifiedName     `json:"name"`
 	Columns     []*ColumnDef       `json:"columns,omitempty"`
 	Constraints []*TableConstraint `json:"constraints,omitempty"`
-	Options     []*Ident           `json:"options,omitempty"` // WITHOUT ROWID, STRICT
-	WithoutOpt  []bool             `json:"withoutOpt,omitempty"`
+	Options     []*TableOption     `json:"options,omitempty"` // WITHOUT ROWID, STRICT
 	Select      *SelectStmt        `json:"select,omitempty"`
 }
 
+// TableOption is one entry of a table_option_set. SQLite rejects an unknown
+// one from a grammar action rather than the grammar, so any name parses.
+//
+//	table_option ::= WITHOUT nm. / table_option ::= nm.
+type TableOption struct {
+	Span
+	Without bool   `json:"without,omitempty"`
+	Name    *Ident `json:"name"`
+}
+
+func (n *TableOption) Children() []Node { return nodes(n.Name) }
+
 func (*CreateTableStmt) stmtNode() {}
 func (n *CreateTableStmt) Children() []Node {
 	out := nodes(n.Name)
-	for _, c := range n.Columns {
-		out = append(out, c)
-	}
-	for _, c := range n.Constraints {
-		out = append(out, c)
-	}
-	for _, o := range n.Options {
-		out = append(out, o)
-	}
+	out = appendNodes(out, n.Columns)
+	out = appendNodes(out, n.Constraints)
+	out = appendNodes(out, n.Options)
 	return append(out, nodes(n.Select)...)
 }
 
@@ -46,9 +51,7 @@ type ColumnDef struct {
 
 func (n *ColumnDef) Children() []Node {
 	out := nodes(n.Name, n.Type)
-	for _, c := range n.Constraints {
-		out = append(out, c)
-	}
+	out = appendNodes(out, n.Constraints)
 	return out
 }
 
@@ -132,13 +135,9 @@ type TableConstraint struct {
 
 func (n *TableConstraint) Children() []Node {
 	out := nodes(n.Name)
-	for _, c := range n.Columns {
-		out = append(out, c)
-	}
+	out = appendNodes(out, n.Columns)
 	out = append(out, nodes(n.Expr)...)
-	for _, c := range n.FKColumns {
-		out = append(out, c)
-	}
+	out = appendNodes(out, n.FKColumns)
 	return append(out, nodes(n.References, n.Deferrable)...)
 }
 
@@ -179,12 +178,8 @@ type ForeignKeyClause struct {
 
 func (n *ForeignKeyClause) Children() []Node {
 	out := nodes(n.Table)
-	for _, c := range n.Columns {
-		out = append(out, c)
-	}
-	for _, a := range n.Args {
-		out = append(out, a)
-	}
+	out = appendNodes(out, n.Columns)
+	out = appendNodes(out, n.Args)
 	return out
 }
 
@@ -228,9 +223,7 @@ type CreateIndexStmt struct {
 func (*CreateIndexStmt) stmtNode() {}
 func (n *CreateIndexStmt) Children() []Node {
 	out := nodes(n.Name, n.Table)
-	for _, c := range n.Columns {
-		out = append(out, c)
-	}
+	out = appendNodes(out, n.Columns)
 	return append(out, nodes(n.Where)...)
 }
 
@@ -249,9 +242,7 @@ type CreateViewStmt struct {
 func (*CreateViewStmt) stmtNode() {}
 func (n *CreateViewStmt) Children() []Node {
 	out := nodes(n.Name)
-	for _, c := range n.Columns {
-		out = append(out, c)
-	}
+	out = appendNodes(out, n.Columns)
 	return append(out, nodes(n.Select)...)
 }
 
@@ -287,13 +278,9 @@ type CreateTriggerStmt struct {
 func (*CreateTriggerStmt) stmtNode() {}
 func (n *CreateTriggerStmt) Children() []Node {
 	out := nodes(n.Name)
-	for _, u := range n.UpdateOf {
-		out = append(out, u)
-	}
+	out = appendNodes(out, n.UpdateOf)
 	out = append(out, nodes(n.Table, n.When)...)
-	for _, s := range n.Body {
-		out = append(out, s)
-	}
+	out = appendNodes(out, n.Body)
 	return out
 }
 

ast/dml.go

@@ -41,16 +41,10 @@ type InsertStmt struct {
 func (*InsertStmt) stmtNode() {}
 func (n *InsertStmt) Children() []Node {
 	out := nodes(n.With, n.Table, n.Alias)
-	for _, c := range n.Columns {
-		out = append(out, c)
-	}
+	out = appendNodes(out, n.Columns)
 	out = append(out, nodes(n.Select)...)
-	for _, u := range n.Upserts {
-		out = append(out, u)
-	}
-	for _, r := range n.Returning {
-		out = append(out, r)
-	}
+	out = appendNodes(out, n.Upserts)
+	out = appendNodes(out, n.Returning)
 	return out
 }
 
@@ -69,13 +63,9 @@ type Upsert struct {
 
 func (n *Upsert) Children() []Node {
 	var out []Node
-	for _, t := range n.Target {
-		out = append(out, t)
-	}
+	out = appendNodes(out, n.Target)
 	out = append(out, nodes(n.TargetWhere)...)
-	for _, s := range n.Set {
-		out = append(out, s)
-	}
+	out = appendNodes(out, n.Set)
 	return append(out, nodes(n.Where)...)
 }
 
@@ -92,9 +82,7 @@ type SetPair struct {
 
 func (n *SetPair) Children() []Node {
 	out := make([]Node, 0, len(n.Columns)+1)
-	for _, c := range n.Columns {
-		out = append(out, c)
-	}
+	out = appendNodes(out, n.Columns)
 	return append(out, nodes(n.Value)...)
 }
 
@@ -123,16 +111,10 @@ type UpdateStmt struct {
 func (*UpdateStmt) stmtNode() {}
 func (n *UpdateStmt) Children() []Node {
 	out := nodes(n.With, n.Table, n.Alias, n.IndexedBy)
-	for _, s := range n.Set {
-		out = append(out, s)
-	}
-	for _, f := range n.From {
-		out = append(out, f)
-	}
+	out = appendNodes(out, n.Set)
+	out = appendNodes(out, n.From)
 	out = append(out, nodes(n.Where)...)
-	for _, r := range n.Returning {
-		out = append(out, r)
-	}
+	out = appendNodes(out, n.Returning)
 	return out
 }
 
@@ -155,8 +137,6 @@ type DeleteStmt struct {
 func (*DeleteStmt) stmtNode() {}
 func (n *DeleteStmt) Children() []Node {
 	out := nodes(n.With, n.Table, n.Alias, n.IndexedBy, n.Where)
-	for _, r := range n.Returning {
-		out = append(out, r)
-	}
+	out = appendNodes(out, n.Returning)
 	return out
 }

ast/expr.go

@@ -292,12 +292,8 @@ type InExpr struct {
 func (*InExpr) exprNode() {}
 func (n *InExpr) Children() []Node {
 	out := nodes(n.X, n.Select, n.Table)
-	for _, e := range n.List {
-		out = append(out, e)
-	}
-	for _, e := range n.Args {
-		out = append(out, e)
-	}
+	out = appendNodes(out, n.List)
+	out = appendNodes(out, n.Args)
 	return out
 }
 
@@ -314,9 +310,7 @@ type CaseExpr struct {
 func (*CaseExpr) exprNode() {}
 func (n *CaseExpr) Children() []Node {
 	out := nodes(n.Operand)
-	for _, w := range n.Whens {
-		out = append(out, w)
-	}
+	out = appendNodes(out, n.Whens)
 	return append(out, nodes(n.Else)...)
 }
 
@@ -375,12 +369,8 @@ type FuncCall struct {
 func (*FuncCall) exprNode() {}
 func (n *FuncCall) Children() []Node {
 	out := nodes(n.Name)
-	for _, a := range n.Args {
-		out = append(out, a)
-	}
-	for _, o := range n.OrderBy {
-		out = append(out, o)
-	}
+	out = appendNodes(out, n.Args)
+	out = appendNodes(out, n.OrderBy)
 	return append(out, nodes(n.Filter, n.Over)...)
 }
 
@@ -448,13 +438,25 @@ type TypeName struct {
 
 func (n *TypeName) Children() []Node { return nil }
 
-// nodes builds a Children() slice, dropping nil interfaces and nil pointers.
+// nodes builds a Children() slice, dropping nil interfaces and nil
+// pointers. Optional fields are common, so a node whose children are all
+// absent allocates nothing.
 func nodes(list ...Node) []Node {
-	out := make([]Node, 0, len(list))
+	var out []Node
 	for _, n := range list {
 		if !isNil(n) {
 			out = append(out, n)
 		}
 	}
 	return out
 }
+
+// appendNodes appends a slice of concrete node pointers to a Children()
+// result. It exists because every node with a repeated field would
+// otherwise spell the same three-line loop out again.
+func appendNodes[T Node](out []Node, list []T) []Node {
+	for _, n := range list {
+		out = append(out, n)
+	}
+	return out
+}