find used vars.clj

(do                                                                                                                                                                                                                                            
  (prn *ns*)                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                               
  (require  '[clojure.tools.namespace.find :as ns-find]                                                                                                                                                                                        
            '[clojure.java.io :as io]                                                                                                                                                                                                          
            '[clojure.tools.reader :as rdr]                                                                                                                                                                                                    
            '[clojure.tools.analyzer.jvm :as ana.jvm]                                                                                                                                                                                          
            '[clojure.tools.analyzer.ast :as walk]                                                                                                                                                                                             
            '[clojure.tools.analyzer.passes.jvm.emit-form :as e])                                                                                                                                                                              
                                                                                                                                                                                                                                               
  (def vars (atom {}))                                                                                                                                                                                                                         
                                                                                                                                                                                                                                               
  (defn magic-load-file [original-load clojure-source-files]                                                                                                                                                                                   
    (fn [file]                                                                                                                                                                                                                                 
      (if (contains? clojure-source-files file)                                                                                                                                                                                                
        (let [file (str (subs file 1) ".clj")]                                                                                                                                                                                                 
          (binding [*ns* *ns*                                                                                                                                                                                                                  
                    *file* file                                                                                                                                                                                                                
                    *warn-on-reflection* false]                                                                                                                                                                                                
            (with-open [rdr (-> (io/reader (io/resource file))                                                                                                                                                                                 
                                (clojure.lang.LineNumberingPushbackReader.))]                                                                                                                                                                  
              (loop []                                                                                                                                                                                                                         
                (let [form (rdr/read rdr false ::end)]                                                                                                                                                                                         
                  (when (not= ::end form)                                                                                                                                                                                                      
                    (eval                                                                                                                                                                                                                      
                     (e/emit-form                                                                                                                                                                                                              
                      (walk/postwalk                                                                                                                                                                                                           
                       (ana.jvm/analyze form)                                                                                                                                                                                                  
                       (fn [x]                                                                                                                                                                                                                 
                         (case (:op x)                                                                                                                                                                                                         
                           :var (do                                                                                                                                                                                                            
                                  (swap! vars update-in [*ns*] (fnil conj #{})                                                                                                                                                                 
                                         (:var x))                                                                                                                                                                                             
                                  x)                                                                                                                                                                                                           
                           x)))))                                                                                                                                                                                                              
                    (recur)))))))                                                                                                                                                                                                              
        (original-load file))))                                                                                                                                                                                                                
                                                                                                                                                                                                                                               
                                                                                                                                                                                                                                               
  (let [files (ns-find/find-clojure-sources-in-dir (clojure.java.io/file "src/"))]                                                                                                                                                             
    (doseq [ns (ns-find/find-namespaces [(clojure.java.io/file "src/")])]                                                                                                                                                                      
      (with-redefs [load (magic-load-file                                                                                                                                                                                                      
                          load                                                                                                                                                                                                                 
                          (set (for [file files                                                                                                                                                                                                
                                     :let [rel-name (subs (.getAbsolutePath file)                                                                                                                                                              
                                                          (count                                                                                                                                                                               
                                                           (.getAbsolutePath (clojure.java.io/file "src/"))))                                                                                                                                  
                                           ]]                                                                                                                                                                                                  
                                 (.replaceAll rel-name "\\.clj$" ""))))]                                                                                                                                                                       
        (require ns))))                                                                                                                                                                                                                        
  (prn @vars))