CLJS-1152: (require 'some.ns :reload) causes printing to stop working in browser REPL

REPL require and require-macros now canonicalizes spec into vector form, remove :reload
and :reload-all from spec and instead annotate the spec vector with this information.

Analyzer now checks for reload metadata on specs. If available populates reloads atom
which maps ns and macro nses to reload type.

handle individual ns macro reloads based on reloads map

The ns AST now includes :reloads populated from reloads map

in compiler emit :ns case, reload and reload-all libs based on :reloads information in ns
form AST

Author: dnolen

src/clj/cljs/analyzer.clj

@@ -1473,6 +1473,7 @@
                       :import         (partial parse-import-spec env deps)}
         valid-forms (atom #{:use :use-macros :require :require-macros :import})
         reload (atom {:use nil :require nil :use-macros nil :require-macros nil})
+        reloads (atom {})
         {uses :use requires :require use-macros :use-macros require-macros :require-macros imports :import :as params}
         (reduce
           (fn [m [k & libs]]
@@ -1481,11 +1482,16 @@
             (when-not (@valid-forms k)
               (throw (error env (str "Only one " k " form is allowed per namespace definition"))))
             (swap! valid-forms disj k)
+            ;; check for spec type reloads
             (when-not (= :import k)
               (when (some #{:reload} libs)
                 (swap! reload assoc k :reload))
               (when (some #{:reload-all} libs)
                 (swap! reload assoc k :reload-all)))
+            ;; check for individual ns reloads from REPL interactions
+            (when-let [xs (seq (filter #(-> % meta :reload) libs))]
+              (swap! reloads assoc k
+                (zipmap (map first xs) (map #(-> % meta :reload) xs))))
             (apply merge-with merge m
               (map (spec-parsers k)
                 (remove #{:reload :reload-all} libs))))
@@ -1498,13 +1504,15 @@
     (when *load-macros*
       (load-core)
       (doseq [nsym (vals use-macros)]
-        (let [k (:use-macros @reload)]
+        (let [k (or (:use-macros @reload)
+                    (get-in @reloads [:use-macros nsym]))]
           (if k
             (clojure.core/require nsym k)
             (clojure.core/require nsym))
           (intern-macros nsym k)))
       (doseq [nsym (vals require-macros)]
-        (let [k (:require-macros @reload)]
+        (let [k (or (:require-macros @reload)
+                    (get-in @reloads [:require-macros nsym]))]
           (if k
             (clojure.core/require nsym k)
             (clojure.core/require nsym))
@@ -1535,7 +1543,8 @@
                 ns-info))
             ns-info)]
       (swap! env/*compiler* update-in [::namespaces name] merge ns-info)
-      (merge {:env env :op :ns :form form}
+      (merge {:env env :op :ns :form form
+              :reloads @reloads}
         (cond-> ns-info
           (@reload :use)
           (update-in [:uses]

src/clj/cljs/compiler.clj

@@ -839,46 +839,47 @@
   (emit-wrap env (emits target " = " val)))
 
 (defn load-libs
-  ([libs] (load-libs libs nil))
-  ([libs seen]
-    (let [loaded-libs      (munge 'cljs.core.*loaded-libs*)
-          loaded-libs-temp (munge (gensym 'cljs.core.*loaded-libs*))]
-      (when (-> libs meta :reload-all)
-        (emitln "if(!COMPILED) " loaded-libs-temp " = " loaded-libs " || cljs.core.set();")
-        (emitln "if(!COMPILED) " loaded-libs " = cljs.core.set();"))
-      (doseq [lib (remove (set (vals seen)) (distinct (vals libs)))]
-        (cond
-          (ana/foreign-dep? lib)
-          (let [{:keys [target optimizations]} (get @env/*compiler* :options)]
-            ;; we only load foreign libraries under optimizations :none
-            (when (= :none optimizations)
-              (if (= :nodejs target)
-                ;; under node.js we load foreign libs globally
-                (let [{:keys [js-dependency-index options]} @env/*compiler*
-                      ijs-url (get-in js-dependency-index [(name lib) :url])]
-                  (emitln "cljs.core.load_file(\""
-                    (str (io/file (util/output-directory options) (util/get-name ijs-url)))
-                    "\");"))
-                (emitln "goog.require('" (munge lib) "');"))))
-
-          (-> libs meta :reload)
-          (emitln "goog.require('" (munge lib) "', 'reload');")
-
-          (-> libs meta :reload-all)
-          (emitln "goog.require('" (munge lib) "', 'reload-all');")
-
-          :else
-          (emitln "goog.require('" (munge lib) "');")))
-      (when (-> libs meta :reload-all)
-        (emitln "if(!COMPILED) " loaded-libs " = cljs.core.into(" loaded-libs-temp ", " loaded-libs ");")))))
+  [libs seen reloads]
+  (let [loaded-libs (munge 'cljs.core.*loaded-libs*)
+        loaded-libs-temp (munge (gensym 'cljs.core.*loaded-libs*))]
+    (when (-> libs meta :reload-all)
+      (emitln "if(!COMPILED) " loaded-libs-temp " = " loaded-libs " || cljs.core.set();")
+      (emitln "if(!COMPILED) " loaded-libs " = cljs.core.set();"))
+    (doseq [lib (remove (set (vals seen)) (distinct (vals libs)))]
+      (cond
+        (ana/foreign-dep? lib)
+        (let [{:keys [target optimizations]} (get @env/*compiler* :options)]
+          ;; we only load foreign libraries under optimizations :none
+          (when (= :none optimizations)
+            (if (= :nodejs target)
+              ;; under node.js we load foreign libs globally
+              (let [{:keys [js-dependency-index options]} @env/*compiler*
+                    ijs-url (get-in js-dependency-index [(name lib) :url])]
+                (emitln "cljs.core.load_file(\""
+                  (str (io/file (util/output-directory options) (util/get-name ijs-url)))
+                  "\");"))
+              (emitln "goog.require('" (munge lib) "');"))))
+
+        (or (-> libs meta :reload)
+            (= (get reloads lib) :reload))
+        (emitln "goog.require('" (munge lib) "', 'reload');")
+
+        (or (-> libs meta :reload-all)
+            (= (get reloads lib) :reload-all))
+        (emitln "goog.require('" (munge lib) "', 'reload-all');")
+
+        :else
+        (emitln "goog.require('" (munge lib) "');")))
+    (when (-> libs meta :reload-all)
+      (emitln "if(!COMPILED) " loaded-libs " = cljs.core.into(" loaded-libs-temp ", " loaded-libs ");"))))
 
 (defmethod emit* :ns
-  [{:keys [name requires uses require-macros env]}]
+  [{:keys [name requires uses require-macros reloads env]}]
   (emitln "goog.provide('" (munge name) "');")
   (when-not (= name 'cljs.core)
     (emitln "goog.require('cljs.core');"))
-  (load-libs requires)
-  (load-libs uses requires))
+  (load-libs requires nil (:require reloads))
+  (load-libs uses requires (:use reloads)))
 
 (defmethod emit* :deftype*
   [{:keys [t fields pmasks body]}]

src/clj/cljs/repl.clj

@@ -519,6 +519,32 @@
      ((or (:wrap opts) wrap-fn) form)
      opts)))
 
+(defn canonicalize-specs [specs]
+  (letfn [(canonicalize [quoted-spec-or-kw]
+            (if (keyword? quoted-spec-or-kw)
+              quoted-spec-or-kw
+              (as-> (second quoted-spec-or-kw) spec
+                (if (vector? spec) spec [spec]))))]
+    (map canonicalize specs)))
+
+(defn decorate-specs [specs]
+  (if-let [k (some #{:reload :reload-all} specs)]
+    (->> specs (remove #{k}) (map #(vary-meta % assoc :reload k)))
+    specs))
+
+(comment
+  (canonicalize-specs
+    '['foo.bar '[bar.core :as bar]])
+
+  (canonicalize-specs
+    '['foo.bar '[bar.core :as bar] :reload])
+
+  (map meta
+    (decorate-specs
+      (canonicalize-specs
+        '['foo.bar '[bar.core :as bar] :reload])))
+  )
+
 ;; Special REPL fns, these provide compatiblity with Clojure functions
 ;; that are not possible to reproduce given ClojureScript's compilation model
 ;; All functions should have the following signature
@@ -578,43 +604,31 @@
           (evaluate-form repl-env env "<cljs repl>"
             (with-meta
               `(~'ns ~target-ns
-                 (:require
-                   ~@(map
-                       (fn [quoted-spec-or-kw]
-                         (if (keyword? quoted-spec-or-kw)
-                           quoted-spec-or-kw
-                           (second quoted-spec-or-kw)))
-                       specs)))
+                 (:require ~@(-> specs canonicalize-specs decorate-specs)))
               {:merge true :line 1 :column 1})
             identity opts)
           (when is-self-require?
             (set! ana/*cljs-ns* restore-ns)))))
-     'import
+     'require-macros
      (fn self
        ([repl-env env form]
         (self repl-env env form nil))
        ([repl-env env [_ & specs :as form] opts]
         (evaluate-form repl-env env "<cljs repl>"
           (with-meta
             `(~'ns ~ana/*cljs-ns*
-               (:import
-                 ~@(map
-                     (fn [quoted-spec-or-kw]
-                       (if (keyword? quoted-spec-or-kw)
-                         quoted-spec-or-kw
-                         (second quoted-spec-or-kw)))
-                     specs)))
+               (:require-macros ~@(-> specs canonicalize-specs decorate-specs)))
             {:merge true :line 1 :column 1})
           identity opts)))
-     'require-macros
+     'import
      (fn self
        ([repl-env env form]
         (self repl-env env form nil))
        ([repl-env env [_ & specs :as form] opts]
         (evaluate-form repl-env env "<cljs repl>"
           (with-meta
             `(~'ns ~ana/*cljs-ns*
-               (:require-macros
+               (:import
                  ~@(map
                      (fn [quoted-spec-or-kw]
                        (if (keyword? quoted-spec-or-kw)