Nested module imports are no longer obscured by their parent module (#360)

Author: chrisrink10

src/basilisp/lang/compiler/generator.py

@@ -1171,11 +1171,10 @@ def _import_to_py_ast(ctx: GeneratorContext, node: Import) -> GeneratedPyAST:
     deps: List[ast.AST] = []
     for alias in node.aliases:
         safe_name = munge(alias.name)
-        safe_alias = munge(alias.alias)
 
         try:
             module = importlib.import_module(safe_name)
-            if alias.name != alias.alias:
+            if alias.alias is not None:
                 ctx.add_import(sym.symbol(alias.name), module, sym.symbol(alias.alias))
             else:
                 ctx.add_import(sym.symbol(alias.name), module)
@@ -1184,17 +1183,22 @@ def _import_to_py_ast(ctx: GeneratorContext, node: Import) -> GeneratedPyAST:
                 f"Python module '{alias.name}' not found", node.form, node
             ) from e
 
+        py_import_alias = (
+            munge(alias.alias)
+            if alias.alias is not None
+            else safe_name.split(".", maxsplit=1)[0]
+        )
         deps.append(
             ast.Assign(
-                targets=[ast.Name(id=safe_alias, ctx=ast.Store())],
+                targets=[ast.Name(id=py_import_alias, ctx=ast.Store())],
                 value=ast.Call(
                     func=_load_attr("builtins.__import__"),
                     args=[ast.Str(safe_name)],
                     keywords=[],
                 ),
             )
         )
-        last = ast.Name(id=safe_alias, ctx=ast.Load())
+        last = ast.Name(id=py_import_alias, ctx=ast.Load())
 
         # Note that we add this import to the live running system in the above
         # calls to `ctx.add_import`, however, since we compile and cache Python

src/basilisp/lang/compiler/nodes.py

@@ -404,7 +404,7 @@ class Import(Node[SpecialForm]):
 class ImportAlias(Node[Union[sym.Symbol, vec.Vector]]):
     form: Union[sym.Symbol, vec.Vector]
     name: str
-    alias: str
+    alias: Optional[str]
     env: NodeEnv
     children: Collection[kw.Keyword] = vec.Vector.empty()
     op: NodeOp = NodeOp.IMPORT_ALIAS

src/basilisp/lang/compiler/parser.py

@@ -995,7 +995,7 @@ def _import_ast(  # pylint: disable=too-many-branches
     for f in form.rest:
         if isinstance(f, sym.Symbol):
             module_name = f
-            module_alias = module_name.name.split(".", maxsplit=1)[0]
+            module_alias = None
         elif isinstance(f, vec.Vector):
             if len(f) != 3:
                 raise ParserException(

tests/basilisp/compiler_test.py

@@ -44,10 +44,19 @@ def test_ns() -> str:
 
 
 @pytest.fixture
-def ns(test_ns: str) -> runtime.Namespace:
+def test_ns_sym(test_ns: str) -> sym.Symbol:
+    return sym.symbol(test_ns)
+
+
+@pytest.fixture
+def ns(test_ns: str, test_ns_sym: sym.Symbol) -> runtime.Namespace:
     runtime.init_ns_var(which_ns=runtime.CORE_NS)
+    runtime.Namespace.get_or_create(test_ns_sym)
     with runtime.ns_bindings(test_ns) as ns:
-        yield ns
+        try:
+            yield ns
+        finally:
+            runtime.Namespace.remove(test_ns_sym)
 
 
 @pytest.fixture
@@ -902,7 +911,7 @@ def test_macro_expansion(ns: runtime.Namespace):
 
 
 class TestIf:
-    def test_if_number_of_elems(self, ns: runtime.Namespace):
+    def test_if_number_of_elems(self):
         with pytest.raises(compiler.CompilerException):
             lcompile("(if)")
 
@@ -925,7 +934,7 @@ def test_if(self, ns: runtime.Namespace):
         """
         assert "YELLING" == lcompile(code)
 
-    def test_truthiness(self, ns: runtime.Namespace):
+    def test_truthiness(self):
         # Valid false values
         assert kw.keyword("b") == lcompile("(if false :a :b)")
         assert kw.keyword("b") == lcompile("(if nil :a :b)")
@@ -1007,7 +1016,7 @@ def test_import_module_must_exist(self, ns: runtime.Namespace):
         with pytest.raises(ImportError):
             lcompile("(import* real.fake.module)")
 
-    def test_import_resolves_within_do_block(self):
+    def test_import_resolves_within_do_block(self, ns: runtime.Namespace):
         import time
 
         assert time.perf_counter == lcompile("(do (import* time)) time/perf-counter")
@@ -1041,6 +1050,16 @@ def test_multi_import(self, ns: runtime.Namespace):
             )
         )
 
+    def test_nested_imports_visible_with_parent(self, ns: runtime.Namespace):
+        import collections.abc
+
+        assert [collections.OrderedDict, collections.abc.Sized] == lcompile(
+            """
+        (import* collections collections.abc)
+        #py [collections/OrderedDict collections.abc/Sized]
+        """
+        )
+
 
 class TestPythonInterop:
     def test_interop_is_valid_type(self, ns: runtime.Namespace):
@@ -1368,22 +1387,22 @@ def test_loop_with_recur(self, ns: runtime.Namespace):
 
 
 class TestQuote:
-    def test_quoted_list(self, ns: runtime.Namespace):
+    def test_quoted_list(self):
         assert lcompile("'()") == llist.l()
         assert lcompile("'(str)") == llist.l(sym.symbol("str"))
         assert lcompile("'(str 3)") == llist.l(sym.symbol("str"), 3)
         assert lcompile("'(str 3 :feet-deep)") == llist.l(
             sym.symbol("str"), 3, kw.keyword("feet-deep")
         )
 
-    def test_quoted_map(self, ns: runtime.Namespace):
+    def test_quoted_map(self):
         assert lcompile("'{}") == lmap.Map.empty()
         assert lcompile("'{:a 2}") == lmap.map({kw.keyword("a"): 2})
         assert lcompile('\'{:a 2 "str" s}') == lmap.map(
             {kw.keyword("a"): 2, "str": sym.symbol("s")}
         )
 
-    def test_quoted_set(self, ns: runtime.Namespace):
+    def test_quoted_set(self):
         assert lcompile("'#{}") == lset.Set.empty()
         assert lcompile("'#{:a 2}") == lset.s(kw.keyword("a"), 2)
         assert lcompile('\'#{:a 2 "str"}') == lset.s(kw.keyword("a"), 2, "str")
@@ -1650,7 +1669,7 @@ def test_set_cannot_assign_fn_arg_local(self):
         with pytest.raises(compiler.CompilerException):
             lcompile("(fn [a b] (set! a :c))")
 
-    def test_set_cannot_assign_non_dynamic_var(self):
+    def test_set_cannot_assign_non_dynamic_var(self, ns: runtime.Namespace):
         with pytest.raises(compiler.CompilerException):
             lcompile(
                 """