expander: bug: atoms in quasiliteral.

Via macros, atoms can sneak into a quasiliteral which then
blow up because they get treated as strings without being
converted.

Example:

  (defmacro two () 2)

  `@(two)xyz` -> ;; error

The expansion produces the invalid form, in which the 2
is subsequently treated as a string.

  (sys:quasi 2 "xyz")

On the other hand, symbol macros don't have this problem:

  (defsymacro two 2)

  `@{two}xyz` -> "2xyz"

The reason is that the (sys:var two) syntax will expand to
(sys:var 2), and not 2.

The straightforward, consistent fix is to ensure that the
first case will also go to (sys:var 2).

* eval.c (expand_quasi): If the expanded form is an atom which
is not a bindable symbol, wrap it in a sys:var.

* tests/012/quasi.tl: Test cases added.
Also adding a compilation test for this file, cribbed from
patmatch.tl.

1 files changed, 15 insertions, 0 deletions

diff --git a/tests/012/quasi.tl b/tests/012/quasi.tl
index 276d5395..1cb24578 100644
--- a/tests/012/quasi.tl
+++ b/tests/012/quasi.tl
@@ -36,3 +36,18 @@
     (let ((s))
       (mapcar (ret `<@{(push (inc @1) s) d}>`) (range 0 2))))
   ("<1>" "<2-1>" "<3-2-1>"))
+
+(test
+  (symacrolet ((two 2))
+    `@{two}abc`)
+  "2abc")
+
+(test
+  (macrolet ((two () 2))
+    `@(two)abc`)
+  "2abc")
+
+(compile-only
+  (eval-only
+    (compile-file (base-name *load-path*) "temp.tlo")
+    (remove-path "temp.tlo")))