consistently use cljs.compiler/munge over clojure.core/munge

Author: swannodette

src/main/clojure/cljs/module_graph.cljc

@@ -26,7 +26,7 @@
                       (filter
                         (fn [source]
                           (when (some #(.startsWith ^String % matcher)
-                                  (map (comp str munge) (:provides source)))
+                                  (map (comp str comp/munge) (:provides source)))
                             source)))
                       sources)]
         (when-not (empty? matches)
@@ -36,7 +36,7 @@
                            (let [matcher
                                  (into #{}
                                    [(name entry) (name (comp/munge entry))])]
-                             (when (some matcher (map (comp str munge) (:provides source)))
+                             (when (some matcher (map (comp str comp/munge) (:provides source)))
                                source)))
                          sources)]
         #{input}))))
@@ -51,7 +51,7 @@
     (fn [ret module-name module]
       (assoc ret module-name
                  (update module :entries
-                   (fn [es] (into #{} (map (comp str munge)) es)))))
+                   (fn [es] (into #{} (map (comp str comp/munge)) es)))))
     {} modules))
 
 (defn add-cljs-base
@@ -104,10 +104,10 @@
         (map
           (fn [provide]
             (vector
-              (-> provide munge str)
+              (-> provide comp/munge str)
               (-> input
-                (update :provides #(into [] (map (comp str munge)) %))
-                (update :requires #(into [] (map (comp str munge)) %))))))
+                (update :provides #(into [] (map (comp str comp/munge)) %))
+                (update :requires #(into [] (map (comp str comp/munge)) %))))))
         provides))
     {} inputs))
 
@@ -121,7 +121,7 @@
 (defn deps-for-entry
   "Return all dependencies for an entry using a compiler inputs index."
   [entry indexed-inputs]
-  (map #(-> % munge str) (deps-for entry indexed-inputs :requires)))
+  (map #(-> % comp/munge str) (deps-for entry indexed-inputs :requires)))
 
 (defn deps-for-module
   "Return all dependencies of a module using compiler :modules."
@@ -199,7 +199,7 @@
                    (into {} (map assign1) d->ms)
                    (into {} (map assign1) e->ms))
         orphans  (zipmap
-                   (map (comp str munge first :provides)
+                   (map (comp str comp/munge first :provides)
                      (-> (reduce-kv (fn [m k _] (dissoc m k)) index assigned)
                        vals set))
                    (repeat :cljs-base))]
@@ -213,7 +213,7 @@
                    (reduce
                      (fn [[ret n] {:keys [provides]}]
                        [(merge ret
-                          (zipmap (map (comp str munge) provides) (repeat n)))
+                          (zipmap (map (comp str comp/munge) provides) (repeat n)))
                         (inc n)])
                      [{} 0] inputs))
         modules' (-> modules normalize add-cljs-base add-cljs-base-dep)
@@ -348,7 +348,7 @@
   "Given an entry find the module it belongs to."
   [entry modules]
   (let [modules' (normalize modules)
-        entry'   (str (munge entry))]
+        entry'   (str (comp/munge entry))]
     (->> modules'
       (some
         (fn [[module-name {:keys [entries]} :as me]]