Fix line and column metadata (#454)

* Fix line and column metadata

* Fetch metadata from various places as needed

* Format and typecheck

* Allow None type in IPersistentMap.cons

Author: chrisrink10

src/basilisp/core.lpy

@@ -1279,11 +1279,6 @@
       (throw
        (python/ValueError (str "cannot coerce " (python/repr x) " to byte"))))))
 
-(defn boolean
-  "Coerce x to a boolean."
-  [x]
-  (python/bool x))
-
 (defn char
   "Coerce x to a string of length 1.
 

src/basilisp/lang/compiler/analyzer.py

@@ -651,7 +651,19 @@ def _def_ast(  # pylint: disable=too-many-branches,too-many-locals
     current_ns = ctx.current_ns
 
     # Attach metadata relevant for the current process below.
-    def_loc = _loc(form) or (None, None)
+    #
+    # The reader line/col metadata will be attached to the form itself in the
+    # happy path case (top-level bare def or top-level def returned from a
+    # macro). Less commonly, we may have to rely on metadata attached to the
+    # def symbol if, for example, the def form is returned by a macro wrapped
+    # in a do or let form. In that case, the macroexpansion process won't have
+    # any metadata to pass along to the expanded form, but the symbol itself
+    # is likely to have metadata. In rare cases, we may not be able to get
+    # any metadata. This may happen if the form and name were both generated
+    # programmatically.
+    def_loc = _loc(form) or _loc(name) or (None, None)
+    if def_loc == (None, None):
+        logger.warning(f"def line and column metadata not provided for Var {name}")
     def_node_env = ctx.get_node_env()
     def_meta = _clean_meta(
         name.meta.update(  # type: ignore [union-attr]
@@ -1670,6 +1682,11 @@ def _invoke_ast(ctx: AnalyzerContext, form: Union[llist.List, ISeq]) -> Node:
                 try:
                     macro_env = ctx.symbol_table.as_env_map()
                     expanded = fn.var.value(macro_env, form, *form.rest)
+                    if isinstance(expanded, IWithMeta) and isinstance(form, IMeta):
+                        old_meta = expanded.meta
+                        expanded = expanded.with_meta(
+                            old_meta.cons(form.meta) if old_meta else form.meta
+                        )
                     with ctx.macro_ns(
                         fn.var.ns if fn.var.ns is not ctx.current_ns else None
                     ):

src/basilisp/lang/interfaces.py

@@ -198,7 +198,7 @@ class IPersistentMap(ICounted, IAssociative[K, V]):
 
     @abstractmethod
     def cons(  # type: ignore[override]
-        self: T_map, *elems: Union[IMapEntry[K, V], "IPersistentMap[K, V]"]
+        self: T_map, *elems: Union[IMapEntry[K, V], "IPersistentMap[K, V]", None]
     ) -> T_map:
         raise NotImplementedError()
 

src/basilisp/test.lpy

@@ -134,7 +134,7 @@
   Tests defined by deftest will be run by default by the PyTest test
   runner using Basilisp's builtin PyTest hook."
   [name-sym & body]
-  (let [test-name-sym (with-meta name-sym {:test true})
+  (let [test-name-sym (vary-meta name-sym assoc :test true)
         test-name-str (name test-name-sym)
         test-ns-name  `(quote ~(symbol (name *ns*)))]
     `(do

tests/basilisp/compiler_test.py

@@ -1776,6 +1776,8 @@ def test_macroexpand_1(self, example_macro):
         )
 
     def test_macroexpand(self, example_macro):
+        meta = lmap.map({reader.READER_LINE_KW: 1, reader.READER_COL_KW: 1})
+
         assert llist.l(
             sym.symbol("def"),
             sym.symbol("child"),
@@ -1785,16 +1787,18 @@ def test_macroexpand(self, example_macro):
                 vec.v(sym.symbol("&env"), sym.symbol("&form")),
                 llist.l(sym.symbol("fn", ns="basilisp.core"), vec.Vector.empty()),
             ),
-        ) == compiler.macroexpand(llist.l(sym.symbol("parent")))
+        ) == compiler.macroexpand(llist.l(sym.symbol("parent"), meta=meta))
 
         assert llist.l(sym.symbol("add", ns="operator"), 1, 2) == compiler.macroexpand(
-            llist.l(sym.symbol("add", ns="operator"), 1, 2)
+            llist.l(sym.symbol("add", ns="operator"), 1, 2, meta=meta)
         )
         assert sym.symbol("map") == compiler.macroexpand(sym.symbol("map"))
         assert llist.l(sym.symbol("map")) == compiler.macroexpand(
-            llist.l(sym.symbol("map"))
+            llist.l(sym.symbol("map"), meta=meta)
+        )
+        assert vec.Vector.empty() == compiler.macroexpand(
+            vec.Vector.empty().with_meta(meta)
         )
-        assert vec.Vector.empty() == compiler.macroexpand(vec.Vector.empty())
 
         assert sym.symbol("non-existent-symbol") == compiler.macroexpand(
             sym.symbol("non-existent-symbol")