Macroexpand convenience function (#394)

* Imports in the time of __init__

* Tests

* Allow Python submodules to Basilisp modules

* Macroexpansion except way overcomplicated

* Actually good, simple macroexpand function

* Rebuild

* Make MyPy happy

* plz

Author: chrisrink10

src/basilisp/core.lpy

@@ -467,6 +467,19 @@
        ~fmeta
        ~@body)))
 
+(defn macroexpand-1
+  "Macroexpand form one time. Returns the macroexpanded form. The return
+  value may still represent a macro. Does not macroexpand child forms."
+  [form]
+  (basilisp.lang.compiler/macroexpand-1 form))
+
+(defn macroexpand
+  "Repeatedly macroexpand form as by macroexpand-1 until form no longer
+  represents a macro. Returns the expanded form. Does not macroexpand child
+  forms."
+  [form]
+  (basilisp.lang.compiler/macroexpand form))
+
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Logical Comparisons & Macros ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

src/basilisp/lang/compiler/__init__.py

@@ -13,6 +13,8 @@
     WARN_ON_SHADOWED_VAR,
     WARN_ON_UNUSED_NAMES,
     analyze_form,
+    macroexpand,
+    macroexpand_1,
 )
 from basilisp.lang.compiler.exception import CompilerException, CompilerPhase  # noqa
 from basilisp.lang.compiler.generator import (  # noqa

src/basilisp/lang/compiler/analyzer.py

@@ -281,11 +281,15 @@ class AnalyzerContext:
         "_is_quoted",
         "_opts",
         "_recur_points",
+        "_should_macroexpand",
         "_st",
     )
 
     def __init__(
-        self, filename: Optional[str] = None, opts: Optional[Mapping[str, bool]] = None
+        self,
+        filename: Optional[str] = None,
+        opts: Optional[Mapping[str, bool]] = None,
+        should_macroexpand: bool = True,
     ) -> None:
         self._filename = Maybe(filename).or_else_get(DEFAULT_COMPILER_FILE_PATH)
         self._func_ctx: Deque[bool] = collections.deque([])
@@ -294,6 +298,7 @@ def __init__(
             Maybe(opts).map(lmap.map).or_else_get(lmap.Map.empty())  # type: ignore
         )
         self._recur_points: Deque[RecurPoint] = collections.deque([])
+        self._should_macroexpand = should_macroexpand
         self._st = collections.deque([SymbolTable("<Top>")])
 
     @property
@@ -339,6 +344,10 @@ def quoted(self):
         yield
         self._is_quoted.pop()
 
+    @property
+    def should_macroexpand(self) -> bool:
+        return self._should_macroexpand
+
     @property
     def is_async_ctx(self) -> bool:
         try:
@@ -1614,25 +1623,26 @@ def _invoke_ast(ctx: AnalyzerContext, form: Union[llist.List, ISeq]) -> Node:
 
     if fn.op == NodeOp.VAR and isinstance(fn, VarRef):
         if _is_macro(fn.var):
