Update to Java commit 3296c3c (): CLJ-2914: Throw if QualifiedMethodExpr given no target

Author: dmiller

Clojure/Clojure.Tests/clojure/test_clojure/java_interop.clj

@@ -648,4 +648,250 @@
 
 (deftest test-boxing-prevention-when-compiling-statements
   (is (= 1 (.get (doto (AtomicInteger. 0) inc-atomic-int))))
-  (is (= 1 (.get (doto (AtomicLong. 0) inc-atomic-long)))))
+  (is (= 1 (.get (doto (AtomicLong. 0) inc-atomic-long)))))
+
+(deftest array-type-symbols
+  (is (= long/1 (class (make-array Int64 0))))                         ;;; Long/TYPE
+  (is (= int/1 (class (make-array Int32 0))))                          ;;; Integer/TYPE
+  (is (= double/1 (class (make-array Double 0))))                      ;;; Double/TYPE 
+  (is (= short/1 (class (make-array Int16 0))))                       ;;; Short/TYPE
+  (is (= boolean/1 (class (make-array Boolean 0))))                    ;;; Boolean/TYPE
+  (is (= byte/1 (class (make-array Byte 0))))                          ;;; Byte/TYPE 
+  (is (= float/1 (class (make-array Single 0))))                       ;;; Float/TYPE
+  (is (= String/1 (class (make-array String 0))))
+  (is (= System.String/1 (class (make-array String 0))))            ;;; java.lang.String
+  (is (= System.Guid/1 (class (make-array System.Guid 0))))            ;;; java.util.UUID java.util.UUID
+  (is (= `byte/1 'byte/1))
+  (is (= `byte/3 'byte/3))
+  (is (= `System.Guid/1 'System.Guid/1))                               ;;; java.util.UUID java.util.UUID
+  (is (= `String/1 'System.String/1))                                  ;;; java.lang.String
+  (is (= `System.String/1 'System.String/1))                           ;;; java.lang.String java.lang.String 
+  (is (= ['long/2] `[~'long/2])))
+
+(comment   "Mostly Java FI"
+(defn make-test-files []
+  (let [id (str (UUID/randomUUID))
+        temp-1 (java.io.File/createTempFile (str "test-1-" id)".edn")
+        temp-2 (java.io.File/createTempFile "test-2"".xml")
+        temp-3 (java.io.File/createTempFile (str "test-3-" id)".edn")
+        dir (File. (.getParent temp-3))]
+    {:dir dir :file-id id}))
+
+(defn return-long ^long []
+  (let [^java.util.function.ToLongFunction f (fn ^long [x] 1)]
+    (Long/highestOneBit (.applyAsLong f :x))))
+
+(deftest clojure-fn-as-java-fn
+  ;; pass Clojure fn as Java Predicate
+  (let [coll (java.util.ArrayList. [1 2 3 4 5])]
+    (is (true? (.removeIf coll even?)))
+    (is (= coll [1 3 5])))
+  
+  ;; binding type hint triggers coercion
+  (is (instance? FileFilter
+    (let [^FileFilter ff (fn [f] true)] ff)))
+
+  ;; coercion in let - reflection has types that should work
+  (let [{:keys [dir file-id]} (make-test-files)
+        ^FileFilter ff (fn [^File f]
+                                 (str/includes? (.getName f) file-id))
+        filtered (.listFiles dir ff)]
+    (is (= 2 (count filtered))))
+
+  ;; coercion in let
+  (let [{:keys [dir file-id]} (make-test-files)
+        ^FileFilter ff (fn [^File f]
+                                 (str/includes? (.getName f) file-id))
+        filtered (.listFiles ^File dir ff)]
+    (is (= 2 (count filtered))))
+
+  ;;; resolve method ambiguity using member symbol and param-tags
+  (let [{:keys [dir file-id]} (make-test-files)
+        ^FileFilter ff (fn [^File f]
+                                 (str/includes? (.getName f) file-id))
+        filtered (^[FileFilter] File/.listFiles dir ff)]
+    (is (= 2 (count filtered))))
+
+  (defn files-with-ext [^File dir ext]
+    (vec (.list dir ^FilenameFilter #(str/ends-with? % ext))))
+
+  (let [{:keys [dir file-id]} (make-test-files)
+        ^FilenameFilter ff (fn [dir file-name]
+                             (str/includes? file-name file-id))
+        filtered (.list ^File dir ff)]
+    (is (= 2 (count filtered))))
+
+  (let [^java.util.function.DoubleToLongFunction f (fn [d] (int d))]
+    (is (instance? java.util.function.DoubleToLongFunction f))
+    (is (= 10 (.applyAsLong f (double 10.6)))))
+
+  (let [^java.util.function.IntConsumer f (fn [i] nil)]
+    (is (nil? (.accept f 42))))
+
+  (let [^java.util.function.IntPredicate f (fn [i] true)]
+    (is (true? (.test f 42))))
+
+  (let [arr (java.util.ArrayList. [1 2 3 4 5])
+        ^java.util.function.ObjDoubleConsumer f (fn [arr i] nil)]
+    (is (nil? (.accept f arr 42))))
+
+  (let [f (constantly 100)
+        ^Runnable g f]
+    (is (identical? f g) "has been unintentionally adapted"))
+
+  (let [^java.util.function.Predicate pred even?
+        coll1 (java.util.ArrayList. [1 2 3 4 5])
+        coll2 (java.util.ArrayList. [6 7 8 9 10])]
+    (is (instance? java.util.function.Predicate pred))
+    (is (true? (.removeIf coll1 pred)))
+    (is (= coll1 [1 3 5]))
+    (is (true? (.removeIf coll2 pred)))
+    (is (= coll2 [7 9])))
+
+  (let [^java.util.function.Predicate pred even?
+        coll1 (java.util.ArrayList. [1 2 3 4 5])
+        cup-fn (java.util.ArrayList. [1 2 3 4 5])]
+    (is (instance? java.util.function.Predicate pred))
+    (is (true? (.removeIf coll1 pred)))
+    (is (= coll1 [1 3 5]))
+    (is (true? (.removeIf cup-fn pred)))
+    (is (= cup-fn [1 3 5])))
+
+  (should-not-reflect #(clojure.test-clojure.java-interop/return-long))
+
+  ;; FI in class constructor
+  (let [^java.util.function.Predicate hinted-pred (fn [i] (> i 0))
+        clj-pred (fn [i] (> i 0))
+        fi-constructor-1 (FIConstructor. hinted-pred)
+        fi-constructor-2 (FIConstructor. clj-pred)
+        fi-constructor-3 (FIConstructor. (fn [i] (> i 0)))]
+    (is (= [1 2] (.numbers fi-constructor-1)))
+    (is (= [1 2] (.numbers fi-constructor-2)))
+    (is (= [1 2] (.numbers fi-constructor-3))))
+
+  ;; FI as arg to static
+  (let [^java.util.function.Predicate hinted-pred (fn [i] (> i 0))
+        res (FIStatic/numbers hinted-pred)]
+    (is (= [1 2] res))))
+
+(deftest eval-in-place-supplier-instance
+  (def stream (java.util.stream.Stream/generate ^java.util.function.Supplier (atom 42)))
+  (is (instance? java.util.stream.Stream stream)))
+
+(deftest eval-in-place-as-java-fn
+  (def filtered-list (.removeIf (java.util.ArrayList. [1 2 3 4 5]) even?))
+  (is (true? filtered-list))
+
+  (def fi-constructor-numbers (.numbers (FIConstructor. (fn [i] (> i 0)))))
+  (is (= [1 2] fi-constructor-numbers))
+
+  (def fi-static (FIStatic/numbers (fn [i] (< i 0))))
+  (is (= [-2 -1] fi-static)))
+
+;; newDirectoryStream is overloaded, takes ^[Path String] or ^[Path DirectoryStream$Filter]
+;; so this method will reflect
+(defn get-dir-stream [^java.nio.file.Path dir-path glob-pattern]
+  (let [path (.toPath (java.io.File. dir-path))]
+    (java.nio.file.Files/newDirectoryStream path glob-pattern)))
+
+(deftest test-reflection-to-overloaded-method-taking-FI
+  ;; all of these should resolve at runtime in reflection
+  (is (not (nil? (get-dir-stream "." "*"))))
+  (is (not (nil? (get-dir-stream "." (reify java.nio.file.DirectoryStream$Filter (accept [_ path] (.isDirectory (.toFile path))))))))
+  ;; this one gets FI converted from IFn to DirectoryStream$Filter
+  (is (not (nil? (get-dir-stream "." (fn [^java.nio.file.Path path] (.isDirectory (.toFile path))))))))
+
+;; we only support FI invoke coercion up to 10 args, this has 11
+(definterface ^{java.lang.FunctionalInterface true} FIWontWork
+  (invoke [a b c d e f g h i j k]))
+
+(definterface ReceivesFI
+  (call [^clojure.test_clojure.java_interop.FIWontWork fi]))
+
+(deftest test-reify-to-FI-allowed
+  ;; throws because there is no 11-arity invoker method and thus it is not possible to coerce
+  (is (thrown? ClassCastException
+        (eval '(let [^clojure.test_clojure.java_interop.FIWontWork f
+                     (fn [p1 p2 p3 p4 p5 p6 p7 p8 p9 p10 p11] p11)]
+                 (.invoke f 1 2 3 4 5 6 7 8 9 10 11)))))
+
+  (let [r (reify clojure.test_clojure.java_interop.ReceivesFI
+            (call [_ fi] (.invoke fi 0 0 0 0 0 0 0 0 0 0 1)))]
+
+    ;; doesn't throw at compilation time, but throws at runtime
+    ;; because IFn cannot be implicitly converted
+    (is (thrown? ClassCastException
+      (.call r (fn [a b c d e f g h i j k] k))))
+
+    ;; works because the reify implements the FI, no conversion necessary
+    (is (= 1 (.call r (reify clojure.test_clojure.java_interop.FIWontWork (invoke [_ a b c d e f g h i j k] k)))))))
+
+(definterface ^{java.lang.FunctionalInterface true} FIPrims
+  (^long invoke [^long a ^long b ^long c ^long d]))
+
+(definterface ReceivesFIPrims
+  (call [^clojure.test_clojure.java_interop.FIPrims fi]))
+
+(deftest test-match-prim-args-only-to-2
+  (let [r (reify clojure.test_clojure.java_interop.ReceivesFIPrims
+            (call [_ fi] (.invoke fi 1 2 3 4)))]
+    (is (= 4 (.call r (fn [^long a ^long b ^long c ^long d] d))))))
+
+(deftest test-invoke-fiprim-rets
+  (let [^clojure.test_clojure.java_interop.FIPrims f (fn [a b c d] a)]
+    (is (instance? clojure.test_clojure.java_interop.FIPrims f))
+    (is (= 1 (.invoke f 1 2 3 4))))
+
+  (is (= "LLL" (AdapterExerciser/.methodLLL (AdapterExerciser.) (fn ^long [^long a ^long b]))))
+  (is (= "OOOO" (AdapterExerciser/.methodOOOO (AdapterExerciser.) (fn ^long [^long a ^long b ^long c]))))
+  )
+
+(deftest test-null-reify
+  (is (= "null" ((fn [x] (FIStatic/allowsNullFI x)) nil))))
+
+(deftest test-FI-subtype
+  (is (= [1 2 3 4 5] (->> (java.util.stream.Stream/iterate 1 inc) stream-seq! (take 5)))))
+
+(deftest class-methods-with-fi-args
+  (testing "Constructor accepting FI arg, provided overloaded static class FI"
+    (let [fi (FunctionalTester. "Constructor" 0 FunctionalTester/getChar)]
+      (is (= \C (.testVar fi)))))
+
+   (testing "Instance method accepting FI arg, provided overloaded static class FI"
+     (let [fi (FunctionalTester. "asf" 0 FunctionalTester/getChar)]
+       (.instanceMethodWithFIArg fi "Instance" 0 FunctionalTester/getChar)
+       (is (= \I (.testVar fi)))))
+
+   (testing "Static method accepting FI arg, provided overloaded static class FI"
+     (is (= \S (FunctionalTester/staticMethodWithFIArg "Static" 0 FunctionalTester/getChar)))))
+
+;; call is reflective and one overload takes an FI (Supplier)
+(definterface TakesFIOverloaded
+  (call [^java.util.function.Supplier s])
+  (call [^String s]))
+
+(deftest CLJ-2898-reified-objs-both-IFn-and-FI
+  ;; f is both IFn and FI (Supplier)
+  (let [f (reify
+            java.util.function.Supplier
+            (get [_] 100)
+
+            clojure.lang.IFn
+            (applyTo [_ _] 201)
+            (invoke [_] 200))]
+
+    ;; should not be adapted. use Supplier.get() impl on tl
+    (is (= 100 (.get (ThreadLocal/withInitial f))))
+
+    (let [tfio (reify TakesFIOverloaded
+                 (call [_ ^java.util.function.Supplier o] (.get o))
+                 (call [_ ^String s] "string"))]
+      ;; reflective call to TakesFIOverloaded.call()
+      ;; as above, should not be adapted and use Supplier.get()
+      (is (= 100 (.call tfio (identity f)))))))
+  ) ;; and commented out section
+
+(deftest CLJ-2914-Qualified-Method-Expr-NPE
+  (is (fails-with-cause? ArgumentException                                ;;; IllegalArgumentException
+        #"Malformed method expression.*String/\.length"
+        (eval '(fn [] (System.String/.length))))))                        ;;; java.lang.String

Clojure/Clojure/CljCompiler/Ast/InvokeExpr.cs

@@ -241,11 +241,16 @@ fexpr is StaticFieldExpr sfe
 
 
             if (fexpr is QualifiedMethodExpr qmfexpr)
+            {
+                if (qmfexpr.Kind == QualifiedMethodExpr.EMethodKind.INSTANCE && RT.count(args) == 0)
+                    throw QualifiedMethodExpr.InstanceNoTargetException(qmfexpr);
+
                 return ToHostExpr(pcon,
                     qmfexpr,
                     Compiler.TagOf(form),
                     tailPosition,
                     form.next());
+            }
 
 
             //if (args.count() > Compiler.MAX_POSITIONAL_ARITY)

Clojure/Clojure/CljCompiler/Ast/QualifiedMethodExpr.cs

@@ -318,6 +318,11 @@ private static ArgumentException ParamTagsDontResolveException(Type t, string me
             return new ArgumentException($"Error - param-tags {genericTypeArgs}{paramTags} insufficient to resolve {Compiler.MethodDescription(t, methodName)}");
         }
 
+        internal static ArgumentException InstanceNoTargetException(QualifiedMethodExpr qme)
+        {
+            return new ArgumentException($"Malformed method expression, expecting ({qme.MethodType.Name}/.{qme.MethodName} target...)");
+        }
+
 
         #endregion
     }