Retain clojure.* name for standard namespaces

Makefile

@@ -4,7 +4,7 @@ STDLIB_ORIGINALS_DIR := scripts/rewrite-core/originals
 STDLIB_ORIGINALS := $(shell find $(STDLIB_ORIGINALS_DIR) -name '*.clj')
 STDLIB := $(STDLIB_ORIGINALS:scripts/rewrite-core/originals/%=%)
 STDLIB_ORIGINALS := $(addprefix scripts/rewrite-core/originals/,$(STDLIB))
-STDLIB_TARGETS := $(addprefix pkg/stdlib/glojure/,$(STDLIB:.clj=.glj))
+STDLIB_TARGETS := $(addprefix pkg/stdlib/clojure/,$(STDLIB:.clj=.glj))
 
 OS-TYPE := $(shell bash -c 'echo $$OSTYPE')
 OS-NAME := \
@@ -41,19 +41,22 @@ GO_VERSION := 1.19.3
 GO_CMD := go$(GO_VERSION)
 
 .PHONY: all
-all: gocmd $(STDLIB_TARGETS) generate $(GLJIMPORTS) $(BINS)
+all: gocmd $(STDLIB_TARGETS) go-generate aot $(GLJIMPORTS) $(BINS)
 
 .PHONY: gocmd
 gocmd:
 	@$(GO_CMD) version 2>&1 > /dev/null || \
 		(go install "golang.org/dl/$(GO_CMD)@latest" && \
 		$(GO_CMD) download > /dev/null && $(GO_CMD) version > /dev/null)
 
-.PHONY: generate
+.PHONY: go-generate
 generate:
 	@go generate ./...
-	@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: aot
+aot: gocmd $(STDLIB_TARGETS)
+	@echo "(map compile '[clojure.core clojure.core.async clojure.walk clojure.template clojure.uuid glojure.go.types glojure.go.io])" | \
+		GLOJURE_USE_AOT=false GLOJURE_STDLIB_PATH=./pkg/stdlib $(GO_CMD) run -tags glj_no_aot_stdlib ./cmd/glj
 
 .PHONY: build
 build: $(GLJ)
@@ -67,7 +70,7 @@ pkg/gen/gljimports/gljimports_%.go: ./scripts/gen-gljimports.sh ./cmd/gen-import
 	@echo "Generating $@"
 	@./scripts/gen-gljimports.sh $@ $* $(GO_CMD)
 
-pkg/stdlib/glojure/%.glj: scripts/rewrite-core/originals/%.clj scripts/rewrite-core/run.sh scripts/rewrite-core/rewrite.clj
+pkg/stdlib/clojure/%.glj: scripts/rewrite-core/originals/%.clj scripts/rewrite-core/run.sh scripts/rewrite-core/rewrite.clj
 	@echo "Rewriting $< to $@"
 	@mkdir -p $(dir $@)
 	@scripts/rewrite-core/run.sh $< > $@

pkg/glj/glj_test.go

