Add namespace functions to basilisp.core (#176)

* Add namespace functions to basilisp.core

* Rename Namespace.mappings to Namespace.interns

* Use refer_all method for CLI bootstrapping of REPL

* Loads of new Namespace tests

* Many more Var tests

* Fix a bug with ns-publics

* Non-functional refer function

* Realize lazy seq to check if the sequence is empty

* First pass on a require function

* Generated Python vars are private to each namespace

* Resolve macro symbols with more sophisticated heuristic

* Rearrange some code

* Add small import macro

* Add ns preamble macro

* Fix import mechanism using global keyword hackery

* Fix the gated import test

* Plz fix everything

* Fix linting error

* Refactor require code slightly

Author: chrisrink10

basilisp/cli.py

@@ -11,7 +11,6 @@
 import basilisp.lang.symbol as sym
 import basilisp.main as basilisp
 import basilisp.reader as reader
-from basilisp.util import Maybe
 
 
 @click.group()
@@ -44,11 +43,7 @@ def bootstrap_repl(which_ns: str) -> types.ModuleType:
     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)
-    for name in ['*1', '*2', '*3', '*e', 'doc', 'pydoc', 'source']:
-        ns.intern(sym.symbol(name),
-                  Maybe(runtime.Var.find(sym.symbol(name, ns='basilisp.repl'))).or_else_raise(
-                      lambda: runtime.RuntimeException(
-                          f"Var basilisp.repl/{name} not found!")))  # pylint: disable=cell-var-from-loop
+    ns.refer_all(repl_ns)
     return repl_module
 
 

basilisp/compiler.py

@@ -2,6 +2,7 @@
 import collections
 import contextlib
 import functools
+import importlib
 import itertools
 import sys
 import types
@@ -181,11 +182,11 @@ def quoted(self):
         yield
         self._is_quoted.pop()
 
-    def add_import(self, imp: sym.Symbol):
-        self.current_ns.add_import(imp)
+    def add_import(self, imp: sym.Symbol, mod: types.ModuleType):
+        self.current_ns.add_import(imp, mod)
 
     @property
-    def imports(self):
+    def imports(self) -> lmap.Map:
         return self.current_ns.imports
 
     @property
@@ -225,15 +226,6 @@ def attr_node(node, idx):
     return attr_node(ast.Name(id=attrs[0], ctx=ast.Load()), 1)
 
 
-def _is_py_module(name: str) -> bool:
-    """Determine if a namespace is Python module."""
-    try:
-        __import__(name)
-        return True
-    except ModuleNotFoundError:
-        return False
-
-
 class ASTNodeType(Enum):
     DEPENDENCY = 1
     NODE = 2
@@ -943,22 +935,32 @@ def _if_ast(ctx: CompilerContext, form: llist.List) -> ASTStream:
 
 def _import_ast(ctx: CompilerContext, form: llist.List) -> ASTStream:
     """Append Import statements into the compiler context nodes."""
-    assert form[0] == _IMPORT
+    assert form.first == _IMPORT
     assert all([isinstance(f, sym.Symbol) for f in form.rest])
 
-    import_names = []
+    last = None
     for s in form.rest:
-        if not _is_py_module(s.name):
+        try:
+            module = importlib.import_module(s.name)
+            ctx.add_import(s, module)
+        except ModuleNotFoundError:
             raise ImportError(f"Module '{s.name}' not found")
-        ctx.add_import(s)
+
         with ctx.quoted():
+            module_name = s.name.split(".", maxsplit=1)[0]
+            yield _dependency(ast.Global(names=[module_name]))
+            yield _dependency(ast.Assign(targets=[ast.Name(id=module_name, ctx=ast.Store())],
+                                         value=ast.Call(func=_load_attr("builtins.__import__"),
+                                                        args=[ast.Str(s.name)],
+                                                        keywords=[])))
+            last = ast.Name(id=module_name, ctx=ast.Load())
             yield _dependency(ast.Call(
                 func=_load_attr(f'{_NS_VAR_VALUE}.add_import'),
-                args=_unwrap_nodes(_to_ast(ctx, s)),
+                args=list(chain(_unwrap_nodes(_to_ast(ctx, s)), [last])),
                 keywords=[]))
-        import_names.append(ast.alias(name=s.name, asname=None))
-    yield _dependency(ast.Import(names=import_names))
-    yield _node(ast.NameConstant(None))
+
+    assert last is not None
+    yield _node(last)
 
 
 def _interop_call_ast(ctx: CompilerContext, form: llist.List) -> ASTStream:
@@ -1780,7 +1782,7 @@ def _module_imports(ctx: CompilerContext) -> Iterable[ast.Import]:
                'basilisp.lang.vector': _VEC_ALIAS,
                'basilisp.lang.util': _UTIL_ALIAS}
     return seq(ctx.imports) \
-        .map(lambda s: s.name) \
+        .map(lambda entry: entry.key.name) \
         .map(lambda name: (name, aliases.get(name, None))) \
         .map(lambda t: ast.Import(names=[ast.alias(name=t[0], asname=t[1])])) \
         .to_list()