Fix AOT namespace dependencies and dynamic var compilation

.gitignore

@@ -3,4 +3,4 @@ doc/repl/glj.wasm
 .direnv
 
 # useful to symlink in for context
-clojure
+/clojure

Makefile

@@ -52,8 +52,8 @@ gocmd:
 .PHONY: generate
 generate:
 	@go generate ./...
-	@echo "(map compile '[glojure.core glojure.core.async glojure.walk glojure.template])" | \
-		GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run ./cmd/glj
+	@echo "(map compile '[glojure.core glojure.go.io glojure.core.async glojure.walk glojure.template glojure.go.types glojure.uuid])" | \
+		GLOJURE_USE_AOT=false GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run ./cmd/glj
 
 .PHONY: build
 build: $(GLJ)

pkg/glj/init.go

@@ -8,6 +8,12 @@ import (
 	_ "github.com/glojurelang/glojure/pkg/gen/gljimports"
 	"github.com/glojurelang/glojure/pkg/lang"
 
+	// Add NS loaders for the standard library.
+	_ "github.com/glojurelang/glojure/pkg/stdlib/glojure/core"
+	_ "github.com/glojurelang/glojure/pkg/stdlib/glojure/core/async"
+	_ "github.com/glojurelang/glojure/pkg/stdlib/glojure/go/io"
+	_ "github.com/glojurelang/glojure/pkg/stdlib/glojure/protocols"
+
 	"github.com/glojurelang/glojure/pkg/runtime"
 )
 

pkg/gljmain/gljmain.go

@@ -10,10 +10,6 @@ import (
 	// bootstrap the runtime
 	_ "github.com/glojurelang/glojure/pkg/glj"
 
-	_ "github.com/glojurelang/glojure/pkg/stdlib/glojure/core"
-	_ "github.com/glojurelang/glojure/pkg/stdlib/glojure/core/async"
-	_ "github.com/glojurelang/glojure/pkg/stdlib/glojure/protocols"
-
 	"github.com/glojurelang/glojure/pkg/lang"
 	"github.com/glojurelang/glojure/pkg/reader"
 	"github.com/glojurelang/glojure/pkg/repl"

pkg/runtime/codegen.go

@@ -144,7 +144,9 @@ func (g *Generator) Generate(ns *lang.Namespace) error {
 		second, _ := lang.Nth(entry, 1)
 		vr, ok := second.(*lang.Var)
 		if !ok {
-			panic(fmt.Sprintf("expected var, got %T", second))
+			continue // skip non-var mappings
+			// TODO: handle non-var mappings like direct references to functions or values
+			// panic(fmt.Sprintf("can't codegen %v: expected var, got %T (%v)", name, second, second))
 		}
 
 		if !(vr.Namespace() == ns && lang.Equals(vr.Symbol(), name)) {
@@ -402,7 +404,14 @@ func (g *Generator) generateVar(nsVariableName string, name *lang.Symbol, vr *la
 
 	// check if the var has a value
 	if vr.IsBound() {
-		g.writef("%s = %s.InternWithValue(%s, %s, true)\n", varVar, nsVariableName, varSym, g.generateValue(vr.Get()))
+		// we call Get() on a new goroutine to ensure we get the root value in the case
+		// of dynamic vars
+		valChan := make(chan any)
+		go func() {
+			valChan <- vr.Get()
+		}()
+		v := <-valChan
+		g.writef("%s = %s.InternWithValue(%s, %s, true)\n", varVar, nsVariableName, varSym, g.generateValue(v))
 	} else {
 		g.writef("%s = %s.Intern(%s)\n", varVar, nsVariableName, varSym)
 	}

pkg/runtime/envinit.go

@@ -117,6 +117,14 @@ func NewEnvironment(opts ...EvalOption) lang.Environment {
 	// Add stdlib
 	RT.Load("glojure/core")
 
+	// Workaround to ensure namespaces that are required by core are loaded.
+	// TODO: AOT should identify this dependency and generate code to load it.
+	if useAot {
+		RT.Load("glojure/core/protocols")
+		RT.Load("glojure/string")
+		RT.Load("glojure/go/io")
+	}
+
 	// Set the glojure version
 	core := lang.FindNamespace(lang.NewSymbol("glojure.core"))
 	versionVar := core.FindInternedVar(lang.NewSymbol("*glojure-version*"))

pkg/runtime/evalast.go

@@ -204,7 +204,9 @@ func (env *environment) EvalASTTheVar(n *ast.Node) (interface{}, error) {
 	return n.Sub.(*ast.TheVarNode).Var, nil
 }
 
-// TODO: this is a bit of a mess
+// TODO: fix up, as this is a bit of a mess. This is a compatibility
+// layer to make certain uses of Clojure Compiler methods work in
+// core.
 type evalCompiler struct{}
 
 var (
@@ -261,22 +263,9 @@ func (env *environment) EvalASTMaybeClass(n *ast.Node) (interface{}, error) {
 func (env *environment) EvalASTMaybeHostForm(n *ast.Node) (interface{}, error) {
 	hostFormNode := n.Sub.(*ast.MaybeHostFormNode)
 	field := hostFormNode.Field
-	// TODO: implement this for real
-	switch hostFormNode.Class {
-	case "glojure.lang.PersistentTreeSet":
-		switch field.Name() {
-		case "create":
-			return func(keys interface{}) interface{} {
-				var ks []interface{}
-				for seq := lang.Seq(keys); seq != nil; seq = seq.Next() {
-					ks = append(ks, seq.First())
-				}
-				return lang.NewSet(ks...)
-			}, nil
-		}
-	}
 
-	// TODO: how to handle?
+	// TODO: should we support any version of this? Go doesn't have any notion of static
+	// vs instance fields.
 	panic("EvalASTMaybeHostForm: " + hostFormNode.Class + "/" + field.Name())
 }
 

pkg/runtime/rtcompat.go

@@ -212,6 +212,13 @@ func compileNSToFile(fs fs.FS, scriptBase string) {
 	var buf bytes.Buffer
 	gen := NewGenerator(&buf)
 	currNS := VarCurrentNS.Deref().(*lang.Namespace)
+	// only generate if the namespace has a name that matches the scriptBase
+	nsName := strings.ReplaceAll(scriptBase, string(os.PathSeparator), ".")
+	if currNS.Name().Name() != nsName {
+		fmt.Printf("Skipping code generation for namespace %s: does not match script base %s\n", currNS.Name(), nsName)
+		return
+	}
+
 	if err = gen.Generate(currNS); err != nil {
 		panic(fmt.Errorf("failed to generate code for namespace %s: %w", currNS.Name(), err))
 	}