feat(poet): add Defer, Assign, and CallStmt statement types

Add new statement AST nodes:
- Defer: defer statements (defer expr)
- Assign: assignment statements (left op right)
- CallStmt: function call statements

Update generator.go to use structured statements:
- Convert RawStmt assignments to poet.Assign
- Eliminates manual tab management for these statements

The rendering handles indentation automatically, making the code
more maintainable and less error-prone.

Author: claude

internal/codegen/golang/generator.go

@@ -421,13 +421,19 @@ func (g *CodeGenerator) addModelsCode(f *poet.File) {
 						{
 							Values: []string{"[]byte"},
 							Body: []poet.Stmt{
-								poet.RawStmt{Code: fmt.Sprintf("\t\t*e = %s(s)\n", enum.Name)},
+								poet.Assign{
+									Left: []string{"*e"}, Op: "=",
+									Right: []string{fmt.Sprintf("%s(s)", enum.Name)},
+								},
 							},
 						},
 						{
 							Values: []string{"string"},
 							Body: []poet.Stmt{
-								poet.RawStmt{Code: fmt.Sprintf("\t\t*e = %s(s)\n", enum.Name)},
+								poet.Assign{
+									Left: []string{"*e"}, Op: "=",
+									Right: []string{fmt.Sprintf("%s(s)", enum.Name)},
+								},
 							},
 						},
 						{
@@ -479,11 +485,15 @@ func (g *CodeGenerator) addModelsCode(f *poet.File) {
 				poet.If{
 					Cond: "value == nil",
 					Body: []poet.Stmt{
-						poet.RawStmt{Code: fmt.Sprintf("\t\tns.%s, ns.Valid = \"\", false\n", enum.Name)},
+						poet.Assign{
+							Left:  []string{"ns." + enum.Name, "ns.Valid"},
+							Op:    "=",
+							Right: []string{`""`, "false"},
+						},
 						poet.Return{Values: []string{"nil"}},
 					},
 				},
-				poet.RawStmt{Code: "\tns.Valid = true\n"},
+				poet.Assign{Left: []string{"ns.Valid"}, Op: "=", Right: []string{"true"}},
 				poet.Return{Values: []string{fmt.Sprintf("ns.%s.Scan(value)", enum.Name)}},
 			},
 		})
@@ -1352,11 +1362,14 @@ func (g *CodeGenerator) addCopyFromCodePGX(f *poet.File) {
 				poet.If{
 					Cond: "!r.skippedFirstNextCall",
 					Body: []poet.Stmt{
-						poet.RawStmt{Code: "\t\tr.skippedFirstNextCall = true\n"},
+						poet.Assign{
+							Left: []string{"r.skippedFirstNextCall"}, Op: "=",
+							Right: []string{"true"},
+						},
 						poet.Return{Values: []string{"true"}},
 					},
 				},
-				poet.RawStmt{Code: "\tr.rows = r.rows[1:]\n"},
+				poet.Assign{Left: []string{"r.rows"}, Op: "=", Right: []string{"r.rows[1:]"}},
 				poet.Return{Values: []string{"len(r.rows) > 0"}},
 			},
 		})
@@ -1697,7 +1710,7 @@ func (g *CodeGenerator) addBatchCodePGX(f *poet.File) {
 			Name:    "Close",
 			Results: []poet.Param{{Type: "error"}},
 			Stmts: []poet.Stmt{
-				poet.RawStmt{Code: "\tb.closed = true\n"},
+				poet.Assign{Left: []string{"b.closed"}, Op: "=", Right: []string{"true"}},
 				poet.Return{Values: []string{"b.br.Close()"}},
 			},
 		})

internal/poet/ast.go

@@ -188,3 +188,26 @@ type Case struct {
 	Values []string // Case values (empty for default case)
 	Body   []Stmt
 }
+
+// Defer represents a defer statement.
+type Defer struct {
+	Call string // The function call to defer
+}
+
+func (Defer) isStmt() {}
+
+// Assign represents an assignment statement.
+type Assign struct {
+	Left  []string // Left-hand side (variable names)
+	Op    string   // Assignment operator: "=", ":=", "+=", etc.
+	Right []string // Right-hand side (expressions)
+}
+
+func (Assign) isStmt() {}
+
+// CallStmt represents a function call as a statement.
+type CallStmt struct {
+	Call string // The function call expression
+}
+
+func (CallStmt) isStmt() {}

internal/poet/render.go

@@ -307,6 +307,12 @@ func renderStmt(b *strings.Builder, s Stmt, indent string) {
 		renderIf(b, s, indent)
 	case Switch:
 		renderSwitch(b, s, indent)
+	case Defer:
+		renderDefer(b, s, indent)
+	case Assign:
+		renderAssign(b, s, indent)
+	case CallStmt:
+		renderCallStmt(b, s, indent)
 	}
 }
 
@@ -403,3 +409,36 @@ func renderSwitch(b *strings.Builder, s Switch, indent string) {
 	b.WriteString(indent)
 	b.WriteString("}\n")
 }
+
+func renderDefer(b *strings.Builder, d Defer, indent string) {
+	b.WriteString(indent)
+	b.WriteString("defer ")
+	b.WriteString(d.Call)
+	b.WriteString("\n")
+}
+
+func renderAssign(b *strings.Builder, a Assign, indent string) {
+	b.WriteString(indent)
+	for i, l := range a.Left {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		b.WriteString(l)
+	}
+	b.WriteString(" ")
+	b.WriteString(a.Op)
+	b.WriteString(" ")
+	for i, r := range a.Right {
+		if i > 0 {
+			b.WriteString(", ")
+		}
+		b.WriteString(r)
+	}
+	b.WriteString("\n")
+}
+
+func renderCallStmt(b *strings.Builder, c CallStmt, indent string) {
+	b.WriteString(indent)
+	b.WriteString(c.Call)
+	b.WriteString("\n")
+}