Fix resolver bugs (#170)

* Fix resolver to ignore special forms and resolve imported files

* Fix regex errors reported by Pytest

* Add a test for runtime.resolve_alias

Author: chrisrink10

basilisp/compiler.py

@@ -1525,8 +1525,8 @@ def _resolve_sym(ctx: CompilerContext, form: sym.Symbol) -> Optional[str]:  # no
             # If neither resolve, then defer to a Var.find
             return None
         elif ns_sym in ctx.current_ns.aliases:
-            aliased_ns = ctx.current_ns.aliases[ns_sym]
-            v = Var.find(sym.symbol(form.name, ns=aliased_ns))
+            aliased_ns: runtime.Namespace = ctx.current_ns.aliases[ns_sym]
+            v = Var.find(sym.symbol(form.name, ns=aliased_ns.name))
             if v is not None:
                 return _resolve_sym_var(ctx, v)
             return None

basilisp/importer.py

@@ -85,7 +85,7 @@ def exec_module(self, module):
         ns: runtime.Namespace = runtime.set_current_ns(fullname).value
         ns.module = module
 
-        forms = reader.read_file(filename)
+        forms = reader.read_file(filename, resolver=runtime.resolve_alias)
         compiler.compile_module(forms, compiler.CompilerContext(), module, filename)
 
         # Because we want to (by default) add 'basilisp.core into every namespace by default,

basilisp/lang/runtime.py

@@ -15,6 +15,7 @@
 import basilisp.lang.list as llist
 import basilisp.lang.map as lmap
 import basilisp.lang.seq as lseq
+import basilisp.lang.set as lset
 import basilisp.lang.symbol as sym
 from basilisp.lang import atom
 from basilisp.lang.typing import LispNumber
@@ -28,6 +29,25 @@
 _GENERATED_PYTHON_VAR_NAME = '*generated-python*'
 _PRINT_GENERATED_PY_VAR_NAME = '*print-generated-python*'
 
+_CATCH = sym.symbol("catch")
+_DEF = sym.symbol("def")
+_DO = sym.symbol("do")
+_FINALLY = sym.symbol("finally")
+_FN = sym.symbol("fn*")
+_IF = sym.symbol("if")
+_IMPORT = sym.symbol("import*")
+_INTEROP_CALL = sym.symbol(".")
+_INTEROP_PROP = sym.symbol(".-")
+_LET = sym.symbol("let*")
+_QUOTE = sym.symbol("quote")
+_RECUR = sym.symbol("recur")
+_THROW = sym.symbol("throw")
+_TRY = sym.symbol("try")
+_VAR = sym.symbol("var")
+_SPECIAL_FORMS = lset.s(_CATCH, _DEF, _DO, _FINALLY, _FN, _IF, _IMPORT,
+                        _INTEROP_CALL, _INTEROP_PROP, _LET, _QUOTE, _RECUR,
+                        _THROW, _TRY, _VAR)
+
 
 def _new_module(name: str, doc=None) -> types.ModuleType:
     """Create a new empty Basilisp Python module.
@@ -671,9 +691,12 @@ def get_current_ns(ns_var_name: str = _NS_VAR_NAME,
     return ns
 
 
-def resolve_alias(s: sym.Symbol) -> sym.Symbol:
+def resolve_alias(s: sym.Symbol, ns: Optional[Namespace] = None) -> sym.Symbol:
     """Resolve the aliased symbol in the current namespace."""
-    ns = get_current_ns()
+    if s in _SPECIAL_FORMS:
+        return s
+
+    ns = Maybe(ns).or_else(get_current_ns)
     if s.ns is not None:
         aliased_ns = ns.get_alias(sym.symbol(s.ns))
         if aliased_ns is not None:

basilisp/reader.py

@@ -25,12 +25,12 @@
 from basilisp.util import Maybe
 
 ns_name_chars = re.compile(r'\w|-|\+|\*|\?|/|\=|\\|!|&|%|>|<')
-begin_num_chars = re.compile('[0-9\-]')
+begin_num_chars = re.compile(r'[0-9\-]')
 num_chars = re.compile('[0-9]')
-whitespace_chars = re.compile('[\s,]')
+whitespace_chars = re.compile(r'[\s,]')
 newline_chars = re.compile('(\r\n|\r|\n)')
 fn_macro_args = re.compile('(%)(&|[0-9])?')
-unicode_char = re.compile('u(\w+)')
+unicode_char = re.compile(r'u(\w+)')
 
 DataReaders = Optional[lmap.Map]
 GenSymEnvironment = Dict[str, symbol.Symbol]

tests/compiler_test.py

@@ -725,7 +725,7 @@ def test_inst(ns_var: Var):
 
 
 def test_regex(ns_var: Var):
-    assert lcompile('#"\s"') == re.compile('\s')
+    assert lcompile(r'#"\s"') == re.compile(r'\s')
 
 
 def test_uuid(ns_var: Var):

tests/reader_test.py

@@ -783,10 +783,10 @@ def test_inst_reader_literal():
 
 def test_regex_reader_literal():
     assert read_str_first('#"hi"') == langutil.regex_from_str("hi")
-    assert read_str_first('#"\s"') == langutil.regex_from_str(r"\s")
+    assert read_str_first(r'#"\s"') == langutil.regex_from_str(r"\s")
 
     with pytest.raises(reader.SyntaxError):
-        read_str_first('#"\y"')
+        read_str_first(r'#"\y"')
 
 
 def test_uuid_reader_literal():

tests/runtime_test.py

@@ -7,6 +7,7 @@
 import basilisp.lang.runtime as runtime
 import basilisp.lang.seq as lseq
 import basilisp.lang.set as lset
+import basilisp.lang.symbol as sym
 import basilisp.lang.vector as vec
 
 
@@ -245,3 +246,35 @@ def test_trampoline_args():
 
     args = runtime._TrampolineArgs(True, 1, llist.l(2, 3, 4), 5, 6)
     assert (1, llist.l(2, 3, 4), 5, 6) == args.args
+
+
+@pytest.fixture
+def core_ns():
+    ns_var = runtime.init_ns_var(which_ns=runtime._CORE_NS)
+    yield ns_var.value
+    runtime.Namespace.remove(sym.symbol(runtime._CORE_NS))
+
+
+def test_resolve_alias(core_ns):
+    for form in runtime._SPECIAL_FORMS:
+        assert form == runtime.resolve_alias(form)
+
+    ns_name = 'resolve-test'
+    ns_sym = sym.symbol(ns_name)
+    ns: runtime.Namespace = runtime.set_current_ns(ns_name).value
+
+    runtime.Var.intern(ns_sym, sym.symbol('existing-var'), None)
+    assert sym.symbol('existing-var', ns=ns_name) == runtime.resolve_alias(
+        sym.symbol('existing-var'), ns=ns)
+
+    assert sym.symbol('non-existent-var', ns=ns_name) == runtime.resolve_alias(
+        sym.symbol('non-existent-var'), ns=ns)
+
+    foo_ns_sym = sym.symbol('zux.bar.foo')
+    foo_ns = runtime.Namespace.get_or_create(foo_ns_sym)
+    ns.add_alias(sym.symbol('foo'), foo_ns)
+    assert sym.symbol('aliased-var', ns=foo_ns_sym.name) == runtime.resolve_alias(
+        sym.symbol('aliased-var', ns='foo'), ns=ns)
+
+    assert sym.symbol('non-existent-alias-var', ns='wee.woo') == runtime.resolve_alias(
+        sym.symbol('non-existent-alias-var', ns='wee.woo'), ns=ns)