CLJS-1542: Self-host: cljs/compile-str not handling errors properly

If you use cljs.js/compile-str on a form that cannot be analyzed, then
the analysis error is wrapped, but inadvertently passed on to
compilation as an AST structure. This results in the compiler derailing
because it tries to process a nil :op.

The fix is to employ the same pattern used in cljs.js/eval-str, namely:
Wrap successful analysis in a {:value ast} map, and then additionally
check for an :error key in the result and cb early, otherwise extract
the :value and continue on to compilation.

Author: mfikes

src/main/cljs/cljs/js.cljs

@@ -621,20 +621,23 @@
                  (let [aenv (cond-> (assoc aenv :ns (ana/get-namespace ana/*cljs-ns*))
                               (:context opts) (assoc :context (:context opts))
                               (:def-emits-var opts) (assoc :def-emits-var true))
-                       ast  (try
-                              (ana/analyze aenv form nil opts)
+                       res  (try
+                              {:value (ana/analyze aenv form nil opts)}
                               (catch :default cause
                                 (wrap-error
                                   (ana/error aenv
                                     (str "Could not compile " name) cause))))]
-                   (.append sb (with-out-str (comp/emit ast)))
-                   (if (= :ns (:op ast))
-                     (ns-side-effects bound-vars aenv ast opts
-                       (fn [res]
-                         (if (:error res)
-                           (cb res)
-                           (compile-loop (:name ast)))))
-                     (recur ns)))
+                   (if (:error res)
+                     (cb res)
+                     (let [ast (:value res)]
+                       (.append sb (with-out-str (comp/emit ast)))
+                       (if (= :ns (:op ast))
+                         (ns-side-effects bound-vars aenv ast opts
+                           (fn [res]
+                             (if (:error res)
+                               (cb res)
+                               (compile-loop (:name ast)))))
+                         (recur ns)))))
                  (do
                    (when (:source-map opts)
                      (append-source-map env/*compiler*

src/test/self/self_host/test.cljs

@@ -52,7 +52,7 @@
 
 (deftest test-analyze-str
   (async done
-    (let [l (latch 2 done)]
+    (let [l (latch 3 done)]
       (cljs/analyze-str st "(+ 1 1)" nil
         {:context :expr}
         (fn [{:keys [error value]}]
@@ -63,11 +63,17 @@
         {:context :expr}
         (fn [{:keys [error value]}]
           (is (nil? error))
+          (inc! l)))
+      (cljs/analyze-str st "(fn [] (let [x 7 y] (prn y)))" nil
+        {:context :expr}
+        (fn [{:keys [error value]}]
+          (is (nil? value))
+          (is (= "Could not analyze " (ex-message error)))
           (inc! l))))))
 
 (deftest test-compile-str
   (async done
-    (let [l (latch 6 done)]
+    (let [l (latch 7 done)]
       (cljs/compile-str st "(+ 1 1)"
         (fn [{:keys [error value]}]
           (is (nil? error))
@@ -103,6 +109,12 @@
         (fn [{:keys [error value]}]
           (is (nil? error))
           (is (string/index-of value "cljs.user.foo((1),(2))"))
+          (inc! l)))
+      (cljs/compile-str st "(fn [] (let [x 7 y] (prn y)))" nil
+        {:context :expr}
+        (fn [{:keys [error value]}]
+          (is (nil? value))
+          (is (= "Could not compile " (ex-message error)))
           (inc! l))))))
 
 (deftest test-eval-str