Show enums whose zero value means something, and chain difftest edits

A dump omits zero-valued fields, which made a snapshot ambiguous
wherever the zero is the answer: UNBOUNDED PRECEDING, PRIMARY KEY, the
NULL literal and four others were printing as nothing at all. An enum
whose zero means "absent" says so in its String -- "none", "default",
"unspecified" -- which turns out to be exactly the right test. Seven
lines gained across the snapshots, no noise added.

difftest's -depth applied every extra round to the original mutation
rather than to the previous one, so it never got past two edits.

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

Author: claude

cmd/difftest/main.go

@@ -112,13 +112,19 @@ func main() {
 			for src := range work {
 				for _, m := range mutations(src, *per, rng) {
 					check(r, m, rep)
-					// A second edit reaches shapes one cannot: two
-					// unbalanced brackets, a keyword in a position only
-					// another edit could open up.
+					// Further edits reach shapes one cannot: two unbalanced
+					// brackets, a keyword in a position only another edit
+					// could open up. Each round builds on the last.
+					cur := m
 					for d := 1; d < *depth; d++ {
-						for _, m2 := range mutations(m, 2, rng) {
+						next := mutations(cur, 2, rng)
+						if len(next) == 0 {
+							break
+						}
+						for _, m2 := range next {
 							check(r, m2, rep)
 						}
+						cur = next[0]
 					}
 				}
 			}

internal/dump/dump.go

@@ -139,8 +139,34 @@ type field struct {
 	value reflect.Value
 }
 
+// meaningfulZero reports whether a zero value still says something. Several
+// enums have a meaningful zero -- FrameBoundType(0) is UNBOUNDED PRECEDING,
+// TableConstraintKind(0) is PRIMARY KEY -- and omitting those would make a
+// snapshot ambiguous. An enum whose zero means "absent" says so in its
+// String, which is exactly the ones worth leaving out.
+func meaningfulZero(v reflect.Value) bool {
+	// Only enums: a nil node pointer also implements Stringer, and calling
+	// String on it is a crash rather than an answer.
+	switch v.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
+		reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+	default:
+		return false
+	}
+	s, ok := v.Interface().(fmt.Stringer)
+	if !ok {
+		return false
+	}
+	switch s.String() {
+	case "", "none", "default", "unspecified":
+		return false
+	}
+	return true
+}
+
 // fields selects the fields worth printing: zero values are omitted so that
-// a dump shows what a statement said rather than what it did not.
+// a dump shows what a statement said rather than what it did not, except
+// where the zero value is itself the statement (see meaningfulZero).
 func (d *dumper) fields(v reflect.Value) []field {
 	t := v.Type()
 	var out []field
@@ -160,7 +186,7 @@ func (d *dumper) fields(v reflect.Value) []field {
 		if sf.Name == "Raw" && !d.opts.Raw {
 			continue
 		}
-		if fv.IsZero() {
+		if fv.IsZero() && !meaningfulZero(fv) {
 			continue
 		}
 		out = append(out, field{sf.Name, fv})

parser/parser.go

@@ -69,6 +69,11 @@ func LineCol(src string, offset int) (line, col int) {
 }
 
 // Parse reads SQL from r and returns one ast.Stmt per statement.
+//
+// The context is accepted so the signature matches the sibling parsers
+// sqlc uses, and is not consulted: parsing is a bounded, allocation-light
+// pass over the input, and the recursion limit keeps even hostile input
+// from taking long enough to be worth cancelling.
 func Parse(ctx context.Context, r io.Reader) ([]ast.Stmt, error) {
 	src, err := io.ReadAll(r)
 	if err != nil {

parser/testdata/ast/ddl.tree

@@ -198,6 +198,7 @@ CreateTableStmt{
                   Name: "full"
                   Raw: "full"
                 }
+                Action: ForeignKeyAction(NO ACTION)
               }
             ]
           }
@@ -295,6 +296,7 @@ CreateTableStmt{
         Name: "pk"
         Raw: "pk"
       }
+      Kind: TableConstraintKind(PRIMARY KEY)
       Columns: [
         OrderingTerm{
           Span: 447:448
@@ -743,6 +745,7 @@ AlterTableStmt{
       Raw: "t"
     }
   }
+  Action: AlterAction(RENAME TO)
   NewName: Ident{
     Span: 1126:1127
     Name: "u"

parser/testdata/ast/expressions.tree

@@ -1199,6 +1199,7 @@ SelectStmt{
           Span: 985:989
           Expr: Literal{
             Span: 985:989
+            Kind: LiteralKind(NULL)
             Value: "NULL"
             Raw: "NULL"
           }
@@ -1289,6 +1290,7 @@ SelectStmt{
           Span: 1057:1058
           Expr: BindParam{
             Span: 1057:1058
+            Kind: ParamKind(?)
             Number: 1
             Raw: "?"
           }

parser/testdata/ast/misc.tree

@@ -1,5 +1,6 @@
 BeginStmt{
   Span: 58:64
+  Type: TransactionType(DEFERRED)
 }
 BeginStmt{
   Span: 65:98

parser/testdata/ast/select.tree

@@ -942,6 +942,7 @@ SelectStmt{
           Frame: FrameType(RANGE)
           StartBound: FrameBound{
             Span: 807:826
+            Type: FrameBoundType(UNBOUNDED PRECEDING)
           }
           EndBound: FrameBound{
             Span: 831:842