TANAL-71: memoize only maybe-class and member*, invalidate memoize ca…

…che on deftype*
clojure · Feb 11, 2014 · dc02dc6 · dc02dc6
1 parent fcb7cac
commit dc02dc6
Show file tree

Hide file tree

Showing 2 changed files with 43 additions and 40 deletions.
diff --git a/src/main/clojure/clojure/tools/analyzer/jvm.clj b/src/main/clojure/clojure/tools/analyzer/jvm.clj
@@ -35,7 +35,8 @@
             [clojure.tools.analyzer.passes.jvm.infer-tag :refer [infer-tag ensure-tag]]
             [clojure.tools.analyzer.passes.jvm.annotate-tag :refer [annotate-tag]]
             [clojure.tools.analyzer.passes.jvm.validate-loop-locals :refer [validate-loop-locals]]
-            [clojure.tools.analyzer.passes.jvm.analyze-host-expr :refer [analyze-host-expr]])
+            [clojure.tools.analyzer.passes.jvm.analyze-host-expr :refer [analyze-host-expr]]
+            [clojure.core.memoize :refer [memo-clear!]])
   (:import clojure.lang.IObj))
 
 (def specials
@@ -234,6 +235,11 @@
       :children (into [:this] (:children method)))))
 
 (defn -deftype [name class-name args interfaces & [methods]]
+
+  (doseq [arg [class-name (str class-name) name (str name)]
+          f   [maybe-class members*]]
+    (memo-clear! f [arg]))
+
   (let [interfaces (mapv #(symbol (.getName ^Class %)) interfaces)]
     (eval (list 'let []
                 (list* 'deftype* name class-name args :implements interfaces methods)

diff --git a/src/main/clojure/clojure/tools/analyzer/jvm/utils.clj b/src/main/clojure/clojure/tools/analyzer/jvm/utils.clj
@@ -200,18 +200,21 @@
             (= member-name** name)
             (= member-name*** name))))))
 
-(def members
+(def members*
   (lru (fn ([class]
              (remove (fn [{:keys [flags]}]
                        (not-any? #{:public :protected} flags))
               (-> (maybe-class class)
                 box
                 (type-reflect :ancestors true)
-                :members)))
-         ([class member]
-            (when-let [members (filter #((name-matches? member) (:name %))
-                                       (members class))]
-              members)))))
+                :members))))))
+
+(defn members
+  ([class] (members* class))
+  ([class member]
+     (when-let [members (filter #((name-matches? member) (:name %))
+                                (members* class))]
+       members)))
 
 (defn static-members [class f]
   (when-let [members (members class f)]
@@ -223,39 +226,33 @@
     (when-let [i-members (remove (comp :static :flags) members)]
       i-members)))
 
-(def static-methods
-  (lru (fn [class method argc]
-         (filter #(= argc (count (:parameter-types %)))
-                 (filter :return-type (static-members class method))))))
-
-(def instance-methods
-  (lru (fn [class method argc]
-         (filter #(= argc (count (:parameter-types %)))
-                 (filter :return-type (instance-members class method))))))
-
-(def static-field
-  (lru (fn [class f]
-         (when-let [statics (static-members class f)]
-           (when-let [[member] (filter (every-pred (comp nil? seq :parameter-types)
-                                                   (comp nil? :return-type))
-                                       statics)]
-             member)))))
-
-(def instance-field
-  (lru (fn [class f]
-         (when-let [i-members (instance-members class f)]
-           (when-let [[member] (filter (every-pred (comp nil? seq :parameter-types)
-                                                   (comp nil? :return-type))
-                                       i-members)]
-             member)))))
-
-(def static-method
-  (lru (fn [class method]
-         (first (static-methods class method 0)))))
-
-(def instance-method
-  (lru (fn [class method]
-         (first (instance-methods class method 0)))))
+(defn static-methods [class method argc]
+  (filter #(= argc (count (:parameter-types %)))
+          (filter :return-type (static-members class method))))
+
+(defn instance-methods [class method argc]
+  (filter #(= argc (count (:parameter-types %)))
+          (filter :return-type (instance-members class method))))
+
+(defn static-field [class f]
+  (when-let [statics (static-members class f)]
+    (when-let [[member] (filter (every-pred (comp nil? seq :parameter-types)
+                                            (comp nil? :return-type))
+                                statics)]
+      member)))
+
+(defn instance-field [class f]
+  (when-let [i-members (instance-members class f)]
+    (when-let [[member] (filter (every-pred (comp nil? seq :parameter-types)
+                                            (comp nil? :return-type))
+                                i-members)]
+      member)))
+
+(defn static-method [class method]
+  (first (static-methods class method 0)))
+
+(defn instance-method [class method]
+  (first (instance-methods class method 0)))
 
 (defn prim-or-obj [tag]
   (if (and tag (primitive? tag))