Replace string builders with structured Go IR for try/spawn/parallel

Introduce lightweight Go IR node types (goIIFE, goDefer, goGoroutine, goIf,
goRaw, goUserCode) that represent the structure of generated Go code. The
emitGoIR() method handles indentation uniformly.

Refactored tryExpr(), spawnExpr(), and parallelExpr() to build IR trees
instead of manually assembling strings with hardcoded tab characters.
The generated output is structurally identical.

Author: rubiojr

compiler/codegen_expr.go

@@ -645,7 +645,6 @@ func (g *codeGen) tryExpr(e *ast.TryExpr) (string, error) {
 	}
 
 	// Build the handler body as Go source in a temporary buffer.
-	var handlerBuf strings.Builder
 	handlerCode, cerr := g.captureOutput(func() error {
 		g.pushScope()
 		g.declareVar(e.ErrVar)
@@ -680,24 +679,22 @@ func (g *codeGen) tryExpr(e *ast.TryExpr) (string, error) {
 		return "", cerr
 	}
 
-	// Build the IIFE
-	handlerBuf.WriteString("func() (r interface{}) {\n")
-	handlerBuf.WriteString("\t\tdefer func() {\n")
-	handlerBuf.WriteString("\t\t\tif e := recover(); e != nil {\n")
-	handlerBuf.WriteString(fmt.Sprintf("\t\t\t\t%s := fmt.Sprint(e)\n", e.ErrVar))
-	handlerBuf.WriteString(fmt.Sprintf("\t\t\t\t_ = %s\n", e.ErrVar))
-	// Indent and write handler code
-	for _, line := range strings.Split(handlerCode, "\n") {
-		if line != "" {
-			handlerBuf.WriteString("\t\t\t\t" + strings.TrimLeft(line, "\t") + "\n")
-		}
+	// Build the IIFE using Go IR
+	ir := goIIFE{
+		ReturnType: "(r interface{})",
+		Body: []goNode{
+			goDefer{Body: []goNode{
+				goIf{Cond: "e := recover(); e != nil", Body: []goNode{
+					goRaw{Code: fmt.Sprintf("%s := fmt.Sprint(e)", e.ErrVar)},
+					goRaw{Code: fmt.Sprintf("_ = %s", e.ErrVar)},
+					goUserCode{Code: handlerCode},
+				}},
+			}},
+		},
+		Return: exprStr,
 	}
-	handlerBuf.WriteString("\t\t\t}\n")
-	handlerBuf.WriteString("\t\t}()\n")
-	handlerBuf.WriteString(fmt.Sprintf("\t\treturn %s\n", exprStr))
-	handlerBuf.WriteString("\t}()")
 
-	return handlerBuf.String(), nil
+	return g.emitGoIR(ir), nil
 }
 
 func (g *codeGen) spawnExpr(e *ast.SpawnExpr) (string, error) {
@@ -732,27 +729,24 @@ func (g *codeGen) spawnExpr(e *ast.SpawnExpr) (string, error) {
 		return "", cerr
 	}
 
-	// Build the IIFE that creates a rugoTask and launches a goroutine
-	var buf strings.Builder
-	buf.WriteString("func() interface{} {\n")
-	buf.WriteString("\t\tt := &rugoTask{done: make(chan struct{})}\n")
-	buf.WriteString("\t\tgo func() {\n")
-	buf.WriteString("\t\t\tdefer func() {\n")
-	buf.WriteString("\t\t\t\tif e := recover(); e != nil {\n")
-	buf.WriteString("\t\t\t\t\tt.err = fmt.Sprint(e)\n")
-	buf.WriteString("\t\t\t\t}\n")
-	buf.WriteString("\t\t\t\tclose(t.done)\n")
-	buf.WriteString("\t\t\t}()\n")
-	for _, line := range strings.Split(bodyCode, "\n") {
-		if line != "" {
-			buf.WriteString("\t\t\t" + strings.TrimLeft(line, "\t") + "\n")
-		}
-	}
-	buf.WriteString("\t\t}()\n")
-	buf.WriteString("\t\treturn interface{}(t)\n")
-	buf.WriteString("\t}()")
-
-	return buf.String(), nil
+	// Build the IIFE using Go IR
+	ir := goIIFE{
+		Body: []goNode{
+			goRaw{Code: "t := &rugoTask{done: make(chan struct{})}"},
+			goGoroutine{Body: []goNode{
+				goDefer{Body: []goNode{
+					goIf{Cond: "e := recover(); e != nil", Body: []goNode{
+						goRaw{Code: "t.err = fmt.Sprint(e)"},
+					}},
+					goRaw{Code: "close(t.done)"},
+				}},
+				goUserCode{Code: bodyCode},
+			}},
+		},
+		Return: "interface{}(t)",
+	}
+
+	return g.emitGoIR(ir), nil
 }
 
 func (g *codeGen) fnExpr(e *ast.FnExpr) (string, error) {
@@ -895,42 +889,48 @@ func (g *codeGen) parallelExpr(e *ast.ParallelExpr) (string, error) {
 		}
 	}
 
-	var buf strings.Builder
-	buf.WriteString("func() interface{} {\n")
-	buf.WriteString(fmt.Sprintf("\t\t_results := make([]interface{}, %d)\n", n))
-	buf.WriteString("\t\tvar _wg sync.WaitGroup\n")
-	buf.WriteString("\t\tvar _parErr string\n")
-	buf.WriteString("\t\tvar _parOnce sync.Once\n")
-	buf.WriteString(fmt.Sprintf("\t\t_wg.Add(%d)\n", n))
-
+	// Build goroutine nodes for each parallel branch
+	var goroutines []goNode
 	for i, sc := range stmts {
-		buf.WriteString("\t\tgo func() {\n")
-		buf.WriteString("\t\t\tdefer _wg.Done()\n")
-		buf.WriteString("\t\t\tdefer func() {\n")
-		buf.WriteString("\t\t\t\tif e := recover(); e != nil {\n")
-		buf.WriteString("\t\t\t\t\t_parOnce.Do(func() { _parErr = fmt.Sprint(e) })\n")
-		buf.WriteString("\t\t\t\t}\n")
-		buf.WriteString("\t\t\t}()\n")
+		var bodyNode goNode
 		if sc.isExpr {
-			buf.WriteString(fmt.Sprintf("\t\t\t_results[%d] = %s\n", i, sc.code))
+			bodyNode = goRaw{Code: fmt.Sprintf("_results[%d] = %s", i, sc.code)}
 		} else {
-			for _, line := range strings.Split(sc.code, "\n") {
-				if line != "" {
-					buf.WriteString("\t\t\t" + strings.TrimLeft(line, "\t") + "\n")
-				}
-			}
-		}
-		buf.WriteString("\t\t}()\n")
-	}
-
-	buf.WriteString("\t\t_wg.Wait()\n")
-	buf.WriteString("\t\tif _parErr != \"\" {\n")
-	buf.WriteString("\t\t\tpanic(_parErr)\n")
-	buf.WriteString("\t\t}\n")
-	buf.WriteString("\t\tout := make([]interface{}, len(_results))\n")
-	buf.WriteString("\t\tcopy(out, _results)\n")
-	buf.WriteString("\t\treturn interface{}(out)\n")
-	buf.WriteString("\t}()")
-
-	return buf.String(), nil
+			bodyNode = goUserCode{Code: sc.code}
+		}
+		goroutines = append(goroutines, goGoroutine{Body: []goNode{
+			goRaw{Code: "defer _wg.Done()"},
+			goDefer{Body: []goNode{
+				goIf{Cond: "e := recover(); e != nil", Body: []goNode{
+					goRaw{Code: `_parOnce.Do(func() { _parErr = fmt.Sprint(e) })`},
+				}},
+			}},
+			bodyNode,
+		}})
+	}
+
+	// Build the IIFE using Go IR
+	body := []goNode{
+		goRaw{Code: fmt.Sprintf("_results := make([]interface{}, %d)", n)},
+		goRaw{Code: "var _wg sync.WaitGroup"},
+		goRaw{Code: "var _parErr string"},
+		goRaw{Code: "var _parOnce sync.Once"},
+		goRaw{Code: fmt.Sprintf("_wg.Add(%d)", n)},
+	}
+	body = append(body, goroutines...)
+	body = append(body,
+		goRaw{Code: "_wg.Wait()"},
+		goIf{Cond: `_parErr != ""`, Body: []goNode{
+			goRaw{Code: "panic(_parErr)"},
+		}},
+		goRaw{Code: "out := make([]interface{}, len(_results))"},
+		goRaw{Code: "copy(out, _results)"},
+	)
+
+	ir := goIIFE{
+		Body:   body,
+		Return: "interface{}(out)",
+	}
+
+	return g.emitGoIR(ir), nil
 }

