:require-global

Support :require syntax for libraries external to the build

- add external-dep? helper for new :external? property for :foreign
libs
- Need to implicitly create :external? :foreign libs from
:require-global specs
- elide these libs from the js inputs, they have no files
- these libs don't need `goog.require`
- add basic unit tests

Author: swannodette

src/main/clojure/cljs/analyzer.cljc

@@ -2781,6 +2781,17 @@
            (if (and (.exists cljcf) (.isFile cljcf))
              cljcf))))))
 
+(defn external-dep?
+  "Returns true if the library is an :external? foreign dep. This means no source is provided
+  for the library, i.e. it will be provided by some script tag on the page, or loaded by some
+  other means into the JS execution environment."
+  #?(:cljs {:tag boolean})
+  [dep]
+  (let [js-index (:js-dependency-index @env/*compiler*)]
+    (if-some [[_ {:keys [foreign external?]}] (find js-index (name (-> dep lib&sublib first)))]
+      (and foreign external?)
+      false)))
+
 (defn foreign-dep?
   #?(:cljs {:tag boolean})
   [dep]
@@ -3083,13 +3094,10 @@
                           [new-name (symbol "js" (str orig))]))
                    rename)}))))
 
-(defn global-lib [lib]
-  (symbol "js" (str lib)))
-
 (defn parse-global-require-spec
-  [env aliases spec]
+  [env cenv deps aliases spec]
   (if (or (symbol? spec) (string? spec))
-    (recur env aliases [spec])
+    (recur env cenv deps aliases [spec])
     (do
       (basic-validate-ns-spec env false spec)
       (let [[lib & opts] spec
@@ -3120,18 +3128,25 @@
             (error env
               (parse-ns-error-msg spec
                 ":refer must be followed by a sequence of symbols in :require / :require-macros"))))
-        (merge
-          (when (some? alias)
-            {rk (merge {alias (global-lib lib)} {lib (global-lib lib)})})
-          (when (some? referred-without-renamed)
-            {uk (apply hash-map (interleave referred-without-renamed (repeat (global-lib lib))))})
-          (when (some? renamed)
-            {renk (reduce (fn [m [original renamed]]
-                            (when-not (some #{original} referred)
-                              (throw (error env
-                                       (str "Renamed symbol " original " not referred"))))
-                            (assoc m renamed (symbol "js" (str (str lib) "." (str original)))))
-                    {} renamed)}))))))
+        (swap! deps conj lib)
+        (let [ret (merge
+                    (when (some? alias)
+                      {rk (merge {alias lib} {lib lib})})
+                    (when (some? referred-without-renamed)
+                      {uk (apply hash-map (interleave referred-without-renamed (repeat lib)))})
+                    (when (some? renamed)
+                      {renk (reduce (fn [m [original renamed]]
+                                      (when-not (some #{original} referred)
+                                        (throw (error env
+                                                 (str "Renamed symbol " original " not referred"))))
+                                      (assoc m renamed (symbol (str lib) (str original))))
+                              {} renamed)}))]
+          (swap! cenv assoc-in [:js-dependency-index (str lib)]
+            {:external?      true
+             :foreign        true
+             :provides       [(str lib)]
+             :global-exports {lib lib}})
+          ret)))))
 
 (defn parse-require-spec [env macros? deps aliases spec]
   (if (or (symbol? spec) (string? spec))
@@ -3435,7 +3450,7 @@
                         :use-macros     (comp (partial parse-require-spec env true deps aliases)
                                           (partial use->require env))
                         :import         (partial parse-import-spec env deps)
-                        :require-global #(parse-global-require-spec env aliases %)}
+                        :require-global #(parse-global-require-spec env env/*compiler* deps aliases %)}
           valid-forms  (atom #{:use :use-macros :require :require-macros :require-global :import})
           reload       (atom {:use nil :require nil :use-macros nil :require-macros nil})
           reloads      (atom {})

src/main/clojure/cljs/closure.clj

@@ -1127,13 +1127,17 @@
   (let [requires    (set (mapcat deps/-requires inputs))
         required-js (js-dependencies opts requires)]
     (concat
-      (map
-        (fn [{:keys [foreign url file provides requires] :as js-map}]
-          (let [url (or url (io/resource file))]
-            (merge
-              (javascript-file foreign url provides requires)
-              js-map)))
-        required-js)
+      (->> required-js
+        ;; :foreign-libs which declare :external? have no sources (they are included
+        ;; on the page via some script tag we'll never see). :require-global libs are
+        ;; implicit :foreign-libs where :external? is true
+        (remove :external?)
+        (map
+          (fn [{:keys [foreign url file provides requires] :as js-map}]
+            (let [url (or url (io/resource file))]
+              (merge
+                (javascript-file foreign url provides requires)
+                js-map)))))
       (when (-> @env/*compiler* :options :emit-constants)
         [(constants-javascript-file opts)])
       inputs)))

src/main/clojure/cljs/compiler.cljc

@@ -1367,7 +1367,10 @@
                          escape-string
                          wrap-in-double-quotes)
                        ");"))
-                   (emitln "goog.require('" (munge lib) "');"))))]
+                   (if-not (ana/external-dep? lib)
+                     (emitln "goog.require('" (munge lib) "');")
+                     ;; TODO: validate the lib exists
+                     ))))]
             :cljs
             [(and (ana/foreign-dep? lib)
                   (not (keyword-identical? optimizations :none)))

src/test/clojure/cljs/analyzer_tests.clj

@@ -395,18 +395,23 @@
              :rename {JSSymbol js/Symbol}}))))
 
 (deftest test-parse-require-global
-  (let [parsed (ana/parse-global-require-spec {} (atom {:fns {}})
-                '[React :refer [createElement] :as react])]
+  (let [cenv   (atom {})
+        deps   (atom [])
+        parsed (ana/parse-global-require-spec {} cenv deps (atom {:fns {}}) 
+                 '[React :refer [createElement] :as react])]
+    (println (pr-str @cenv) (pr-str @deps))
     (is (= parsed
-          '{:require {react js/React
-                      React js/React}
-            :use  {createElement js/React}})))
-  (let [parsed (ana/parse-global-require-spec {} (atom {:fns {}})
-                '[React :refer [createElement] :rename {createElement create} :as react])]
+          '{:require {react React
+                      React React}
+            :use  {createElement React}})))
+  (let [cenv   (atom {})
+        deps   (atom [])
+        parsed (ana/parse-global-require-spec {} cenv deps (atom {:fns {}})
+                 '[React :refer [createElement] :rename {createElement create} :as react])]
     (is (= parsed
-          '{:require {react js/React
-                      React js/React}
-            :rename  {create js/React.createElement}}))))
+          '{:require {react React
+                      React React}
+            :rename  {create React/createElement}}))))
 
 (deftest test-cljs-1785-js-shadowed-by-local
   (let [ws (atom [])]
@@ -1582,7 +1587,7 @@
                         '(ns foo.core
                            (:require-global [React :as react :refer [createElement]]))))]
       (is (= (:requires parsed-ns)
-             '{React js/React
-               react js/React}))
+             '{React React
+               react React}))
       (is (= (:uses parsed-ns)
-             '{createElement js/React})))))
+             '{createElement React})))))