@@ -7,8 +7,8 @@ import (
 )
 
 func TestGLJ(t *testing.T) {
-	mp := Var("glojure.core", "map")
-	inc := Var("glojure.core", "inc")
+	mp := Var("clojure.core", "map")
+	inc := Var("clojure.core", "inc")
 	res := lang.PrintString(mp.Invoke(inc, Read("[1 2 3]")))
 	if res != "(2 3 4)" {
 		t.Errorf("Expected (2 3 4), got %v", res)

pkg/glj/init-aot.go

@@ -4,8 +4,8 @@ package glj
 
 import (
 	// 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/clojure/core"
+	_ "github.com/glojurelang/glojure/pkg/stdlib/clojure/core/async"
+	_ "github.com/glojurelang/glojure/pkg/stdlib/clojure/core/protocols"
 	_ "github.com/glojurelang/glojure/pkg/stdlib/glojure/go/io"
-	_ "github.com/glojurelang/glojure/pkg/stdlib/glojure/protocols"
 )

pkg/gljmain/gljmain.go

@@ -57,7 +57,7 @@ func Main(args []string) {
 		env := lang.GlobalEnv
 
 		// Set command line args (everything after -e and the expression)
-		core := lang.FindNamespace(lang.NewSymbol("glojure.core"))
+		core := lang.FindNamespace(lang.NewSymbol("clojure.core"))
 		core.FindInternedVar(lang.NewSymbol("*command-line-args*")).BindRoot(lang.Seq(args[2:]))
 
 		rdr := reader.New(strings.NewReader(expr), reader.WithGetCurrentNS(func() *lang.Namespace {
@@ -90,7 +90,7 @@ func Main(args []string) {
 		}
 		env := lang.GlobalEnv
 
-		core := lang.FindNamespace(lang.NewSymbol("glojure.core"))
+		core := lang.FindNamespace(lang.NewSymbol("clojure.core"))
 		core.FindInternedVar(lang.NewSymbol("*command-line-args*")).BindRoot(lang.Seq(args[1:]))
 
 		rdr := reader.New(bufio.NewReader(file), reader.WithGetCurrentNS(func() *lang.Namespace {

pkg/lang/namespace.go

@@ -21,7 +21,7 @@ type Namespace struct {
 }
 
 var (
-	SymbolCoreNamespace = NewSymbol("glojure.core")
+	SymbolCoreNamespace = NewSymbol("clojure.core")
 
 	namespaces = map[string]*Namespace{}
 	nsMtx      sync.RWMutex
@@ -60,8 +60,8 @@ func FindOrCreateNamespace(sym *Symbol) *Namespace {
 }
 
 func RemoveNamespace(sym *Symbol) {
-	if sym.String() == "glojure.core" {
-		panic(errors.New("cannot remove glojure.core namespace"))
+	if sym.String() == "clojure.core" {
+		panic(errors.New("cannot remove clojure.core namespace"))
 	}
 
 	nsMtx.Lock()

pkg/reader/reader.go

@@ -15,11 +15,11 @@ import (
 
 var (
 	symQuote         = lang.NewSymbol("quote")
-	symList          = lang.NewSymbol("glojure.core/list")
-	symSeq           = lang.NewSymbol("glojure.core/seq")
-	symConcat        = lang.NewSymbol("glojure.core/concat")
-	symUnquote       = lang.NewSymbol("glojure.core/unquote")
-	symSpliceUnquote = lang.NewSymbol("glojure.core/splice-unquote")
+	symList          = lang.NewSymbol("clojure.core/list")
+	symSeq           = lang.NewSymbol("clojure.core/seq")
+	symConcat        = lang.NewSymbol("clojure.core/concat")
+	symUnquote       = lang.NewSymbol("clojure.core/unquote")
+	symSpliceUnquote = lang.NewSymbol("clojure.core/splice-unquote")
 
 	specials = func() map[string]bool {
 		specialStrs := []string{
@@ -34,7 +34,7 @@ var (
 			"fn*",
 			"quote",
 			"var",
-			"glojure.core/import*",
+			"clojure.core/import*",
 			".",
 			"set!",
 			"deftype*",
@@ -802,12 +802,12 @@ func (r *Reader) syntaxQuote(symbolNameMap map[string]*lang.Symbol, node interfa
 			keyvals = append(keyvals, entry.Key(), entry.Val())
 		}
 		return lang.NewList(
-			lang.NewSymbol("glojure.core/apply"),
-			lang.NewSymbol("glojure.core/hash-map"),
+			lang.NewSymbol("clojure.core/apply"),
+			lang.NewSymbol("clojure.core/hash-map"),
 			lang.NewList(
-				lang.NewSymbol("glojure.core/seq"),
+				lang.NewSymbol("clojure.core/seq"),
 				lang.NewCons(
-					lang.NewSymbol("glojure.core/concat"),
+					lang.NewSymbol("clojure.core/concat"),
 					r.sqExpandList(symbolNameMap, keyvals),
 				),
 			),
@@ -816,14 +816,14 @@ func (r *Reader) syntaxQuote(symbolNameMap map[string]*lang.Symbol, node interfa
 		_, isVector := node.(lang.IPersistentVector)
 		if lang.Count(node) == 0 {
 			if isVector {
-				//(glojure.core/apply glojure.core/vector (glojure.core/seq (glojure.core/concat)))
+				//(clojure.core/apply clojure.core/vector (clojure.core/seq (clojure.core/concat)))
 				return lang.NewList(
-					lang.NewSymbol("glojure.core/apply"),
-					lang.NewSymbol("glojure.core/vector"),
+					lang.NewSymbol("clojure.core/apply"),
+					lang.NewSymbol("clojure.core/vector"),
 					lang.NewList(
-						lang.NewSymbol("glojure.core/seq"),
+						lang.NewSymbol("clojure.core/seq"),
 						lang.NewList(
-							lang.NewSymbol("glojure.core/concat"),
+							lang.NewSymbol("clojure.core/concat"),
 						),
 					),
 				)
@@ -848,8 +848,8 @@ func (r *Reader) syntaxQuote(symbolNameMap map[string]*lang.Symbol, node interfa
 			lang.NewList(elements...))
 		if isVector {
 			ret = lang.NewList(
-				lang.NewSymbol("glojure.core/apply"),
-				lang.NewSymbol("glojure.core/vector"),
+				lang.NewSymbol("clojure.core/apply"),
+				lang.NewSymbol("clojure.core/vector"),
 				ret)
 		}
 		return ret
@@ -861,11 +861,11 @@ func (r *Reader) sqExpandList(symbolNameMap map[string]*lang.Symbol, els []inter
 	var ret lang.IPersistentVector = lang.NewVector()
 	for _, v := range els {
 		if r.isUnquote(v) {
-			ret = ret.Cons(lang.NewList(lang.NewSymbol("glojure.core/list"), lang.First(lang.Rest(v)))).(lang.IPersistentVector)
+			ret = ret.Cons(lang.NewList(lang.NewSymbol("clojure.core/list"), lang.First(lang.Rest(v)))).(lang.IPersistentVector)
 		} else if r.isUnquoteSplicing(v) {
 			ret = ret.Cons(lang.First(lang.Rest(v))).(lang.IPersistentVector)
 		} else {
-			ret = ret.Cons(lang.NewList(lang.NewSymbol("glojure.core/list"), r.syntaxQuote(symbolNameMap, v))).(lang.IPersistentVector)
+			ret = ret.Cons(lang.NewList(lang.NewSymbol("clojure.core/list"), r.syntaxQuote(symbolNameMap, v))).(lang.IPersistentVector)
 		}
 	}
 	return lang.Seq(ret)
@@ -883,8 +883,8 @@ func (r *Reader) isUnquoteSplicing(form interface{}) bool {
 
 func (r *Reader) readDeref() (interface{}, error) {
 	// TODO: look up 'deref' with the symbol resolver
-	// it should resolve to glojure.core/deref in the go case
-	return r.readQuoteType("glojure.core/deref")
+	// it should resolve to clojure.core/deref in the go case
+	return r.readQuoteType("clojure.core/deref")
 }
 
 func (r *Reader) readUnquote() (interface{}, error) {
@@ -893,11 +893,11 @@ func (r *Reader) readUnquote() (interface{}, error) {
 		return nil, r.error("error reading input: %w", err)
 	}
 	if rn == '@' {
-		return r.readQuoteType("glojure.core/splice-unquote")
+		return r.readQuoteType("clojure.core/splice-unquote")
 	}
 
 	r.rs.UnreadRune()
-	return r.readQuoteType("glojure.core/unquote")
+	return r.readQuoteType("clojure.core/unquote")
 }
 
 func (r *Reader) readDispatch() (interface{}, error) {

pkg/reader/testdata/reader/quasiquote00.out

@@ -1,8 +1,8 @@
 (quote user/foobar)
-(glojure.core/list)
-(glojure.core/seq (glojure.core/concat (glojure.core/list (quote user/a)) (glojure.core/list (quote user/b)) (glojure.core/list (quote user/c))))
-(glojure.core/seq (glojure.core/concat (glojure.core/list (quote user/a)) (glojure.core/list (+ 1 2))))
-(glojure.core/seq (glojure.core/concat (glojure.core/list (quote user/a)) [(+ 1 2)]))
-(glojure.core/seq (glojure.core/concat (glojure.core/list (quote do.not.Qualify))))
-(glojure.core/apply glojure.core/hash-map (glojure.core/seq (glojure.core/concat (glojure.core/list :x) (glojure.core/list []))))
-(glojure.core/seq (glojure.core/concat (glojure.core/list (quote resolved.alias/foo))))
+(clojure.core/list)
+(clojure.core/seq (clojure.core/concat (clojure.core/list (quote user/a)) (clojure.core/list (quote user/b)) (clojure.core/list (quote user/c))))
+(clojure.core/seq (clojure.core/concat (clojure.core/list (quote user/a)) (clojure.core/list (+ 1 2))))
+(clojure.core/seq (clojure.core/concat (clojure.core/list (quote user/a)) [(+ 1 2)]))
+(clojure.core/seq (clojure.core/concat (clojure.core/list (quote do.not.Qualify))))
+(clojure.core/apply clojure.core/hash-map (clojure.core/seq (clojure.core/concat (clojure.core/list :x) (clojure.core/list []))))
+(clojure.core/seq (clojure.core/concat (clojure.core/list (quote resolved.alias/foo))))

pkg/runtime/codegen.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"go/format"
 	"io"
+	"path/filepath"
 	"reflect"
 	"sort"
 	"strings"
@@ -84,9 +85,9 @@ type Generator struct {
 var (
 	omittedVars = map[string]bool{
 		// initialized by the runtime
-		"#'glojure.core/*in*":            true,
-		"#'glojure.core/*out*":           true,
-		"#'glojure.core/*compile-files*": true,
+		"#'clojure.core/*in*":            true,
+		"#'clojure.core/*out*":           true,
+		"#'clojure.core/*compile-files*": true,
 	}
 )
 
@@ -203,9 +204,7 @@ func (g *Generator) Generate(ns *lang.Namespace) error {
 	var initBuf bytes.Buffer
 	{
 		// Reproduce the behavior of root-resource function
-		rootResourceName := ns.Name().String()
-		rootResourceName = strings.ReplaceAll(rootResourceName, "-", "_")
-		rootResourceName = strings.ReplaceAll(rootResourceName, ".", "/")
+		rootResourceName := nsToPath(ns.Name().String())
 		initBuf.WriteString(`func init() {
 runtime.RegisterNSLoader(` + fmt.Sprintf("%q", rootResourceName) + `, LoadNS)
 }
@@ -1562,8 +1561,8 @@ var (
 	expectedInvalidImports = map[string]bool{
 		"ExceptionInfo":                            true,
 		"LinkedBlockingQueue":                      true,
-		"glojure.lang.LineNumberingPushbackReader": true,
-		"glojure.lang":                             true,
+		"clojure.lang.LineNumberingPushbackReader": true,
+		"clojure.lang":                             true,
 		"java.io.InputStreamReader":                true,
 		"java.io.StringReader":                     true,
 		"java.util.concurrent.CountDownLatch":      true,
@@ -2125,8 +2124,8 @@ var (
 )
 
 func isRuntimeOwnedVar(v *lang.Var) bool {
-	// namespace must be glojure.core
-	if v.Namespace().Name().Name() != "glojure.core" {
+	// namespace must be clojure.core
+	if v.Namespace().Name().Name() != "clojure.core" {
 		return false
 	}
 
@@ -2195,3 +2194,21 @@ func nodeRecurs(n *ast.Node, loopID string) bool {
 
 	return false
 }
+
+func pathToNS(path string) string {
+	// remove file extension if present
+	if ext := filepath.Ext(path); ext != "" {
+		path = path[:len(path)-len(ext)]
+	}
+	path = strings.ReplaceAll(path, "_", "-")
+	path = strings.ReplaceAll(path, "/", ".")
+	return path
+}
+
+func nsToPath(ns string) string {
+	// replace dashes with underscores
+	ns = strings.ReplaceAll(ns, "-", "_")
+	// replace dots with slashes
+	ns = strings.ReplaceAll(ns, ".", "/")
+	return ns
+}

pkg/runtime/codegen_test.go

@@ -52,7 +52,7 @@ func TestCodegen(t *testing.T) {
 				nsName = strings.ReplaceAll(nsName, ".", "-")
 			}
 
-			require := glj.Var("glojure.core", "require")
+			require := glj.Var("clojure.core", "require")
 			runtime.AddLoadPath(os.DirFS("testdata"))
 			// Load the namespace
 			require.Invoke(lang.NewSymbol(nsName))
@@ -67,11 +67,11 @@ func TestCodegen(t *testing.T) {
 		})
 	}
 
-	t.Run("glojure.core", func(t *testing.T) {
+	t.Run("clojure.core", func(t *testing.T) {
 		// Test the core namespace
-		ns := lang.FindNamespace(lang.NewSymbol("glojure.core"))
+		ns := lang.FindNamespace(lang.NewSymbol("clojure.core"))
 		if ns == nil {
-			t.Fatal("glojure.core namespace not found")
+			t.Fatal("clojure.core namespace not found")
 		}
 
 		if err := os.MkdirAll("testdata/codegen/test/core", 0755); err != nil {
@@ -138,7 +138,7 @@ func generateAndTestNamespace(t *testing.T, ns *lang.Namespace, goldenFile strin
 		// run go vet on the temp file with .go extension
 		// - two exceptions: core and try_basic generate unreachable code
 		// TODO: fix the code generation to avoid unreachable code
-		if ns.Name().String() == "glojure.core" || ns.Name().String() == "codegen.test.try-basic" {
+		if ns.Name().String() == "clojure.core" || ns.Name().String() == "codegen.test.try-basic" {
 			t.Logf("skipping go vet for %s", goldenFile)
 			return
 		}

pkg/runtime/envinit.go

@@ -115,18 +115,18 @@ func NewEnvironment(opts ...EvalOption) lang.Environment {
 	}
 
 	// Add stdlib
-	RT.Load("glojure/core")
+	RT.Load("clojure/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/protocols")
-		RT.Load("glojure/string")
+		RT.Load("clojure/protocols")
+		RT.Load("clojure/string")
 		RT.Load("glojure/go/io")
 	}
 
 	// Set the glojure version
-	core := lang.FindNamespace(lang.NewSymbol("glojure.core"))
+	core := lang.FindNamespace(lang.NewSymbol("clojure.core"))
 	versionVar := core.FindInternedVar(lang.NewSymbol("*glojure-version*"))
 	if versionVar != nil {
 		versionVar.BindRoot(ParseVersion(VERSION))

pkg/runtime/environment.go

@@ -12,7 +12,7 @@ import (
 )
 
 var (
-	SymbolUnquote       = lang.NewSymbol("clojure.core/unquote") // TODO: rename to glojure.core/unquote
+	SymbolUnquote       = lang.NewSymbol("clojure.core/unquote")
 	SymbolSpliceUnquote = lang.NewSymbol("splice-unquote")
 	SymbolNamespace     = lang.NewSymbol("ns")
 	SymbolInNamespace   = lang.NewSymbol("in-ns")