imports-and-refers-analysis: remove tracking and caching

Tracking was excessively obstrusive (it monkey-patched clojure.repl) and coupled (to nrepl middleware).

Now `symbols->ns-syms` doesn't use caching at all, as it ran in less than 1ms anyway.

Similarly `all-ns-imports` has been removed of any caching. This function was a little more expensive (100ms for a medium-sized project), but parallelizing it brings that cost down to 20ms which seems more than acceptable for an end user.

These changes are backed by `refactor-nrepl.ns.imports-and-refers-analysis-test`.

Author: vemv

src/refactor_nrepl/ns/imports_and_refers_analysis.clj

@@ -4,54 +4,23 @@
 (ns refactor-nrepl.ns.imports-and-refers-analysis
   "Formerly known as `refactor-nrepl.ns.slam.hound.regrow`."
   (:require
-   [nrepl.middleware.interruptible-eval :refer [*msg*]]
    [refactor-nrepl.ns.class-search :as class-search]))
 
-(def ^:dynamic *cache* (atom {}))
-(def ^:dynamic *dirty-ns* (atom #{}))
-
-(defn wrap-clojure-repl [f]
-  (fn [& args]
-    (when-let [ns (some-> *msg* :ns symbol find-ns)]
-      (swap! *dirty-ns* conj ns))
-    (apply f args)))
-
-;; XXX remove this if possible, we shouldn't be this sort of stuff.
-(alter-var-root #'clojure.main/repl wrap-clojure-repl)
-
-(defn cache-with-dirty-tracking
-  "The function to be cached, f, should have two signatures. A zero-operand
-  signature which computes the result for all namespaces, and a two-operand
-  version which takes the previously computed result and a list of dirty
-  namespaces, and returns an updated result."
-  [k f]
-  (if *cache*
-    (if-let [cached (get @*cache* k)]
-      (if-let [dirty (seq @*dirty-ns*)]
-        (k (swap! *cache* assoc k (f cached dirty)))
-        cached)
-      (k (swap! *cache* assoc k (f))))
-    (f)))
-
-(defn clear-cache! []
-  (when *cache*
-    (reset! *cache* {})
-    (reset! *dirty-ns* #{})))
-
-(defn- all-ns-imports*
+;; Benefits from `pmap` because ns-imports is somewhat expensive.
+(defn- all-ns-imports
   ([]
-   (all-ns-imports* {} (all-ns)))
+   (all-ns-imports {} (all-ns)))
   ([init namespaces]
-   (reduce (fn [imports ns]
-             (assoc imports ns (ns-imports ns)))
-           init namespaces)))
-
-(defn- all-ns-imports []
-  (cache-with-dirty-tracking :all-ns-imports all-ns-imports*))
-
-(defn- symbols->ns-syms*
+   (->> namespaces
+        (pmap (fn [ns]
+                [ns, (ns-imports ns)]))
+        (into init))))
+
+;; Doesn't need parallelization (unlike `all-ns-imports`),
+;; as this defn is instantaneous.
+(defn- symbols->ns-syms
   ([]
-   (symbols->ns-syms* {} (all-ns)))
+   (symbols->ns-syms {} (all-ns)))
   ([init namespaces]
    (reduce
     (fn [m ns] (let [ns-sym (ns-name ns)]
@@ -61,9 +30,6 @@
                   m (keys (ns-publics ns)))))
     init namespaces)))
 
-(defn- symbols->ns-syms []
-  (cache-with-dirty-tracking :symbols->ns-syms symbols->ns-syms*))
-
 (defn- ns-import-candidates
   "Search (all-ns) for imports that match missing-sym, returning a set of
   class symbols. This is slower than scanning through the list of static