Fix up catch

Signed-off-by: James Hamlin <jfhamlin@gmail.com>

Author: jfhamlin

pkg/codegen/codegen.go

@@ -34,6 +34,8 @@ type Generator struct {
 	w              io.Writer
 	varScopes      []varScope     // stack of variable scopes
 	recurStack     []recurContext // stack of recur contexts for nested loops
+
+	imports map[string]bool // set of imported packages to avoid duplicates
 }
 
 // New creates a new code generator
@@ -43,6 +45,7 @@ func New(w io.Writer) *Generator {
 		w:              w,
 		varScopes:      []varScope{{nextNum: 0, names: make(map[string]string)}},
 		recurStack:     []recurContext{},
+		imports:        make(map[string]bool),
 	}
 }
 
@@ -53,41 +56,6 @@ func (g *Generator) Generate(ns *lang.Namespace) error {
 	var buf bytes.Buffer
 	g.w = &buf
 
-	// Check if we need fmt import (for functions with arity checks)
-	needsFmt := false
-	mappings := ns.Mappings()
-
-	// Only check vars that are interned in this namespace
-	for seq := mappings.Seq(); seq != nil; seq = seq.Next() {
-		entry := seq.First()
-		name, ok := lang.First(entry).(*lang.Symbol)
-		if !ok {
-			continue
-		}
-		second, _ := lang.Nth(entry, 1)
-		vr, ok := second.(*lang.Var)
-		if !ok {
-			continue
-		}
-
-		// Skip non-interned mappings
-		if !(vr.Namespace() == ns && lang.Equals(vr.Symbol(), name)) {
-			continue
-		}
-
-		if vr.IsBound() {
-			if _, ok := vr.Get().(*runtime.Fn); ok {
-				needsFmt = true
-				break
-			}
-		}
-	}
-
-	// Write package header
-	if err := g.writeHeader(needsFmt); err != nil {
-		return err
-	}
-
 	g.writef("func init() {\n")
 
 	g.writef("  ns := lang.FindOrCreateNamespace(lang.NewSymbol(\"%s\"))\n", ns.Name().String())
@@ -96,6 +64,7 @@ func (g *Generator) Generate(ns *lang.Namespace) error {
 	// 1. Iterate through ns.Mappings()
 	// 2. Generate Go code for each var
 	// 3. Create initialization functions
+	mappings := ns.Mappings()
 	for seq := mappings.Seq(); seq != nil; seq = seq.Next() {
 		entry := seq.First()
 		name, ok := lang.First(entry).(*lang.Symbol)
@@ -119,8 +88,12 @@ func (g *Generator) Generate(ns *lang.Namespace) error {
 
 	g.writef("}\n")
 
+	// Write package header
+	sourceBytes := []byte(g.header())
+	sourceBytes = append(sourceBytes, buf.Bytes()...)
+
 	// Format the generated code
-	formatted, err := format.Source(buf.Bytes())
+	formatted, err := format.Source(sourceBytes)
 	if err != nil {
 		// If formatting fails, write the unformatted code with the error
 		return fmt.Errorf("formatting failed: %w\n\nGenerated code:\n%s", err, buf.String())
@@ -273,6 +246,7 @@ func (g *Generator) generateFn(fn *runtime.Fn) string {
 
 		g.writef("%s := lang.IFnFunc(func(args ...any) any {\n", fnVar)
 
+		g.addImport("fmt") // Import fmt for error formatting
 		// Check arity
 		g.writef("  if len(args) != %d {\n", methodNode.FixedArity)
 		g.writef("    panic(lang.NewIllegalArgumentError(\"wrong number of arguments (\" + fmt.Sprint(len(args)) + \")\"))\n")
@@ -373,7 +347,6 @@ func (g *Generator) generateASTNode(node *ast.Node) string {
 	// OpSet
 	// OpLetFn
 	// OpQuote
-	// OpGoBuiltin
 	// OpGo
 	// OpHostCall
 	// OpHostInterop
@@ -407,10 +380,7 @@ func (g *Generator) generateASTNode(node *ast.Node) string {
 	case ast.OpRecur:
 		return g.generateRecur(node)
 	case ast.OpGoBuiltin:
-		// For now, just return a reference to the go type
-		// This is used for catch clauses with go/any
-		goBuiltinNode := node.Sub.(*ast.GoBuiltinNode)
-		return fmt.Sprintf("lang.NewSymbol(\"%s\")", goBuiltinNode.Sym.Name())
+		return g.generateGoBuiltin(node)
 	default:
 		fmt.Printf("Generating code for AST node: %T %+v\n", node.Sub, node.Sub)
 		panic(fmt.Sprintf("unsupported AST node type %T", node.Sub))
@@ -720,9 +690,8 @@ func (g *Generator) generateTry(node *ast.Node) string {
 				g.writef("} else ")
 			}
 
-			// Simple implementation: check for "any" or assume it catches
-			// In a full implementation, we'd need to check types properly
-			g.writef("if true { // TODO: implement catchMatches(r, %s)\n", classExpr)
+			// Check if the exception matches this catch type
+			g.writef("if lang.CatchMatches(r, %s) {\n", classExpr)
 
 			// Create new scope for catch binding
 			g.pushVarScope()
@@ -758,25 +727,39 @@ func (g *Generator) generateTry(node *ast.Node) string {
 	return resultVar
 }
 
+func (g *Generator) generateGoBuiltin(node *ast.Node) string {
+	goBuiltinNode := node.Sub.(*ast.GoBuiltinNode)
+	sym := goBuiltinNode.Sym
+
+	_, ok := lang.Builtins[sym.Name()]
+	if !ok {
+		panic(fmt.Sprintf("unknown Go builtin: %s", sym.Name()))
+	}
+
+	return "lang.Builtins[\"" + sym.Name() + "\"]"
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
-func (g *Generator) writeHeader(needsFmt bool) error {
+func (g *Generator) addImport(pkg string) {
+	g.imports[pkg] = true
+}
+
+func (g *Generator) header() string {
 	header := `// Code generated by glojure codegen. DO NOT EDIT.
 
 package generated
 
 import (
+  "github.com/glojurelang/glojure/pkg/lang"
 `
-	if needsFmt {
-		header += `  "fmt"
-`
+
+	for pkg := range g.imports {
+		header += fmt.Sprintf("  \"%s\"\n", pkg)
 	}
-	header += `  "github.com/glojurelang/glojure/pkg/lang"
-)
 
-`
-	_, err := io.WriteString(g.w, header)
-	return err
+	header += ")\n"
+	return header
 }
 
 func (g *Generator) writef(format string, args ...any) error {

pkg/codegen/testdata/codegen/test/try_advanced.go

@@ -0,0 +1,45 @@
+package lang
+
+import (
+	"errors"
+	"reflect"
+)
+
+var (
+	errorType = reflect.TypeOf((*error)(nil)).Elem()
+)
+
+// CatchMatches checks if a recovered panic value matches an expected catch type.
+// This implements the semantics of Clojure's try/catch matching.
+func CatchMatches(r, expect any) bool {
+	if IsNil(expect) {
+		return false
+	}
+
+	// Special case: the symbol "any" catches everything (for go/any)
+	if sym, ok := expect.(*Symbol); ok && sym.Name() == "any" {
+		return true
+	}
+
+	// If expect is an error type, check if r is an instance of it
+	if rErr, ok := r.(error); ok {
+		if expectTyp, ok := expect.(reflect.Type); ok && expectTyp.Implements(errorType) {
+			expectVal := reflect.New(expectTyp).Elem().Interface().(error)
+			if errors.Is(rErr, expectVal) {
+				return true
+			}
+		}
+	}
+
+	// General type check
+	if expectTyp, ok := expect.(reflect.Type); ok {
+		return reflect.TypeOf(r).AssignableTo(expectTyp)
+	}
+
+	// For interface{} type (go/any), catch everything
+	if expectTyp, ok := expect.(reflect.Type); ok && expectTyp.Kind() == reflect.Interface && expectTyp.NumMethod() == 0 {
+		return true
+	}
+
+	return false
+}

pkg/codegen/testdata/codegen/test/try_basic.go

@@ -689,27 +689,6 @@ func (env *environment) EvalASTNew(n *ast.Node) (interface{}, error) {
 	return reflect.New(classValTyp).Interface(), nil
 }
 
-var (
-	errorType = reflect.TypeOf((*error)(nil)).Elem()
-)
-
-func catchMatches(r, expect any) bool {
-	if lang.IsNil(expect) {
-		return false
-	}
-
-	// if expect is an error type, check if r is an instance of it
-	if rErr, ok := r.(error); ok {
-		if expectTyp, ok := expect.(reflect.Type); ok && expectTyp.Implements(errorType) {
-			expectVal := reflect.New(expectTyp).Elem().Interface().(error)
-			if errors.Is(rErr, expectVal) {
-				return true
-			}
-		}
-	}
-
-	return reflect.TypeOf(r).AssignableTo(expect.(reflect.Type))
-}
 
 func (env *environment) EvalASTTry(n *ast.Node) (res interface{}, err error) {
 	tryNode := n.Sub.(*ast.TryNode)
@@ -735,7 +714,7 @@ func (env *environment) EvalASTTry(n *ast.Node) (res interface{}, err error) {
 					panic(classErr)
 				}
 
-				if !catchMatches(r, classVal) {
+				if !lang.CatchMatches(r, classVal) {
 					continue
 				}