feat: if field-overload, convert to method-value

Author: bronsa

src/main/clojure/clojure/tools/analyzer/passes/jvm/process_method_value.clj

@@ -12,13 +12,20 @@
 
 (defn process-method-value
   "Transforms :invoke nodes whose :fn is a :method-value into the
-   corresponding :instance-call, :static-call, or :new node. "
+   corresponding :instance-call, :static-call, or :new node.
+   Also converts value-position :method-value nodes with a
+   :field-overload (and no :param-tags) into :static-field nodes."
   {:pass-info {:walk :post :depends #{#'analyze-host-expr}}}
   [{:keys [op args env] :as ast}]
-  (if (and (= :invoke op)
-           (= :method-value (:op (:fn ast))))
-    (let [{:keys [class method kind param-tags]} (:fn ast)]
-      (when (and (= :instance kind) (empty? args))
+  (cond
+    (and (= :invoke op)
+         (= :method-value (:op (:fn ast))))
+    (let [{:keys [class method kind param-tags methods]} (:fn ast)
+          instance? (= :instance kind)
+          call-args (if instance? (vec (rest args)) args)
+          argc (count call-args)
+          methods (seq (filter #(= argc (count (:parameter-types %))) methods))]
+      (when (and instance? (empty? args))
         (throw (ex-info (str "Qualified instance method " (.getName ^Class class) "/." method
                              " must have a target")
                         (merge {:class class :method method}
@@ -30,22 +37,38 @@
                 :method   method
                 :class    class
                 :instance (first args)
-                :args     (vec (rest args))
+                :args     call-args
                 :children [:instance :args]}
 
                :static
                {:op       :static-call
                 :method   method
                 :class    class
-                :args     args
+                :args     call-args
                 :children [:args]}
 
                :ctor
                {:op       :new
                 :class    {:op :const :type :class :val class
                            :form class :env env}
-                :args     args
+                :args     call-args
                 :children [:class :args]})
              (when param-tags
-               {:param-tags param-tags})))
-    ast))
+               {:param-tags param-tags})
+             (when methods
+               {:methods (vec methods)})))
+
+    (and (= :method-value op)
+         (:field-overload ast)
+         (not (:param-tags ast)))
+    (let [{:keys [flags type name]} (:field-overload ast)]
+      {:op          :static-field
+       :assignable? (not (:final flags))
+       :class       (:class ast)
+       :field       name
+       :form        (:form ast)
+       :env         env
+       :o-tag       type
+       :tag         (or (:tag ast) type)})
+
+    :else ast))