-            try:
-                macro_env = ctx.symbol_table.as_env_map()
-                expanded = fn.var.value(macro_env, form, *form.rest)
-                expanded_ast = _analyze_form(ctx, expanded)
-
-                # Verify that macroexpanded code also does not have any
-                # non-tail recur forms
-                if ctx.recur_point is not None:
-                    _assert_recur_is_tail(expanded_ast)
-
-                return expanded_ast.assoc(
-                    raw_forms=cast(vec.Vector, expanded_ast.raw_forms).cons(form)
-                )
-            except Exception as e:
-                raise CompilerException(
-                    "error occurred during macroexpansion",
-                    form=form,
-                    phase=CompilerPhase.MACROEXPANSION,
-                ) from e
+            if ctx.should_macroexpand:
+                try:
+                    macro_env = ctx.symbol_table.as_env_map()
+                    expanded = fn.var.value(macro_env, form, *form.rest)
+                    expanded_ast = _analyze_form(ctx, expanded)
+
+                    # Verify that macroexpanded code also does not have any
+                    # non-tail recur forms
+                    if ctx.recur_point is not None:
+                        _assert_recur_is_tail(expanded_ast)
+
+                    return expanded_ast.assoc(
+                        raw_forms=cast(vec.Vector, expanded_ast.raw_forms).cons(form)
+                    )
+                except Exception as e:
+                    raise CompilerException(
+                        "error occurred during macroexpansion",
+                        form=form,
+                        phase=CompilerPhase.MACROEXPANSION,
+                    ) from e
 
     return Invoke(
         form=form,
@@ -2458,3 +2468,27 @@ def analyze_form(ctx: AnalyzerContext, form: ReaderForm) -> Node:
     """Take a Lisp form as an argument and produce a Basilisp syntax
     tree matching the clojure.tools.analyzer AST spec."""
     return _analyze_form(ctx, form).assoc(top_level=True)
+
+
+def macroexpand_1(form: ReaderForm) -> ReaderForm:
+    """Macroexpand form one time. Returns the macroexpanded form. The return
+    value may still represent a macro. Does not macroexpand child forms."""
+    ctx = AnalyzerContext("<Macroexpand>", should_macroexpand=False)
+    maybe_macro = analyze_form(ctx, form)
+    if maybe_macro.op == NodeOp.INVOKE:
+        assert isinstance(maybe_macro, Invoke)
+
+        fn = maybe_macro.fn
+        if fn.op == NodeOp.VAR and isinstance(fn, VarRef):
+            if _is_macro(fn.var):
+                assert isinstance(form, ISeq)
+                macro_env = ctx.symbol_table.as_env_map()
+                return fn.var.value(macro_env, form, *form.rest)
+    return maybe_macro.form
+
+
+def macroexpand(form: ReaderForm) -> ReaderForm:
+    """Repeatedly macroexpand form as by macroexpand-1 until form no longer
+    represents a macro. Returns the expanded form. Does not macroexpand child
+    forms."""
+    return analyze_form(AnalyzerContext("<Macroexpand>"), form).form

tests/basilisp/compiler_test.py

@@ -1740,6 +1740,59 @@ def test_macro_expansion(ns: runtime.Namespace):
     assert llist.l(1, 2, 3) == lcompile("((fn [] '(1 2 3)))")
 
 
+class TestMacroexpandFunctions:
+    @pytest.fixture
+    def example_macro(self):
+        lcompile(
+            "(defmacro parent [] `(defmacro ~'child [] (fn [])))",
+            resolver=runtime.resolve_alias,
+        )
+
+    def test_macroexpand_1(self, example_macro):
+        assert llist.l(
+            sym.symbol("defmacro", ns="basilisp.core"),
+            sym.symbol("child"),
+            vec.Vector.empty(),
+            llist.l(sym.symbol("fn", ns="basilisp.core"), vec.Vector.empty()),
+        ) == compiler.macroexpand_1(llist.l(sym.symbol("parent")))
+
+        assert llist.l(
+            sym.symbol("add", ns="operator"), 1, 2
+        ) == compiler.macroexpand_1(llist.l(sym.symbol("add", ns="operator"), 1, 2))
+        assert sym.symbol("map") == compiler.macroexpand_1(sym.symbol("map"))
+        assert llist.l(sym.symbol("map")) == compiler.macroexpand_1(
+            llist.l(sym.symbol("map"))
+        )
+        assert vec.Vector.empty() == compiler.macroexpand_1(vec.Vector.empty())
+
+        with pytest.raises(compiler.CompilerException):
+            compiler.macroexpand_1(sym.symbol("non-existent-symbol"))
+
+    def test_macroexpand(self, example_macro):
+        assert llist.l(
+            sym.symbol("def"),
+            sym.symbol("child"),
+            llist.l(
+                sym.symbol("fn", ns="basilisp.core"),
+                sym.symbol("child"),
+                vec.v(sym.symbol("&env"), sym.symbol("&form")),
+                llist.l(sym.symbol("fn", ns="basilisp.core"), vec.Vector.empty()),
+            ),
+        ) == compiler.macroexpand(llist.l(sym.symbol("parent")))
+
+        assert llist.l(sym.symbol("add", ns="operator"), 1, 2) == compiler.macroexpand(
+            llist.l(sym.symbol("add", ns="operator"), 1, 2)
+        )
+        assert sym.symbol("map") == compiler.macroexpand(sym.symbol("map"))
+        assert llist.l(sym.symbol("map")) == compiler.macroexpand(
+            llist.l(sym.symbol("map"))
+        )
+        assert vec.Vector.empty() == compiler.macroexpand(vec.Vector.empty())
+
+        with pytest.raises(compiler.CompilerException):
+            compiler.macroexpand(sym.symbol("non-existent-symbol"))
+
+
 class TestIf:
     def test_if_number_of_elems(self):
         with pytest.raises(compiler.CompilerException):