some tests

Author: bronsa

src/test/clojure/clojure/tools/analyzer/jvm/core_test.clj

@@ -6,7 +6,8 @@
             [clojure.tools.analyzer.passes.elide-meta :refer [elides elide-meta]]
             [clojure.tools.analyzer.ast :refer [postwalk]]
             [clojure.tools.reader :as r]
-            [clojure.test :refer [deftest is]]))
+            [clojure.test :refer [deftest is]])
+  (:import (java.io File)))
 
 (defprotocol p (f [_]))
 (defn f1 [^long x])
@@ -115,3 +116,77 @@
 
 (deftest array_class
   (is (ana (r/read-string "(fn [^{:tag int/2} x] (instance? int/2 x))"))))
+
+(deftest macroexpander-qualified-methods-test
+  (is (= (list '. Integer (symbol "-MAX_VALUE"))
+         (mexpand Integer/MAX_VALUE)))
+
+  (is (= 'String/1 (mexpand String/1)))
+
+  (is (= 'String/.length (mexpand String/.length)))
+  (is (= 'Integer/.intValue (mexpand Integer/.intValue)))
+
+  (is (= 'String/new (mexpand String/new)))
+
+  (is (= 'String/valueOf (mexpand String/valueOf)))
+  (is (= 'Integer/parseInt (mexpand Integer/parseInt)))
+
+  (let [expanded (mexpand (String/new "hello"))]
+    (is (= 'new (first expanded)))
+    (is (= java.lang.String (second expanded))))
+
+  (let [expanded (mexpand (String/.substring "hello" 1 3))]
+    (is (= '. (first expanded)))
+    (is (= '(do "hello") (second expanded)))
+    (is (= String (:tag (meta (second expanded)))))
+    (is (= 'substring (first (nth expanded 2)))))
+
+  (let [expanded (mexpand (String/.length "hello"))]
+    (is (= '. (first expanded)))
+    (is (= 'length (nth expanded 2))))
+
+  (let [expanded (mexpand (Integer/parseInt "2"))]
+    (is (= '. (first expanded)))
+    (is (= java.lang.Integer (second expanded)))))
+
+(deftest analyzer-qualified-methods-test
+  (let [a (ast1 File/.getName)]
+    (is (= :method-value (:op a)))
+    (is (= :instance (:kind a)))
+    (is (= 'getName (:method a)))
+    (is (= java.io.File (:class a))))
+
+  (let [a (ast1 String/valueOf)]
+    (is (= :method-value (:op a)))
+    (is (= :static (:kind a)))
+    (is (= 'valueOf (:method a)))
+    (is (= String (:class a))))
+
+  (let [a (ast1 File/new)]
+    (is (= :method-value (:op a)))
+    (is (= :ctor (:kind a)))
+    (is (= java.io.File (:class a))))
+
+  (let [a (ast1 Integer/MAX_VALUE)]
+    (is (= :static-field (:op a)))
+    (is (= Integer (:class a))))
+
+  (let [a (ana (r/read-string "String/1"))]
+    (is (= :const (:op a)))
+    (is (= :class (:type a)))
+    (is (.isArray ^Class (:val a))))
+
+  (let [a (ast1 (File/new "."))]
+    (is (= :new (:op a))))
+
+  (let [a (ast1 (String/.length "hello"))]
+    (is (= :instance-call (:op a)))
+    (is (= 'length (:method a))))
+
+  (let [a (ast1 (String/.substring "hello" 1 3))]
+    (is (= :instance-call (:op a)))
+    (is (= 'substring (:method a))))
+
+  (let [a (ast1 (Integer/parseInt "7"))]
+    (is (= :static-call (:op a)))
+    (is (= 'parseInt (:method a)))))

src/test/clojure/clojure/tools/analyzer/jvm/passes_test.clj

@@ -8,7 +8,8 @@
             [clojure.set :as set]
             [clojure.tools.analyzer.passes.add-binding-atom :refer [add-binding-atom]]
             [clojure.tools.analyzer.passes.collect-closed-overs :refer [collect-closed-overs]]
-            [clojure.tools.analyzer.jvm.core-test :refer [ast ast1 e f f1]]
+            [clojure.tools.reader :as r]
+            [clojure.tools.analyzer.jvm.core-test :refer [ast ast1 ana e f f1]]
             [clojure.tools.analyzer.passes.jvm.emit-form
              :refer [emit-form emit-hygienic-form]]
             [clojure.tools.analyzer.passes.jvm.validate :as v]
@@ -22,7 +23,8 @@
             [clojure.tools.analyzer.passes.jvm.classify-invoke :refer [classify-invoke]])
   (:import (clojure.lang Keyword Var Symbol AFunction
                          PersistentVector PersistentArrayMap PersistentHashSet ISeq)
-           java.util.regex.Pattern))
+           java.util.regex.Pattern
+           (java.io File)))
 
 (defn validate [ast]
   (env/with-env (ana.jvm/global-env)
@@ -68,10 +70,10 @@
 (deftest annotate-tag-test
   (is (= PersistentVector (-> {:op :const :form [] :val []} annotate-tag :tag)))
   (is (= PersistentVector (-> (ast []) annotate-tag :tag)))
-  (is (= PersistentArrayMap(-> (ast {}) annotate-tag :tag)))
+  (is (= PersistentArrayMap (-> (ast {}) annotate-tag :tag)))
   (is (= PersistentHashSet (-> (ast #{}) annotate-tag :tag)))
   (is (= Class (-> {:op :const :type :class :form Object :val Object}
-                 annotate-tag :tag)))
+                   annotate-tag :tag)))
   (is (= String (-> (ast "foo") annotate-tag :tag)))
   (is (= Keyword (-> (ast :foo) annotate-tag :tag)))
   (is (= Character/TYPE (-> (ast \f) annotate-tag :tag)))
@@ -80,15 +82,15 @@
   (is (= Var (-> (ast #'+)  annotate-tag :tag)))
   (is (= Boolean (-> (ast true) annotate-tag :tag)))
   (let [b-ast (-> (ast (let [a 1] a)) add-binding-atom
-                 (postwalk annotate-tag))]
+                  (postwalk annotate-tag))]
     (is (= Long/TYPE (-> b-ast :body :ret :tag)))))
 
 (deftest classify-invoke-test
   (is (= :keyword-invoke (-> (ast (:foo {})) classify-invoke :op)))
   (is (= :invoke (-> (ast (:foo {} 1)) classify-invoke :op)))
   (is (= :protocol-invoke (-> (ast (f nil)) classify-invoke :op)))
   (is (= :instance? (-> (ast (instance? String ""))
-                      (prewalk analyze-host-expr) classify-invoke :op)))
+                        (prewalk analyze-host-expr) classify-invoke :op)))
   (is (= :prim-invoke (-> (ast (f1 1)) (prewalk infer-tag) classify-invoke :op))))
 
 (deftest annotate-host-info-test
@@ -100,10 +102,10 @@
 ;; TODO: test primitives, tag matching, throwing validation, method validation
 (deftest validate-test
   (is (= Exception (-> (ast (try (catch Exception e)))
-                     (prewalk (comp validate analyze-host-expr)) :catches first :class :val)))
+                       (prewalk (comp validate analyze-host-expr)) :catches first :class :val)))
   (is (-> (ast (set! *warn-on-reflection* true)) validate))
   (is (= true (-> (ast (String. "foo")) (postwalk (comp validate annotate-tag analyze-host-expr))
-              :validated?)))
+                  :validated?)))
 
   (let [s-ast (-> (ast (Integer/parseInt "7")) (prewalk annotate-tag) analyze-host-expr validate)]
     (is (:validated? s-ast))
@@ -134,8 +136,8 @@
 
   (is (= String (-> (ast1 String) :val)))
   (is (= 'String (-> (ast1 String) :form)))
-(is (= PersistentVector (-> (ast1 '[]) :tag)))
-(is (= ISeq (-> (ast1 '()) :tag)))
+  (is (= PersistentVector (-> (ast1 '[]) :tag)))
+  (is (= ISeq (-> (ast1 '()) :tag)))
 
   (let [d-ast (ast1 (Double/isInfinite 2))]
     (is (= Boolean/TYPE (-> d-ast :tag)))
@@ -161,3 +163,134 @@
                        {:passes-opts (merge ana.jvm/default-passes-opts
                                             {:validate/wrong-tag-handler (fn [t ast]
                                                                            {t nil})})})))
+
+(deftest method-value-emit-form-test
+  (is (= 'java.io.File/.getName (emit-form (ast1 File/.getName))))
+
+  (is (= 'java.lang.String/valueOf (emit-form (ast1 String/valueOf))))
+
+  (is (= 'java.io.File/new (emit-form (ast1 File/new))))
+
+  (let [emitted (emit-form (ana (r/read-string "^[long] String/valueOf")))]
+    (is (= 'java.lang.String/valueOf emitted))
+    (is (= '[long] (:param-tags (meta emitted)))))
+
+  (let [emitted (emit-form (ana (r/read-string "^[int int] String/.substring")))]
+    (is (= 'java.lang.String/.substring emitted))
+    (is (= '[int int] (:param-tags (meta emitted))))))
+
+(deftest method-value-validate-test
+  (let [a (ast1 File/.getName)]
+    (is (= :method-value (:op a)))
+    (is (:validated? a))
+    (is (= java.io.File (:class a))))
+
+  (let [a (ast1 String/valueOf)]
+    (is (= :method-value (:op a)))
+    (is (:validated? a))
+    (is (pos? (count (:methods a)))))
+
+  (let [a (ast1 File/new)]
+    (is (= :method-value (:op a)))
+    (is (:validated? a))
+    (is (= :ctor (:kind a))))
+
+  (let [a (ana (r/read-string "^[long] String/valueOf"))]
+    (is (= :method-value (:op a)))
+    (is (:validated? a))
+    (is (= 1 (count (:methods a)))))
+
+  (let [a (ana (r/read-string "^[int int] String/.substring"))]
+    (is (= :method-value (:op a)))
+    (is (:validated? a))
+    (is (= 1 (count (:methods a))))))
+
+(deftest method-value-kinds-test
+  (let [a (ast1 File/.isDirectory)]
+    (is (= :instance (:kind a)))
+    (is (= 'isDirectory (:method a))))
+
+  (let [a (ast1 Character/isDigit)]
+    (is (= :method-value (:op a)))
+    (is (= :static (:kind a)))
+    (is (= 'isDigit (:method a)))
+    (is (< 1 (count (:methods a)))))
+
+  (let [a (ast1 String/new)]
+    (is (= :ctor (:kind a)))
+    (is (= String (:class a))))
+
+  (let [a (ast1 File/.getName)]
+    (is (= AFunction (:o-tag a)))))
+
+(deftest method-value-field-overload-test
+  (let [a (ast1 Integer/MAX_VALUE)]
+    (is (= :static-field (:op a))))
+
+  (let [a (ast1 Boolean/TRUE)]
+    (is (= :static-field (:op a)))))
+
+(deftest qualified-method-invocation-test
+  (let [a (ast1 (File/new "."))]
+    (is (= :new (:op a))))
+
+  (let [a (ast1 (String/.length "hello"))]
+    (is (= :instance-call (:op a)))
+    (is (= 'length (:method a)))
+    (is (:validated? a)))
+
+  (let [a (ast1 (String/.substring "hello" 1 3))]
+    (is (= :instance-call (:op a)))
+    (is (= 'substring (:method a)))
+    (is (= 2 (count (:args a)))))
+
+  (let [a (ast1 (Integer/parseInt "7"))]
+    (is (= :static-call (:op a)))
+    (is (= 'parseInt (:method a)))
+    (is (:validated? a)))
+
+  (let [a (ast1 (File/.isDirectory (File. ".")))]
+    (is (= :instance-call (:op a)))
+    (is (= 'isDirectory (:method a)))))
+
+(deftest param-tags-invocation-test
+  (let [a (ana (r/read-string "(^[long] String/valueOf 42)"))]
+    (is (= :static-call (:op a)))
+    (is (:validated? a))
+    (is (= '[long] (:param-tags a))))
+
+  (let [a (ana (r/read-string "(^[int int] String/.substring \"hello\" 1 3)"))]
+    (is (= :instance-call (:op a)))
+    (is (:validated? a))
+    (is (= '[int int] (:param-tags a))))
+
+  (let [a (ana (r/read-string "(^[int _] String/.substring \"hello\" 1 3)"))]
+    (is (= :instance-call (:op a)))
+    (is (:validated? a))
+    (is (= '[int _] (:param-tags a))))
+
+  (let [a (ana (r/read-string "^[int/1] java.util.Arrays/sort"))]
+    (is (= :method-value (:op a)))
+    (is (= :static (:kind a)))
+    (is (= 1 (count (:methods a))))))
+
+(deftest existing-interop-unchanged-test
+  (let [a (ast1 (.length "hello"))]
+    (is (= :instance-call (:op a)))
+    (is (:validated? a)))
+
+  (let [a (ast1 (String. "foo"))]
+    (is (= :new (:op a)))
+    (is (:validated? a)))
+
+  (is (= Void/TYPE (:tag (ast1 (.println System/out "foo")))))
+
+  (let [a (ast1 (Integer/parseInt "7"))]
+    (is (= :static-call (:op a)))
+    (is (:validated? a)))
+
+  (let [a (ast1 Integer/MAX_VALUE)]
+    (is (= :static-field (:op a))))
+
+  (let [a (ast1 Boolean/TYPE)]
+    (is (= :static-field (:op a)))))