compiler: unify expression pipeline

The entire expression pipeline now flows through a single path:
buildExpr → GoExpr nodes → printer.

Author: rubiojr

ast/preprocess.go

@@ -1527,7 +1527,6 @@ func expandInlineFnLine(line string) string {
 		if paramEnd < 0 {
 			// No matching ) — leave unchanged
 			buf.WriteString(line[fnIdx:])
-			pos = len(line)
 			break
 		}
 

cmd/cmd.go

@@ -202,9 +202,7 @@ func Execute(version string) {
 	}
 
 	// Inject installed tools as top-level commands so they appear in help.
-	for _, tc := range installedToolCommands() {
-		cmd.Commands = append(cmd.Commands, tc)
-	}
+	cmd.Commands = append(cmd.Commands, installedToolCommands()...)
 
 	if err := cmd.Run(context.Background(), os.Args); err != nil {
 		fmt.Fprintln(os.Stderr, formatError(err.Error()))
@@ -428,7 +426,7 @@ func modTidyAction(ctx context.Context, cmd *cli.Command) error {
 				continue
 			}
 			if existing, ok := moduleVersions[mod]; ok && existing.version != ver {
-				return fmt.Errorf("version conflict for %s:\n  %s requires %s\n  %s requires %s\nAlign on a single version, then re-run 'rugo mod tidy'.",
+				return fmt.Errorf("version conflict for %s:\n  %s requires %s\n  %s requires %s\nAlign on a single version, then re-run 'rugo mod tidy'",
 					mod, existing.file, existing.version, filepath.Base(f), ver)
 			}
 			moduleVersions[mod] = modSource{version: ver, file: filepath.Base(f)}

compiler/codegen.go

@@ -50,7 +50,6 @@ type codeGen struct {
 	lambdaDepth     int                  // nesting depth of lambda bodies (>0 means inside fn)
 	lambdaScopeBase []int                // scope index at each lambda entry (stack)
 	lambdaOuterFunc []*ast.FuncDef       // enclosing function at each lambda entry (stack)
-	indent          int                  // current indent level for nested expression rendering
 	sandbox         *SandboxConfig       // Landlock sandbox config (nil = no sandbox)
 }
 
@@ -429,54 +428,56 @@ func (g *codeGen) ensureFloat(s string, t RugoType) string {
 	return s
 }
 
-// boxedArgs returns comma-joined args, boxing typed values for runtime helpers.
-func (g *codeGen) boxedArgs(args []string, exprs []ast.Expr) string {
-	result := make([]string, len(args))
+// boxedExprs wraps typed GoExpr args in GoCastExpr for runtime helpers.
+func (g *codeGen) boxedExprs(args []GoExpr, exprs []ast.Expr) []GoExpr {
+	result := make([]GoExpr, len(args))
 	for i, a := range args {
-		result[i] = g.boxed(a, g.exprType(exprs[i]))
+		if g.exprType(exprs[i]).IsTyped() {
+			result[i] = GoCastExpr{Type: "interface{}", Value: a}
+		} else {
+			result[i] = a
+		}
 	}
-	return strings.Join(result, ", ")
+	return result
 }
 
-// typedCallArgs generates the argument list for a user-defined function call,
+// typedCallExprs generates GoExpr arguments for a user-defined function call,
 // converting typed args to match the function's typed param signature.
-func (g *codeGen) typedCallArgs(funcName string, args []string, argExprs []ast.Expr) string {
+func (g *codeGen) typedCallExprs(funcName string, args []GoExpr, argExprs []ast.Expr) []GoExpr {
 	if g.typeInfo == nil {
-		return strings.Join(args, ", ")
+		return args
 	}
 	fti, ok := g.typeInfo.FuncTypes[funcName]
 	if !ok {
-		return strings.Join(args, ", ")
+		return args
 	}
 
-	result := make([]string, len(args))
+	result := make([]GoExpr, len(args))
 	for i, a := range args {
 		argType := g.exprType(argExprs[i])
 		if i < len(fti.ParamTypes) && fti.ParamTypes[i].IsTyped() {
-			// Target param is typed — ensure arg matches.
 			if argType == fti.ParamTypes[i] {
-				result[i] = a // Already the right type.
+				result[i] = a
 			} else if argType.IsTyped() && argType.IsNumeric() && fti.ParamTypes[i].IsNumeric() {
-				// Numeric promotion.
 				if fti.ParamTypes[i] == TypeFloat && argType == TypeInt {
-					result[i] = fmt.Sprintf("float64(%s)", a)
+					result[i] = GoCastExpr{Type: "float64", Value: a}
 				} else if fti.ParamTypes[i] == TypeInt && argType == TypeFloat {
-					result[i] = fmt.Sprintf("int(%s)", a)
+					result[i] = GoCastExpr{Type: "int", Value: a}
 				} else {
 					result[i] = a
 				}
 			} else if argType.IsTyped() {
-				// Type mismatch — shouldn't happen with correct inference,
-				// but be safe.
 				result[i] = a
 			} else {
-				// Arg is interface{} but param is typed — need type assertion.
-				result[i] = fmt.Sprintf("%s.(%s)", a, fti.ParamTypes[i].GoType())
+				result[i] = GoTypeAssert{Value: a, Type: fti.ParamTypes[i].GoType()}
 			}
 		} else {
-			// Target param is interface{} — box typed args.
-			result[i] = g.boxed(a, argType)
+			if argType.IsTyped() {
+				result[i] = GoCastExpr{Type: "interface{}", Value: a}
+			} else {
+				result[i] = a
+			}
 		}
 	}
-	return strings.Join(result, ", ")
+	return result
 }

compiler/codegen_build.go

@@ -597,23 +597,6 @@ func (g *codeGen) buildPanicHandler() GoDeferStmt {
 	}}
 }
 
-// buildMainFunc builds the main() function declaration.
-func (g *codeGen) buildMainFunc(topStmts []ast.Statement) (GoFuncDecl, error) {
-	var body []GoStmt
-	body = append(body, g.buildPanicHandler())
-
-	g.pushScope()
-	stmts, err := g.buildStmts(topStmts)
-	if err != nil {
-		g.popScope()
-		return GoFuncDecl{}, err
-	}
-	body = append(body, stmts...)
-	g.popScope()
-
-	return GoFuncDecl{Name: "main", Body: body}, nil
-}
-
 // buildImports constructs the GoImport list for a Rugo program.
 func (g *codeGen) buildImports(needsSync, needsTime bool) []GoImport {
 	var imports []GoImport