Merge branch 'master' of github.com:clojure/clojurescript

Author: swannodette

samples/repl/src/repl/foo.cljs

@@ -0,0 +1,4 @@
+(ns repl.foo)
+
+(defn bar [a b]
+  (+ a b))

src/clj/cljs/analyzer.clj

@@ -429,6 +429,8 @@
 (defn confirm-ns [env ns-sym]
   (when (and (nil? (get '#{cljs.core goog Math goog.string} ns-sym))
              (nil? (get (-> env :ns :requires) ns-sym))
+             ;; something else may have loaded the namespace, i.e. load-file
+             (nil? (get-in @env/*compiler* [::namespaces ns-sym]))
              ;; macros may refer to namespaces never explicitly required
              ;; confirm that the library at least exists
              (nil? (io/resource (util/ns->relpath ns-sym))))
@@ -1473,6 +1475,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 +1484,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 +1506,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 +1545,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

@@ -302,8 +302,12 @@
                      :column   column'}
                     (when url
                       {:url url}))))]
-          ;; take each non-nil :call and merge it into :function one-level up
-          (map merge
+          ;; take each non-nil :call and optionally merge it into :function one-level up
+          ;; to avoid replacing with local symbols, we only replace munged name if we can munge call symbol back to it
+          (map #(merge-with (fn [munged-fn-name unmunged-call-name]
+                              (if (= munged-fn-name (string/replace (cljs.compiler/munge unmunged-call-name) "." "$"))
+                                unmunged-call-name
+                                munged-fn-name)) %1 %2)
             (map #(dissoc % :call) with-calls)
             (concat (rest (map #(if (:call %)
                                  (hash-map :function (:call %))
@@ -467,14 +471,21 @@
 ;; TODO: this should probably compile dependencies - David
 
 (defn load-file
-  ([repl-env f] (load-file repl-env f nil))
+  ([repl-env f] (load-file repl-env f *repl-opts*))
   ([repl-env f opts]
     (if (:output-dir opts)
-      (let [src (if (util/url? f) f (io/resource f))
+      (let [src (cond
+                  (util/url? f) f
+                  (.exists (io/file f)) (io/file f)
+                  :else (io/resource f))
             compiled (cljsc/compile src
                        (assoc opts
                          :output-file
                          (cljsc/src-file->target-file src)))]
+        ;; make sure it's been analyzed, this is because if it's already compiled
+        ;; cljs.compiler/compile-file won't do anything, good for builds,
+        ;; but a bit annoying here
+        (ana/analyze-file src opts)
         (-evaluate repl-env f 1 (cljsc/add-dep-string opts compiled))
         (-evaluate repl-env f 1 (cljsc/src-file->goog-require src)))
       (binding [ana/*cljs-ns* 'cljs.user]
@@ -515,6 +526,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
@@ -574,43 +611,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)