Store generated Python code in *generated-python* in current ns (#108)

Author: chrisrink10

basilisp/compiler.py

@@ -1390,6 +1390,13 @@ def _resolve_sym(ctx: CompilerContext, form: sym.Symbol) -> Optional[str]:
                 return _resolve_sym_var(ctx, v)
         ns_sym = sym.symbol(form.ns)
         if ns_sym in ctx.current_ns.imports:
+            # We still import Basilisp code, so we'll want to make sure
+            # that the symbol isn't referring to a Basilisp Var first
+            v = Var.find(form)
+            if v is not None:
+                return _resolve_sym_var(ctx, v)
+
+            # Otherwise, try to direct-link it like a Python variable
             safe_ns = munge(form.ns)
             safe_name = munge(form.name)
             return f"{safe_ns}.{safe_name}"
@@ -1689,6 +1696,8 @@ def compile_and_exec_form(form: LispForm,
 
     if runtime.print_generated_python():
         print(to_py_str(ast_module))
+    else:
+        runtime.add_generated_python(to_py_str(ast_module))
 
     bytecode = compile(ast_module, source_filename, 'exec')
     exec(bytecode, module.__dict__)
@@ -1711,6 +1720,8 @@ def _incremental_compile_module(nodes: MixedNodeStream,
 
     if runtime.print_generated_python():
         print(to_py_str(module))
+    else:
+        runtime.add_generated_python(to_py_str(module))
 
     bytecode = compile(module, source_filename, 'exec')
     exec(bytecode, mod.__dict__)

basilisp/lang/runtime.py

@@ -20,6 +20,7 @@
 _NS_VAR_NAME = '*ns*'
 _NS_VAR_NS = _CORE_NS
 _PYTHON_PACKAGE_NAME = 'basilisp'
+_GENERATED_PYTHON_VAR_NAME = '*generated-python*'
 _PRINT_GENERATED_PY_VAR_NAME = '*print-generated-python*'
 
 
@@ -186,6 +187,9 @@ class Namespace:
                                           'basilisp.lang.util'])
                                      .map(sym.symbol)))
     GATED_IMPORTS = pset(['basilisp.core'])
+
+    _IGNORED_CORE_MAPPINGS = pset([_GENERATED_PYTHON_VAR_NAME])
+
     _NAMESPACES = atom.Atom(pmap())
 
     __slots__ = ('_name', '_module', '_mappings', '_refers', '_aliases', '_imports')
@@ -293,7 +297,8 @@ def __import_core_mappings(ns_cache: PMap,
         if core_ns is None:
             raise KeyError(f"Namespace {core_ns_name} not found")
         for s, var in core_ns.mappings.items():
-            new_ns.intern(s, var)
+            if s.name not in Namespace._IGNORED_CORE_MAPPINGS:
+                new_ns.intern(s, var)
 
     @staticmethod
     def __get_or_create(ns_cache: PMap,
@@ -577,6 +582,21 @@ def resolve_alias(s: sym.Symbol) -> sym.Symbol:
             return sym.symbol(s.name, ns=ns.name)
 
 
+def add_generated_python(generated_python: str,
+                         var_name: str = _GENERATED_PYTHON_VAR_NAME,
+                         which_ns: Optional[str] = None) -> None:
+    """Add generated Python code to a dynamic variable in which_ns."""
+    if which_ns is None:
+        which_ns = get_current_ns().name
+    ns_sym = sym.Symbol(var_name, ns=which_ns)
+    v = Maybe(Var.find(ns_sym)) \
+        .or_else(lambda: Var.intern(sym.symbol(which_ns),  # type: ignore
+                                    sym.symbol(var_name),
+                                    "",
+                                    dynamic=True))
+    v.value = v.value + generated_python
+
+
 def print_generated_python(var_name: str = _PRINT_GENERATED_PY_VAR_NAME,
                            core_ns_name: str = _CORE_NS) -> bool:
     """Return the value of the `*print-generated-python*` dynamic variable."""
@@ -616,5 +636,10 @@ def in_ns(s: sym.Symbol):
     Var.intern(
         core_ns_sym,
         sym.symbol(_PRINT_GENERATED_PY_VAR_NAME),
-        True,
+        False,
+        dynamic=True)
+    Var.intern(
+        core_ns_sym,
+        sym.symbol(_GENERATED_PYTHON_VAR_NAME),
+        "",
         dynamic=True)