compiler/goir.go

@@ -0,0 +1,158 @@
+package compiler
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Go IR nodes represent the structure of generated Go code fragments.
+// They separate "what to generate" from "how to format it", eliminating
+// manual string builder code with hardcoded indentation.
+
+// goNode is a piece of Go code that can be emitted with proper indentation.
+type goNode interface {
+	goNode()
+}
+
+// goRaw is a literal line of Go code.
+type goRaw struct {
+	Code string
+}
+
+func (goRaw) goNode() {}
+
+// goBlock is a sequence of Go nodes emitted in order.
+type goBlock struct {
+	Nodes []goNode
+}
+
+func (goBlock) goNode() {}
+
+// goIIFE represents a self-calling function: func() T { ... }()
+type goIIFE struct {
+	ReturnType string   // e.g. "interface{}", "(r interface{})"
+	Body       []goNode // statements inside the IIFE
+	Return     string   // final return expression (empty = omit)
+}
+
+func (goIIFE) goNode() {}
+
+// goDefer represents: defer func() { ... }()
+type goDefer struct {
+	Body []goNode
+}
+
+func (goDefer) goNode() {}
+
+// goGoroutine represents: go func() { ... }()
+type goGoroutine struct {
+	Body []goNode
+}
+
+func (goGoroutine) goNode() {}
+
+// goIf represents: if cond { ... }
+type goIf struct {
+	Cond string
+	Body []goNode
+}
+
+func (goIf) goNode() {}
+
+// goUserCode is pre-generated Go code from codegen (e.g., handler body).
+// Lines are re-indented to match the surrounding context.
+type goUserCode struct {
+	Code string
+}
+
+func (goUserCode) goNode() {}
+
+// emitGoIR renders a Go IR node tree into a string suitable for use as
+// an expression (e.g., the right side of an assignment). The first line
+// has no indentation; subsequent lines are indented relative to g.indent.
+func (g *codeGen) emitGoIR(node goNode) string {
+	var sb strings.Builder
+	emitNode(&sb, node, g.indent, true)
+	// Trim trailing newline so caller controls line ending
+	s := sb.String()
+	return strings.TrimRight(s, "\n")
+}
+
+func emitNode(sb *strings.Builder, node goNode, indent int, firstLine bool) {
+	switch n := node.(type) {
+	case goRaw:
+		if firstLine {
+			sb.WriteString(n.Code)
+		} else {
+			writeIndented(sb, indent, n.Code)
+		}
+		sb.WriteByte('\n')
+
+	case goBlock:
+		for i, child := range n.Nodes {
+			emitNode(sb, child, indent, firstLine && i == 0)
+		}
+
+	case goIIFE:
+		retType := n.ReturnType
+		if retType == "" {
+			retType = "interface{}"
+		}
+		opening := fmt.Sprintf("func() %s {", retType)
+		if firstLine {
+			sb.WriteString(opening)
+		} else {
+			writeIndented(sb, indent, opening)
+		}
+		sb.WriteByte('\n')
+		for _, child := range n.Body {
+			emitNode(sb, child, indent+1, false)
+		}
+		if n.Return != "" {
+			writeIndented(sb, indent+1, fmt.Sprintf("return %s", n.Return))
+			sb.WriteByte('\n')
+		}
+		writeIndented(sb, indent, "}()")
+		sb.WriteByte('\n')
+
+	case goDefer:
+		writeIndented(sb, indent, "defer func() {")
+		sb.WriteByte('\n')
+		for _, child := range n.Body {
+			emitNode(sb, child, indent+1, false)
+		}
+		writeIndented(sb, indent, "}()")
+		sb.WriteByte('\n')
+
+	case goGoroutine:
+		writeIndented(sb, indent, "go func() {")
+		sb.WriteByte('\n')
+		for _, child := range n.Body {
+			emitNode(sb, child, indent+1, false)
+		}
+		writeIndented(sb, indent, "}()")
+		sb.WriteByte('\n')
+
+	case goIf:
+		writeIndented(sb, indent, fmt.Sprintf("if %s {", n.Cond))
+		sb.WriteByte('\n')
+		for _, child := range n.Body {
+			emitNode(sb, child, indent+1, false)
+		}
+		writeIndented(sb, indent, "}")
+		sb.WriteByte('\n')
+
+	case goUserCode:
+		for _, line := range strings.Split(n.Code, "\n") {
+			if line != "" {
+				writeIndented(sb, indent, strings.TrimLeft(line, "\t"))
+				sb.WriteByte('\n')
+			}
+		}
+	}
+}
+
+func writeIndented(sb *strings.Builder, indent int, code string) {
+	sb.WriteString(strings.Repeat("\t", indent))
+	sb.WriteString(code)
+}

compiler/source_embed.go

@@ -5,6 +5,6 @@ import "embed"
 // Sources embeds all non-test Go source files and templates needed to
 // reconstruct the compiler package in an external module cache.
 //
-//go:embed compiler.go codegen.go codegen_expr.go codegen_func.go codegen_runtime.go codegen_scope.go codegen_stmt.go ext.go infer.go types.go visitor.go
+//go:embed compiler.go codegen.go codegen_expr.go codegen_func.go codegen_runtime.go codegen_scope.go codegen_stmt.go ext.go goir.go infer.go types.go visitor.go
 //go:embed templates/runtime_core_pre.go.tmpl templates/runtime_core_post.go.tmpl templates/runtime_spawn.go.tmpl
 var Sources embed.FS