Don't force all top-level do forms to use Var indirection (#1033)

Fixes #1034

Author: chrisrink10

CHANGELOG.md

@@ -5,6 +5,9 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Changed
+ * The compiler will no longer require `Var` indirection for top-level `do` forms unless those forms specify `^:use-var-indirection` metadata (which currently is only used in the `ns` macro) (#1034)
+
 ### Fixed
  * Fix a bug where the compiler would always generate inline function definitions even if the `inline-functions` compiler option is disabled (#1023)
  * Fix a bug where `defrecord`/`deftype` constructors could not be used in the type's methods. (#1025)

src/basilisp/core.lpy

@@ -5189,7 +5189,7 @@
                         (map (fn [v]
                                `(import ~v))
                              (:import opts)))]
-    `(do
+    `(^:use-var-indirection do
        (in-ns (quote ~name))
        (swap! *loaded-libs* conj (quote ~name))
        ~(when doc

src/basilisp/lang/compiler/analyzer.py

@@ -77,6 +77,7 @@
     SYM_REDEF_META_KEY,
     SYM_STATICMETHOD_META_KEY,
     SYM_TAG_META_KEY,
+    SYM_USE_VAR_INDIRECTION_KEY,
     VAR_IS_PROTOCOL_META_KEY,
     SpecialForm,
 )
@@ -673,6 +674,7 @@ def get_meta_prop(o: Union[IMeta, Var]) -> Any:
 _is_py_staticmethod = _bool_meta_getter(SYM_STATICMETHOD_META_KEY)
 _is_macro = _bool_meta_getter(SYM_MACRO_META_KEY)
 _is_no_inline = _bool_meta_getter(SYM_NO_INLINE_META_KEY)
+_is_use_var_indirection = _bool_meta_getter(SYM_USE_VAR_INDIRECTION_KEY)
 _inline_meta = _meta_getter(SYM_INLINE_META_KW)
 _tag_meta = _meta_getter(SYM_TAG_META_KEY)
 
@@ -2017,6 +2019,7 @@ def _do_ast(form: ISeq, ctx: AnalyzerContext) -> Do:
         form=form,
         statements=vec.vector(statements),
         ret=ret,
+        use_var_indirection=_is_use_var_indirection(form.first),
         env=ctx.get_node_env(pos=ctx.syntax_position),
     )
 

src/basilisp/lang/compiler/constants.py

@@ -51,6 +51,7 @@ class SpecialForm:
 SYM_REDEF_META_KEY = kw.keyword("redef")
 SYM_STATICMETHOD_META_KEY = kw.keyword("staticmethod")
 SYM_TAG_META_KEY = kw.keyword("tag")
+SYM_USE_VAR_INDIRECTION_KEY = kw.keyword("use-var-indirection")
 
 ARGLISTS_KW = kw.keyword("arglists")
 INTERFACE_KW = kw.keyword("interface")

src/basilisp/lang/compiler/generator.py

@@ -1530,18 +1530,18 @@ def _wrap_override_var_indirection(
 ) -> "PyASTGenerator[T_node, P_generator, T_pynode]":
     """
     Wrap a Node generator to apply a special override requiring Var indirection
-    for any Var accesses generated within top-level `do` blocks.
-
-    This is a bit of a hack to account for the `ns` macro, which is the first
-    form in most standard Namespaces. When Basilisp `require`s a Namespace, it
-    (like in Clojure) simply loads the file and lets that Namespace's `ns` macro
-    create the new Namespace and perform any setup. However, the Basilisp
-    compiler desperately tries to emit "smarter" Python code which avoids using
-    `Var.find` whenever the resolved symbol can be safely called directly from
-    the generated Pythom module. Without this hack, the compiler will emit code
-    during macroexpansion to access `basilisp.core` functions used in the `ns`
-    macro directly, even though they will not be available yet in the target
-    Namespace module.
+    for any Var accesses generated within `do` blocks which are marked with the
+    ^:use-var-indirection metadata.
+
+    This is needed to account for the `ns` macro, which is the first form in most
+    standard Namespaces. When Basilisp `require`s a Namespace, it (like in Clojure)
+    simply loads the file and lets that Namespace's `ns` macro create the new
+    Namespace and perform any setup. However, the Basilisp compiler desperately
+    tries to emit "smarter" Python code which avoids using `Var.find` whenever
+    the resolved symbol can be safely called directly from the generated Python
+    module. Without this hack, the compiler will emit code during macroexpansion
+    to access `basilisp.core` functions used in the `ns` macro directly, even
+    though they will not be available yet in the target Namespace module.
     """
 
     @wraps(f)
@@ -1551,7 +1551,7 @@ def _wrapped_do(
         *args: P_generator.args,
         **kwargs: P_generator.kwargs,
     ) -> GeneratedPyAST[T_pynode]:
-        if isinstance(node, Do) and node.top_level:
+        if isinstance(node, Do) and node.use_var_indirection:
             with ctx.with_var_indirection_override():
                 return f(ctx, cast(T_node, node), *args, **kwargs)
         else:

src/basilisp/lang/compiler/nodes.py

@@ -532,6 +532,7 @@ class Do(Node[SpecialForm]):
     ret: Node
     env: NodeEnv
     is_body: bool = False
+    use_var_indirection: bool = False
     children: Sequence[kw.Keyword] = vec.v(STATEMENTS, RET)
     op: NodeOp = NodeOp.DO
     top_level: bool = False