Fully namespace-qualified symbols should resolve regardless of current Namespace aliases (#479)

* Fully namespace-qualified symbols should resolve regardless of current Namespace aliases

* Change the log

* Allow private Var references during macroexpansion

* Redo the undo

* Don't include the redef changes

Author: chrisrink10

CHANGELOG.md

@@ -13,10 +13,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
  * Change the default user namespace to `basilisp.user` (#466)
- * Changed multi-methods to use a `threading.Lock` internally rather than an Atom (#477)
+ * Changed multi-methods to use a `threading.Lock` internally rather than an Atom (#478)
 
 ### Fixed
  * Fixed a reader bug where no exception was being thrown splicing reader conditional forms appeared outside of valid splicing contexts (#470)
+ * Fixed a bug where fully Namespace-qualified symbols would not resolve if the current Namespace did not alias the referenced Namespace (#479)
 
 ## [v0.1.dev12] - 2020-01-26
 ### Added

src/basilisp/lang/compiler/analyzer.py

@@ -59,6 +59,7 @@
     SYM_MUTABLE_META_KEY,
     SYM_NO_WARN_ON_SHADOW_META_KEY,
     SYM_NO_WARN_WHEN_UNUSED_META_KEY,
+    SYM_PRIVATE_META_KEY,
     SYM_PROPERTY_META_KEY,
     SYM_STATICMETHOD_META_KEY,
     SpecialForm,
@@ -2517,6 +2518,24 @@ def __resolve_namespaced_symbol(  # pylint: disable=too-many-branches
             env=ctx.get_node_env(pos=ctx.syntax_position),
         )
 
+    v = Var.find(form)
+    if v is not None:
+        # Disallow global references to Vars defined with :private metadata
+        #
+        # Global references to private Vars are allowed in macroexpanded code
+        # as long as the macro referencing the private Var is in the same
+        # Namespace as the private Var (via `ctx.current_macro_ns`)
+        if (
+            v.ns != ctx.current_macro_ns
+            and v.meta is not None
+            and v.meta.val_at(SYM_PRIVATE_META_KEY, False)
+        ):
+            raise AnalyzerException(
+                f"cannot resolve private Var {form.name} from namespace {form.ns}",
+                form=form,
+            )
+        return VarRef(form=form, var=v, env=ctx.get_node_env(pos=ctx.syntax_position))
+
     if "." in form.name and form.name != _DOUBLE_DOT_MACRO_NAME:
         raise AnalyzerException(
             "symbol names may not contain the '.' operator", form=form

src/basilisp/lang/compiler/constants.py

@@ -135,6 +135,7 @@ class SpecialForm:
 )
 
 SYM_ASYNC_META_KEY = kw.keyword("async")
+SYM_PRIVATE_META_KEY = kw.keyword("private")
 SYM_CLASSMETHOD_META_KEY = kw.keyword("classmethod")
 SYM_DEFAULT_META_KEY = kw.keyword("default")
 SYM_DYNAMIC_META_KEY = kw.keyword("dynamic")

tests/basilisp/compiler_test.py

@@ -20,6 +20,7 @@
 import basilisp.lang.set as lset
 import basilisp.lang.symbol as sym
 import basilisp.lang.vector as vec
+from basilisp.lang.compiler.constants import SYM_PRIVATE_META_KEY
 from basilisp.lang.interfaces import IType
 from basilisp.lang.runtime import Var
 from basilisp.main import init
@@ -3077,6 +3078,48 @@ def test_aliased_macro_symbol_resolution(self, ns: runtime.Namespace):
         finally:
             runtime.Namespace.remove(other_ns_name)
 
+    def test_fully_namespaced_sym_resolves(self, ns: runtime.Namespace):
+        """Ensure that references to Vars in other Namespaces by a fully Namespace
+        qualified symbol always resolve, regardless of whether the Namespace has
+        been aliased within the current Namespace."""
+        other_ns_name = sym.symbol("other.ns")
+        public_var_sym = sym.symbol("public-var")
+        private_var_sym = sym.symbol("private-var")
+        third_ns_name = sym.symbol("third.ns")
+        try:
+            other_ns = runtime.Namespace.get_or_create(other_ns_name)
+            runtime.Namespace.get_or_create(third_ns_name)
+
+            # Intern a public symbol in `other.ns`
+            public_var = Var(other_ns, public_var_sym)
+            public_var.value = kw.keyword("public-var")
+            other_ns.intern(public_var_sym, public_var)
+
+            # Intern a private symbol in `other.ns`
+            private_var = Var(
+                other_ns, private_var_sym, meta=lmap.map({SYM_PRIVATE_META_KEY: True})
+            )
+            private_var.value = kw.keyword("private-var")
+            other_ns.intern(private_var_sym, private_var)
+
+            with runtime.ns_bindings(third_ns_name.name):
+                # Verify that we can refer to `other.ns/public-var` with a fully
+                # namespace qualified symbol
+                assert kw.keyword("public-var") == lcompile(
+                    "other.ns/public-var", resolver=runtime.resolve_alias,
+                )
+
+                # Verify we cannot refer to `other.ns/private-var` because it is
+                # marked private
+                with pytest.raises(compiler.CompilerException):
+                    lcompile(
+                        "other.ns/private-var", resolver=runtime.resolve_alias,
+                    )
+
+        finally:
+            runtime.Namespace.remove(other_ns_name)
+            runtime.Namespace.remove(third_ns_name)
+
     def test_cross_ns_macro_symbol_resolution(self, ns: runtime.Namespace):
         """Ensure that a macro symbol, `a`, delegating to another macro, named
         by the symbol `b`, in a namespace directly required by `a`'s namespace