Add support for referring imported names

Author: chrisrink10

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [v0.3.8]
 ### Added
  * Added `afor` and `awith` macros to support async Python interop (#1179, #1181)
+ * Added support for referring imported Python names as by `from ... import ...` (#1154)
 
 ### Changed
  * Function parameter names will not be automatically generated with unique suffixes unless the function meta key `^:safe-py-params` is provided (#1212)
@@ -18,7 +19,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
  * Fix an issue where consecutive reader comment forms would not be ignored (#1207)
 
 ## [v0.3.7]
-### Fixed 
+### Fixed
  * Fix a regression introduced in #1176 where the testrunner couldn't handle relative paths in `sys.path`, causing `basilisp test` to fail when no arugments were provided (#1204)
  * Fix a bug where `basilisp.process/exec` could deadlock reading process output if that output exceeded the buffer size (#1202)
  * Fix `basilisp boostrap` issue on MS-Windows where the boostrap file loaded too early, before Basilisp was in `sys.path` (#1208)

src/basilisp/core.lpy

@@ -4950,14 +4950,26 @@
 (defn ns-map
   "Return a map of all the mapped symbols in the namespace.
 
-  Includes the return values of :lpy:fn:`ns-interns` and :lpy:fn:`ns-refers` in one
-  map."
+  Includes the return values of :lpy:fn:`ns-interns`, :lpy:fn:`ns-refers`, and
+  :lpy:fn:`ns-imports` in one map.
+
+  .. note::
+
+     It is possible that the same symbol is mapped to an interned name, a referred
+     name, an imported name, or an import-referred name. They are stored in separate
+     collections in each namespace and Basilisp symbol resolution rules determine the
+     precedence. This function returns the combined set of all mapped symbols in a
+     single map and therefore symbols defined in multiple maps will only show one
+     value. Inspecting the contents of each of the component maps will show all
+     mappings, including those that were overwritten by the merge operation in this
+     function."
   ([] (ns-map *ns*))
   ([ns]
    (let [resolved-ns (the-ns ns)]
      (merge
-      (ns-interns resolved-ns)
-      (ns-refers resolved-ns)))))
+      (ns-imports resolved-ns)
+      (ns-refers resolved-ns)
+      (ns-interns resolved-ns)))))
 
 (defn ^:inline ns-resolve
   "Return the Var which will be resolved by the symbol in the given namespace."

src/basilisp/lang/compiler/analyzer.py

@@ -175,9 +175,11 @@
 FINALLY = kw.keyword("finally")
 
 # Constants used in analyzing
+ALL = kw.keyword("all")
 AS = kw.keyword("as")
 IMPLEMENTS = kw.keyword("implements")
 INTERFACE = kw.keyword("interface")
+REFER = kw.keyword("refer")
 STAR_STAR = sym.symbol("**")
 _DOUBLE_DOT_MACRO_NAME = ".."
 _BUILTINS_NS = "python"
@@ -2571,7 +2573,7 @@ def _do_warn_on_import_or_require_name_clash(
 def _import_ast(form: ISeq, ctx: AnalyzerContext) -> Import:
     assert form.first == SpecialForm.IMPORT
 
-    aliases = []
+    aliases, refers, refer_all = [], [], False
     for f in form.rest:
         if isinstance(f, sym.Symbol):
             module_name = f
@@ -2588,40 +2590,80 @@ def _import_ast(form: ISeq, ctx: AnalyzerContext) -> Import:
                 symbol_table=ctx.symbol_table.context_boundary,
             )
         elif isinstance(f, vec.PersistentVector):
-            if len(f) != 3:
+            if len(f) < 1:
                 raise ctx.AnalyzerException(
-                    "import alias must take the form: [module :as alias]", form=f
+                    "import alias must take the form: [module :as alias :refer [...]]",
+                    form=f,
                 )
             module_name = f.val_at(0)  # type: ignore[assignment]
             if not isinstance(module_name, sym.Symbol):
                 raise ctx.AnalyzerException(
                     "Python module name must be a symbol", form=f
                 )
-            if not AS == f.val_at(1):
+
+            try:
+                opts = lmap.hash_map(*f[1:])
+            except IndexError:
                 raise ctx.AnalyzerException(
-                    "expected :as alias for Python import", form=f
+                    "Expected options: ':as alias' or ':refer [...]'", form=f
                 )
-            module_alias_sym = f.val_at(2)
-            if not isinstance(module_alias_sym, sym.Symbol):
+
+            if not {AS, REFER}.issuperset(set(opts.keys())):
                 raise ctx.AnalyzerException(
-                    "Python module alias must be a symbol", form=f
+                    f"Unexpected import options: {lset.set(opts.keys())}", form=f
                 )
-            module_alias = module_alias_sym.name
-            if "." in module_alias:
-                raise ctx.AnalyzerException(
-                    "Python module alias must not contain '.'", form=f
+
+            if (module_alias_sym := opts.val_at(AS)) is not None:
+                if not isinstance(module_alias_sym, sym.Symbol):
+                    raise ctx.AnalyzerException(
+                        "Python module alias must be a symbol", form=f
+                    )
+                module_alias = module_alias_sym.name
+                if "." in module_alias:
+                    raise ctx.AnalyzerException(
+                        "Python module alias must not contain '.'", form=f
+                    )
+
+                ctx.put_new_symbol(
+                    module_alias_sym,
+                    Binding(
+                        form=module_alias_sym,
+                        name=module_alias,
+                        local=LocalType.IMPORT,
+                        env=ctx.get_node_env(),
+                    ),
+                    symbol_table=ctx.symbol_table.context_boundary,
                 )
+            else:
+                module_alias = module_name.name
 
-            ctx.put_new_symbol(
-                module_alias_sym,
-                Binding(
-                    form=module_alias_sym,
-                    name=module_alias,
-                    local=LocalType.IMPORT,
-                    env=ctx.get_node_env(),
-                ),
-                symbol_table=ctx.symbol_table.context_boundary,
-            )
+            if (module_refers := opts.val_at(REFER)) is not None:
+                if ALL == module_refers:
+                    refer_all = True
+                else:
+                    if not isinstance(module_refers, vec.PersistentVector):
+                        raise ctx.AnalyzerException(
+                            "Python module refers must be a vector of symbols",
+                            form=module_refers,
+                        )
+
+                    for refer in module_refers:
+                        if not isinstance(refer, sym.Symbol):
+                            raise ctx.AnalyzerException(
+                                "Python module refer name must be a symbol", form=refer
+                            )
+                        refers.append(refer.name)
+
+                        ctx.put_new_symbol(
+                            refer,
+                            Binding(
+                                form=refer,
+                                name=refer.name,
+                                local=LocalType.IMPORT,
+                                env=ctx.get_node_env(),
+                            ),
+                            symbol_table=ctx.symbol_table.context_boundary,
+                        )
         else:
             raise ctx.AnalyzerException("symbol or vector expected for import*", form=f)
 
@@ -2643,6 +2685,8 @@ def _import_ast(form: ISeq, ctx: AnalyzerContext) -> Import:
     return Import(
         form=form,
         aliases=aliases,
+        refers=refers,
+        refer_all=refer_all,
         env=ctx.get_node_env(pos=ctx.syntax_position),
     )
 

src/basilisp/lang/compiler/generator.py

@@ -2409,6 +2409,24 @@ def _import_to_py_ast(ctx: GeneratorContext, node: Import) -> GeneratedPyAST[ast
                 ),
             )
         )
+
+        if node.refer_all:
+            deps.append(
+                ast.ImportFrom(
+                    module=safe_name,
+                    names=[ast.alias(name="*")],
+                    level=0,
+                )
+            )
+        elif node.refers:
+            deps.append(
+                ast.ImportFrom(
+                    module=safe_name,
+                    names=[ast.alias(name=munge(name)) for name in node.refers],
+                    level=0,
+                )
+            )
+
         last = ast.Name(id=py_import_alias, ctx=ast.Load())
 
         deps.append(

src/basilisp/lang/compiler/nodes.py

@@ -612,6 +612,8 @@ class If(Node[SpecialForm]):
 class Import(Node[SpecialForm]):
     form: SpecialForm
     aliases: Iterable["ImportAlias"]
+    refers: Iterable["str"]
+    refer_all: bool
     env: NodeEnv = attr.field(hash=False)
     children: Sequence[kw.Keyword] = vec.EMPTY
     op: NodeOp = NodeOp.IMPORT