Namespace.get_or_create should not auto-refer 'basilisp.core (#481)

* EDN Reader

* Revert incorrect changes

* No EDN

* Types

* But this

* This is a nightmare

* Remove unused runtime function

* Changelog

* Type fix

* Remove unused PyTest fixture usages

* Fix up the generator

* Fix the CLI

* Test running with subprocess as well

* Ok fine this doesn't work

* Emit directly to the Namespace `*generated-python*`

* Order the args better

Author: chrisrink10

CHANGELOG.md

@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Change the default user namespace to `basilisp.user` (#466)
  * Changed multi-methods to use a `threading.Lock` internally rather than an Atom (#478)
  * Changed the Basilisp module type from `types.ModuleType` to a custom subtype with support for custom attributes (#482)
+ * Basilisp's runtime function `Namespace.get_or_create` no longer refers `basilisp.core` by default, which allows callers to exclude `basilisp.core` names in the `ns` macro (#481)
 
 ### Fixed
  * Fixed a reader bug where no exception was being thrown splicing reader conditional forms appeared outside of valid splicing contexts (#470)

src/basilisp/cli.py

@@ -11,11 +11,11 @@
 import basilisp.lang.runtime as runtime
 import basilisp.lang.symbol as sym
 import basilisp.main as basilisp
-from basilisp.lang.typing import BasilispModule
 from basilisp.prompt import get_prompter
 
 CLI_INPUT_FILE_PATH = "<CLI Input>"
 REPL_INPUT_FILE_PATH = "<REPL Input>"
+REPL_NS = "basilisp.repl"
 STDIN_INPUT_FILE_PATH = "<stdin>"
 STDIN_FILE_NAME = "-"
 
@@ -25,41 +25,43 @@ def cli():
     """Basilisp is a Lisp dialect inspired by Clojure targeting Python 3."""
 
 
-def eval_file(filename: str, ctx: compiler.CompilerContext, module: BasilispModule):
+def eval_file(filename: str, ctx: compiler.CompilerContext, ns: runtime.Namespace):
     """Evaluate a file with the given name into a Python module AST node."""
     last = None
     for form in reader.read_file(filename, resolver=runtime.resolve_alias):
         assert not isinstance(form, reader.ReaderConditional)
-        last = compiler.compile_and_exec_form(form, ctx, module)
+        last = compiler.compile_and_exec_form(form, ctx, ns)
     return last
 
 
-def eval_stream(stream, ctx: compiler.CompilerContext, module: BasilispModule):
+def eval_stream(stream, ctx: compiler.CompilerContext, ns: runtime.Namespace):
     """Evaluate the forms in stdin into a Python module AST node."""
     last = None
     for form in reader.read(stream, resolver=runtime.resolve_alias):
         assert not isinstance(form, reader.ReaderConditional)
-        last = compiler.compile_and_exec_form(form, ctx, module)
+        last = compiler.compile_and_exec_form(form, ctx, ns)
     return last
 
 
-def eval_str(s: str, ctx: compiler.CompilerContext, module: BasilispModule, eof: Any):
+def eval_str(s: str, ctx: compiler.CompilerContext, ns: runtime.Namespace, eof: Any):
     """Evaluate the forms in a string into a Python module AST node."""
     last = eof
     for form in reader.read_str(s, resolver=runtime.resolve_alias, eof=eof):
         assert not isinstance(form, reader.ReaderConditional)
-        last = compiler.compile_and_exec_form(form, ctx, module)
+        last = compiler.compile_and_exec_form(form, ctx, ns)
     return last
 
 
 def bootstrap_repl(which_ns: str) -> types.ModuleType:
-    """Bootstrap the REPL with a few useful vars and returned the
-    bootstrapped module so it's functions can be used by the REPL
-    command."""
-    repl_ns = runtime.Namespace.get_or_create(sym.symbol("basilisp.repl"))
+    """Bootstrap the REPL with a few useful vars and returned the bootstrapped
+    module so it's functions can be used by the REPL command."""
+    repl_ns = runtime.Namespace.get_or_create(sym.symbol(REPL_NS))
     ns = runtime.Namespace.get_or_create(sym.symbol(which_ns))
-    repl_module = importlib.import_module("basilisp.repl")
-    ns.add_alias(sym.symbol("basilisp.repl"), repl_ns)
+    core_ns = runtime.Namespace.get(sym.symbol(runtime.CORE_NS))
+    assert core_ns is not None
+    ns.refer_all(core_ns)
+    repl_module = importlib.import_module(REPL_NS)
+    ns.add_alias(sym.symbol(REPL_NS), repl_ns)
     ns.refer_all(repl_ns)
     return repl_module
 
@@ -133,7 +135,7 @@ def repl(
             continue
 
         try:
-            result = eval_str(lsrc, ctx, ns.module, eof)
+            result = eval_str(lsrc, ctx, ns, eof)
             if result is eof:  # pragma: no cover
                 continue
             prompter.print(runtime.lrepr(result))
@@ -214,17 +216,18 @@ def run(  # pylint: disable=too-many-arguments
     )
     eof = object()
 
+    core_ns = runtime.Namespace.get(sym.symbol(runtime.CORE_NS))
+    assert core_ns is not None
+
     with runtime.ns_bindings(in_ns) as ns:
+        ns.refer_all(core_ns)
+
         if code:
-            print(runtime.lrepr(eval_str(file_or_code, ctx, ns.module, eof)))
+            print(runtime.lrepr(eval_str(file_or_code, ctx, ns, eof)))
         elif file_or_code == STDIN_FILE_NAME:
-            print(
-                runtime.lrepr(
-                    eval_stream(click.get_text_stream("stdin"), ctx, ns.module)
-                )
-            )
+            print(runtime.lrepr(eval_stream(click.get_text_stream("stdin"), ctx, ns)))
         else:
-            print(runtime.lrepr(eval_file(file_or_code, ctx, ns.module)))
+            print(runtime.lrepr(eval_file(file_or_code, ctx, ns)))
 
 
 @cli.command(short_help="run tests in a Basilisp project")

src/basilisp/core.lpy

@@ -3191,11 +3191,10 @@
 (defn eval
   "Evaluate a form (not a string) and return its result."
   [form]
-  (let [ctx    (basilisp.lang.compiler.CompilerContext. "<Eval Input>")
-        module (.-module *ns*)]
+  (let [ctx (basilisp.lang.compiler.CompilerContext. "<Eval Input>")]
     (basilisp.lang.compiler/compile-and-exec-form form
                                                   ctx
-                                                  module)))
+                                                  *ns*)))
 
 ;;;;;;;;;;;;;;;;;;;
 ;; Ref Utilities ;;
@@ -3527,6 +3526,7 @@
   Example:
     (ns my.namespace
        \"My namespace with code\"
+       (:refer-basilisp :exclude [get])
        (:require
          [basilisp.string :as str])
        (:import inspect))"
@@ -3548,14 +3548,16 @@
                        {}
                        opts))
 
-        requires (when (:require opts)
-                   `(require ~@(map #(list 'quote %) (:require opts))))
-        imports  (when (:import opts)
-                   (map (fn [v]
-                          `(import ~v))
-                        (:import opts)))]
+        requires    (when (:require opts)
+                      `(require ~@(map #(list 'quote %) (:require opts))))
+        imports     (when (:import opts)
+                      (map (fn [v]
+                             `(import ~v))
+                           (:import opts)))]
     `(do
        (in-ns (quote ~name))
+       (refer-basilisp ~@(or (:refer-basilisp opts)
+                             (:refer-clojure opts)))
        ~requires
        ~@imports)))
 

src/basilisp/importer.py

@@ -13,6 +13,7 @@
 import basilisp.lang.compiler as compiler
 import basilisp.lang.reader as reader
 import basilisp.lang.runtime as runtime
+import basilisp.lang.symbol as sym
 from basilisp.lang.typing import BasilispModule, ReaderForm
 from basilisp.lang.util import demunge
 from basilisp.util import timed
@@ -232,7 +233,7 @@ def _exec_cached_module(
         fullname: str,
         loader_state: Mapping[str, str],
         path_stats: Mapping[str, int],
-        module: BasilispModule,
+        ns: runtime.Namespace,
     ):
         """Load and execute a cached Basilisp module."""
         filename = loader_state["filename"]
@@ -252,15 +253,15 @@ def _exec_cached_module(
                 cached_code,
                 compiler.GeneratorContext(filename=filename),
                 compiler.PythonASTOptimizer(),
-                module,
+                ns,
             )
 
     def _exec_module(
         self,
         fullname: str,
         loader_state: Mapping[str, str],
         path_stats: Mapping[str, int],
-        module: BasilispModule,
+        ns: runtime.Namespace,
     ):
         """Load and execute a non-cached Basilisp module."""
         filename = loader_state["filename"]
@@ -290,7 +291,7 @@ def add_bytecode(bytecode: types.CodeType):
             compiler.compile_module(  # pylint: disable=unexpected-keyword-arg
                 forms,
                 compiler.CompilerContext(filename=filename),
-                module,
+                ns,
                 collect_bytecode=add_bytecode,
             )
 
@@ -321,21 +322,19 @@ def exec_module(self, module):
         # generating, then we will not be able to use advanced compilation features such
         # as direct Python variable access to functions and other def'ed values.
         ns_name = demunge(fullname)
-        ns: runtime.Namespace = runtime.set_current_ns(ns_name).value
+        ns: runtime.Namespace = runtime.Namespace.get_or_create(sym.symbol(ns_name))
         ns.module = module
 
         # Check if a valid, cached version of this Basilisp namespace exists and, if so,
         # load it and bypass the expensive compilation process below.
         if os.getenv(_NO_CACHE_ENVVAR, None) == "true":
-            self._exec_module(fullname, spec.loader_state, path_stats, module)
+            self._exec_module(fullname, spec.loader_state, path_stats, ns)
         else:
             try:
-                self._exec_cached_module(
-                    fullname, spec.loader_state, path_stats, module
-                )
+                self._exec_cached_module(fullname, spec.loader_state, path_stats, ns)
             except (EOFError, ImportError, IOError, OSError) as e:
                 logger.debug(f"Failed to load cached Basilisp module: {e}")
-                self._exec_module(fullname, spec.loader_state, path_stats, module)
+                self._exec_module(fullname, spec.loader_state, path_stats, ns)
 
         # Because we want to (by default) add 'basilisp.core into every namespace by default,
         # we want to make sure we don't try to add 'basilisp.core into itself, causing a

src/basilisp/lang/compiler/__init__.py

@@ -28,7 +28,7 @@
     statementize as _statementize,
 )
 from basilisp.lang.compiler.optimizer import PythonASTOptimizer
-from basilisp.lang.typing import BasilispModule, ReaderForm
+from basilisp.lang.typing import ReaderForm
 from basilisp.lang.util import genname
 
 _DEFAULT_FN = "__lisp_expr__"
@@ -69,7 +69,9 @@ def py_ast_optimizer(self) -> PythonASTOptimizer:
         return self._optimizer
 
 
-def _emit_ast_string(module: ast.AST) -> None:  # pragma: no cover
+def _emit_ast_string(
+    ns: runtime.Namespace, module: ast.AST,
+) -> None:  # pragma: no cover
     """Emit the generated Python AST string either to standard out or to the
     *generated-python* dynamic Var for the current namespace. If the
     BASILISP_EMIT_GENERATED_PYTHON env var is not set True, this method is a
@@ -83,13 +85,13 @@ def _emit_ast_string(module: ast.AST) -> None:  # pragma: no cover
     if runtime.print_generated_python():
         print(to_py_str(module))
     else:
-        runtime.add_generated_python(to_py_str(module))
+        runtime.add_generated_python(to_py_str(module), which_ns=ns)
 
 
 def compile_and_exec_form(  # pylint: disable= too-many-arguments
     form: ReaderForm,
     ctx: CompilerContext,
-    module: BasilispModule,
+    ns: runtime.Namespace,
     wrapped_fn_name: str = _DEFAULT_FN,
     collect_bytecode: Optional[BytecodeCollector] = None,
 ) -> Any:
@@ -101,8 +103,8 @@ def compile_and_exec_form(  # pylint: disable= too-many-arguments
     if form is None:
         return None
 
-    if not module.__basilisp_bootstrapped__:
-        _bootstrap_module(ctx.generator_context, ctx.py_ast_optimizer, module)
+    if not ns.module.__basilisp_bootstrapped__:
+        _bootstrap_module(ctx.generator_context, ctx.py_ast_optimizer, ns)
 
     final_wrapped_name = genname(wrapped_fn_name)
 
@@ -122,19 +124,19 @@ def compile_and_exec_form(  # pylint: disable= too-many-arguments
     ast_module = ctx.py_ast_optimizer.visit(ast_module)
     ast.fix_missing_locations(ast_module)
 
-    _emit_ast_string(ast_module)
+    _emit_ast_string(ns, ast_module)
 
     bytecode = compile(ast_module, ctx.filename, "exec")
     if collect_bytecode:
         collect_bytecode(bytecode)
-    exec(bytecode, module.__dict__)
-    return getattr(module, final_wrapped_name)()
+    exec(bytecode, ns.module.__dict__)
+    return getattr(ns.module, final_wrapped_name)()
 
 
 def _incremental_compile_module(
     optimizer: PythonASTOptimizer,
     py_ast: GeneratedPyAST,
-    mod: BasilispModule,
+    ns: runtime.Namespace,
     source_filename: str,
     collect_bytecode: Optional[BytecodeCollector] = None,
 ) -> None:
@@ -152,35 +154,35 @@ def _incremental_compile_module(
     module = optimizer.visit(module)
     ast.fix_missing_locations(module)
 
-    _emit_ast_string(module)
+    _emit_ast_string(ns, module)
 
     bytecode = compile(module, source_filename, "exec")
     if collect_bytecode:
         collect_bytecode(bytecode)
-    exec(bytecode, mod.__dict__)
+    exec(bytecode, ns.module.__dict__)
 
 
 def _bootstrap_module(
     gctx: GeneratorContext,
     optimizer: PythonASTOptimizer,
-    mod: BasilispModule,
+    ns: runtime.Namespace,
     collect_bytecode: Optional[BytecodeCollector] = None,
 ) -> None:
     """Bootstrap a new module with imports and other boilerplate."""
     _incremental_compile_module(
         optimizer,
-        py_module_preamble(gctx),
-        mod,
+        py_module_preamble(ns),
+        ns,
         source_filename=gctx.filename,
         collect_bytecode=collect_bytecode,
     )
-    mod.__basilisp_bootstrapped__ = True
+    ns.module.__basilisp_bootstrapped__ = True
 
 
 def compile_module(
     forms: Iterable[ReaderForm],
     ctx: CompilerContext,
-    module: BasilispModule,
+    ns: runtime.Namespace,
     collect_bytecode: Optional[BytecodeCollector] = None,
 ) -> None:
     """Compile an entire Basilisp module into Python bytecode which can be
@@ -190,7 +192,7 @@ def compile_module(
     Basilisp import machinery, to allow callers to import Basilisp modules from
     Python code.
     """
-    _bootstrap_module(ctx.generator_context, ctx.py_ast_optimizer, module)
+    _bootstrap_module(ctx.generator_context, ctx.py_ast_optimizer, ns)
 
     for form in forms:
         nodes = gen_py_ast(
@@ -199,7 +201,7 @@ def compile_module(
         _incremental_compile_module(
             ctx.py_ast_optimizer,
             nodes,
-            module,
+            ns,
             source_filename=ctx.filename,
             collect_bytecode=collect_bytecode,
         )
@@ -209,14 +211,14 @@ def compile_bytecode(
     code: List[types.CodeType],
     gctx: GeneratorContext,
     optimizer: PythonASTOptimizer,
-    module: BasilispModule,
+    ns: runtime.Namespace,
 ) -> None:
     """Compile cached bytecode into the given module.
 
     The Basilisp import hook attempts to cache bytecode while compiling Basilisp
     namespaces. When the cached bytecode is reloaded from disk, it needs to be
     compiled within a bootstrapped module. This function bootstraps the module
     and then proceeds to compile a collection of bytecodes into the module."""
-    _bootstrap_module(gctx, optimizer, module)
+    _bootstrap_module(gctx, optimizer, ns)
     for bytecode in code:
-        exec(bytecode, module.__dict__)
+        exec(bytecode, ns.module.__dict__)