[Fix #184] Squashed commit of the following:

commit ff5c4612b8a7eb816905a4c412b6d3f574d47b71
Merge: 10089ca fe6b355
Author: Benedek Fazekas <[email protected]>
Date:   Sun Jan 22 21:04:59 2017 +0000

    Merge branch 'eager-find-classes' of git://github.com/plexus/refactor-nrepl into plexus-eager-find-classes

commit fe6b355
Author: Arne Brasseur <[email protected]>
Date:   Sun Jan 22 12:35:01 2017 +0100

    Cleanup: replace pre-1.2 metadata, prefer reify over proxy

    FileNameFilter is an interface, so reify does the job just fine, no need for
    proxy.

commit 9e8531a
Author: Arne Brasseur <[email protected]>
Date:   Sun Jan 22 12:34:19 2017 +0100

    Add CHANGELOG entry for #184

commit c1838f1
Author: Arne Brasseur <[email protected]>
Date:   Fri Jan 20 21:19:38 2017 +0100

    Remove laziness in Slamhound's "get-available-classes"

    Once the classpath gets big enough, this would cause a stack overflow, which
    from clj-refactor simply shows up as a timeout.

    Instead use transducers over lists as much as possible. Since the collection of
    available classes is only ever traversed sequentially, this provides the best
    performance as well.

Author: benedekfazekas

CHANGELOG.md

@@ -6,6 +6,7 @@
 
 * [#185](https://github.com/clojure-emacs/refactor-nrepl/issues/185) Report throwables of type `Error` instead of swallowing them.
 * [#186](https://github.com/clojure-emacs/refactor-nrepl/issues/186) Make sure `resolve-missing` still works, even if a candidate class has missing dependencies.
+* [#184](https://github.com/clojure-emacs/refactor-nrepl/pull/184) In `resolve-missing`, prevent classpaths with many entries from causing a stack overflow.
 * [clojure-emacs/clj-refactor.el#330](https://github.com/clojure-emacs/clj-refactor.el/issues/332) `clean-ns` removes imported inner inner classes.
 * [clojure-emacs/clj-refactor.el#330](https://github.com/clojure-emacs/clj-refactor.el/issues/330) `clean-ns` ignores namespaced keywords.
 * [#160](https://github.com/clojure-emacs/refactor-nrepl/issues/160) Make `resolve-missing` find newly defined vars and types (clj). Because of a stale cache, newly added vars or types would not be found. This fix takes into account vars/types added by eval-ing code (rescan affected namespace), and by hotloading dependencies (reset the cache).

src/refactor_nrepl/ns/slam/hound/search.clj

@@ -41,7 +41,7 @@
 (defn expand-wildcard
   "Expands a wildcard path entry to its matching .jar files (JDK 1.6+).
   If not expanding, returns the path entry as a single-element vector."
-  [#^String path]
+  [^String path]
   (let [f (File. path)]
     (if (= (.getName f) "*")
       (.. f getParentFile (list jar-filter))
@@ -55,70 +55,73 @@
         (.replace path ".class" ""))
       (.replace File/separator ".")))
 
-(def path-class-files nil)
 (defmulti path-class-files
   "Returns a list of classes found on the specified path location
   (jar or directory), each comprised of a map with the following keys:
     :name  Java class or Clojure namespace name
     :loc   Classpath entry (directory or jar) on which the class is located
     :file  Path of the class file, relative to :loc"
-  (fn [#^File f _]
-    (cond (.isDirectory f)           :dir
-          (jar? f)        :jar
+  (fn [^File f _]
+    (cond (.isDirectory f) :dir
+          (jar? f) :jar
           (class-file? (.getName f)) :class)))
 
-(defmethod path-class-files :default
-  [& _] [])
+(defmethod path-class-files :default [& _] [])
 
 (defmethod path-class-files :jar
   ;; Build class info for all jar entry class files.
-  [#^File f #^File loc]
+  [^File f ^File loc]
   (let [lp (.getPath loc)]
     (try
-      (map class-or-ns-name
-           (filter class-file?
-                   (map #(.getName #^JarEntry %)
-                        (enumeration-seq (.entries (JarFile. f))))))
+      (into ()
+            (comp
+             (map #(.getName ^JarEntry %))
+             (filter class-file?)
+             (map class-or-ns-name))
+            (enumeration-seq (.entries (JarFile. f))))
       (catch Exception e []))))          ; fail gracefully if jar is unreadable
 
 (defmethod path-class-files :dir
   ;; Dispatch directories and files (excluding jars) recursively.
-  [#^File d #^File loc]
-  (let [fs (.listFiles d (proxy [FilenameFilter] []
-                           (accept [d n] (not (jar? (file n))))))]
-    (reduce concat (for [f fs] (path-class-files f loc)))))
+  [^File d ^File loc]
+  (let [fs (.listFiles d (reify FilenameFilter
+                           (accept [_ dir name]
+                             (-> name file jar? not))))]
+    (into () (mapcat #(path-class-files % loc)) fs)))
 
 (defmethod path-class-files :class
   ;; Build class info using file path relative to parent classpath entry
   ;; location. Make sure it decends; a class can't be on classpath directly.
-  [#^File f #^File loc]
+  [^File f ^File loc]
   (let [fp (str f), lp (str loc)
         loc-pattern (re-pattern (Pattern/quote (str "^" loc)))]
     (if (re-find loc-pattern fp)                 ; must be descendent of loc
       (let [fpr (.substring fp (inc (count lp)))]
         [(class-or-ns-name fpr)])
       [])))
 
-(defn scan-paths
-  "Takes one or more classpath strings, scans each classpath entry location, and
-  returns a list of all class file paths found, each relative to its parent
-  directory or jar on the classpath."
-  ([cp]
-     (if cp
-       (let [entries (enumeration-seq
-                      (StringTokenizer. cp File/pathSeparator))
-             locs (mapcat expand-wildcard entries)]
-         (mapcat #(path-class-files % %) locs))
-       ())))
-
-(defn- get-available-classes
-  []
-  (->> (mapcat scan-paths (concat (map #(System/getProperty %) ["sun.boot.class.path"
-                                                                "java.ext.dirs"
-                                                                "java.class.path"])
-                                  (map #(.getName %) (cp/classpath-jarfiles))))
-       (remove clojure-fn-file?)
-       (map symbol)))
+(defn path-entries-seq
+  "Split a string on the 'path separator', i.e. ':'. Used for splitting multiple
+  classpath entries."
+  [path-str]
+  (enumeration-seq
+   (StringTokenizer. path-str File/pathSeparator)))
+
+(defn all-classpath-entries []
+  (into (map #(System/getProperty %) ["sun.boot.class.path"
+                                      "java.ext.dirs"
+                                      "java.class.path"])
+        (map #(.getName %) (cp/classpath-jarfiles))))
+
+(defn- get-available-classes []
+  (into ()
+        (comp (mapcat path-entries-seq)
+              (mapcat expand-wildcard)
+              (mapcat #(path-class-files % %))
+              (remove clojure-fn-file?)
+              (distinct)
+              (map symbol))
+        (all-classpath-entries)))
 
 (def available-classes
   (get-available-classes))