CLJS-2667: Non-Node REPL Regression - direct require of JS modules no longer works

cljs.closure/compile-input no longer needs :seed bit as
cljs.repl/load-namespaces now handles all input types.

change cljs.compiler/load-libs, global-exports-libs and libs-to-load
are not mutually exclusive.

cljs.repl/load-namespaces can now handle different types of requires
directly. If ClojureScript namespace use the normal build pipeline. If
JavaScript namespace simply add any JS dependencies and ensure the files
are on disk. Removed old hack where we had to read the file system to
get the updated module name. This possible because we now invoke
handle-js-modules (and include transitive module deps) in
cljs.repl/evaluate-form, thus all JS module requires will already be
remapped by the time we get to cljs.repl/load-namespaces.

Author: swannodette

src/main/clojure/cljs/closure.clj

@@ -2665,7 +2665,7 @@
   (env/ensure
     (let [sources (-> inputs (add-dependency-sources opts))
           opts    (handle-js-modules opts sources env/*compiler*)
-          sources (-> (remove (comp #{:seed} :type) sources)
+          sources (-> sources
                     deps/dependency-order
                     (compile-sources false opts)
                     (#(map add-core-macros-if-cljs-js %))

src/main/clojure/cljs/compiler.cljc

@@ -1127,7 +1127,7 @@
                                      (let [{node-libs true libs-to-load false} (group-by ana/node-module-dep? libs)]
                                        [node-libs libs-to-load])
                                      [nil libs]))
-        {global-exports-libs true libs-to-load false} (group-by ana/dep-has-global-exports? libs-to-load)]
+        global-exports-libs (filter ana/dep-has-global-exports? libs-to-load)]
     (when (-> libs meta :reload-all)
       (emitln "if(!COMPILED) " loaded-libs-temp " = " loaded-libs " || cljs.core.set([\"cljs.core\"]);")
       (emitln "if(!COMPILED) " loaded-libs " = cljs.core.set([\"cljs.core\"]);"))

src/main/clojure/cljs/repl.cljc

@@ -190,36 +190,50 @@
      (assoc :output-dir
             (or (:output-dir opts) (get repl-env :working-dir ".repl"))))))
 
+(defn add-url [ijs]
+  (cond-> ijs
+    (not (contains? ijs :url))
+    (assoc :url (io/resource (:file ijs)))))
+
+(defn ns->input [ns opts]
+  (if-let [input (some-> (util/ns->source ns) (ana/parse-ns opts))]
+    input
+    (if-let [input (some->
+                     (get-in @env/*compiler*
+                       [:js-dependency-index (str ns)])
+                     add-url)]
+      input
+      (throw
+        (ex-info (str ns " does not exist")
+          {::error :invalid-ns})))))
+
+(defn compilable? [input]
+  (contains? input :source-file))
+
 (defn load-namespace
   "Load a namespace and all of its dependencies into the evaluation environment.
   The environment is responsible for ensuring that each namespace is loaded once and
   only once."
   ([repl-env ns] (load-namespace repl-env ns nil))
   ([repl-env ns opts]
    (let [ns (if (and (seq? ns) (= (first ns) 'quote)) (second ns) ns)
-         ;; We need to use a seed because many things (npm deps etc.) cannot be
-         ;; *directly* compiled, they must be a part of some ClojureScript ns
-         ;; form - thus we fabricate a seed
-         sources (->> (cljsc/compile-inputs
-                        [{:requires [(name ns)] :type :seed}]
-                        (merge (env->opts repl-env) opts))
-                   (remove (comp #{["goog"]} :provides)))]
+         input (ns->input ns opts)
+         sources (if (compilable? input)
+                   (->> (cljsc/compile-inputs [input]
+                          (merge (env->opts repl-env) opts))
+                     (remove (comp #{["goog"]} :provides)))
+                   (map #(cljsc/source-on-disk opts %)
+                     (cljsc/add-js-sources [input] opts)))]
+     (when (:repl-verbose opts)
+       (println (str "load-namespace " ns " , compiled:") (map :provides sources)))
      (if (:output-dir opts)
        ;; REPLs that read from :output-dir just need to add deps,
        ;; environment will handle actual loading - David
        (let [sb (StringBuffer.)]
          (doseq [source sources]
-           (when (:repl-verbose opts)
-             (println "Loading:" (:provides source)))
-           ;; Need to get :requires and :provides from compiled source
-           ;; not from our own compilation, this issue oddly doesn't seem to
-           ;; affect compiled ClojureScript, should be cleaned up so we
-           ;; don't need this step here - David
            (with-open [rdr (io/reader (:url source))]
              (.append sb
-               (cljsc/add-dep-string opts
-                 (merge source
-                   (deps/parse-js-ns (line-seq rdr)))))))
+               (cljsc/add-dep-string opts source))))
          (when (:repl-verbose opts)
            (println (.toString sb)))
          (-evaluate repl-env "<cljs repl>" 1 (.toString sb)))