CLJS-2989: Fast-path issues for predicate-induced inference based on satisfies?

Author: mfikes

src/main/clojure/cljs/analyzer.cljc

@@ -1477,29 +1477,22 @@
     cljs.core/delay?          cljs.core/Delay
     cljs.core/reduced?        cljs.core/Reduced
 
+    ;;; Note: For non-marker protocol entries below, we
+    ;;; omit predicates that are based on satisfies? because
+    ;;; we cannot safely apply the fast-path optimization
+    ;;; which is enabled when the protocol type is inferred.
+    ;;; If adding a non-marker entry here, also add a test to
+    ;;; cljs.extend-to-native-test/test-extend-to-protocols.
+
     ;; Protocols
     cljs.core/map-entry?      cljs.core/IMapEntry
-    cljs.core/reversible?     cljs.core/IReversible
     cljs.core/uuid?           cljs.core/IUUID
     cljs.core/tagged-literal? cljs.core/ITaggedLiteral
-    cljs.core/iterable?       cljs.core/IIterable
-    cljs.core/cloneable?      cljs.core/ICloneable
     cljs.core/inst?           cljs.core/Inst
-    cljs.core/counted?        cljs.core/ICounted
-    cljs.core/indexed?        cljs.core/IIndexed
-    cljs.core/coll?           cljs.core/ICollection
-    cljs.core/set?            cljs.core/ISet
-    cljs.core/associative?    cljs.core/IAssociative
-    cljs.core/ifind?          cljs.core/IFind
     cljs.core/sequential?     cljs.core/ISequential
-    cljs.core/sorted?         cljs.core/ISorted
-    cljs.core/reduceable      cljs.core/IReduce
-    cljs.core/map?            cljs.core/IMap
     cljs.core/list?           cljs.core/IList
     cljs.core/record?         cljs.core/IRecord
-    cljs.core/vector?         cljs.core/IVector
     cljs.core/chunked-seq?    cljs.core/IChunkedSeq
-    cljs.core/ifn?            cljs.core/IFn
 
     ;; Composites
     cljs.core/seqable?        #{cljs.core/ISeqable array string}

src/test/cljs/cljs/extend_to_native_test.cljs

@@ -53,6 +53,9 @@
   (is (= "#function[custom-print-cljs-2812]" (pr-str map)))
   ;; Restore basic native types so that test summary output looks correct
   (extend-protocol IPrintWithWriter
+    object
+    (-pr-writer [obj writer _]
+      (write-all writer (str obj)))
     boolean
     (-pr-writer [obj writer _]
       (write-all writer (str obj)))
@@ -70,3 +73,57 @@
   (let [empty-array (empty #js [1 2 3])]
     (is (and (array? empty-array)
              (empty? empty-array)))))
+
+(defn test-map-entry [x] (when (map-entry? x) (-key x)))
+(defn test-coll [x] (when (coll? x) (-conj x 1)))
+(defn test-set [x] (when (set? x) (-disjoin x 1)))
+(defn test-associative [x] (when (associative? x) (-assoc x 1 2)))
+(defn test-find [x] (when (ifind? x) (-find x 1)))
+(defn test-sorted [x] (when (sorted? x) (-sorted-seq x true)))
+(defn test-map [x] (when (map? x) (-dissoc x 1)))
+(defn test-vector [x] (when (vector? x) (-assoc-n x 1 2)))
+(defn test-chunked-seq [x] (when (chunked-seq? x) (-chunked-first x)))
+(defn test-ifn [x] (when (ifn? x) (-invoke x)))
+(defn test-reversible [x] (when (reversible? x) (-rseq x)))
+(defn test-iterable [x] (when (iterable? x) (-iterator x)))
+(defn test-cloneable [x] (when (cloneable? x) (-clone x)))
+(defn test-counted [x] (when (counted? x) (-count x)))
+(defn test-indexed [x] (when (indexed? x) (-nth x 0)))
+(defn test-seqable [x] (when (seqable? x) (-seq x)))
+(defn test-reduceable [x] (when (reduceable? x) (-reduce x inc)))
+
+(deftest test-extend-to-protocols
+  (extend-type string IMapEntry (-key [_] :a))
+  (is (nil? (test-map-entry "a")))
+  (extend-type string ICollection (-conj [_ _] :b))
+  (is (= :b (test-coll "a")))
+  (extend-type string ISet (-disjoin [_ _] :c))
+  (is (= :c (test-set "a")))
+  (extend-type string IAssociative (-assoc [_ _ _] :d))
+  (is (= :d (test-associative "a")))
+  (extend-type string IFind (-find [_ _] :e))
+  (is (= :e (test-find "a")))
+  (extend-type string ISorted (-sorted-seq [_ _] :f))
+  (is (= :f (test-sorted "a")))
+  (extend-type string IMap (-dissoc [_ _] :g))
+  (is (= :g (test-map "a")))
+  (extend-type string IVector (-assoc-n [_ _ _] :h))
+  (is (= :h (test-vector "a")))
+  (extend-type string IChunkedSeq (-chunked-first [_] :i))
+  (is (nil? (test-chunked-seq "a")))
+  (extend-type string IFn (-invoke [_] :j))
+  (is (= :j (test-ifn "a")))
+  (extend-type string IReversible (-rseq [_] :k))
+  (is (= :k (test-reversible "a")))
+  (extend-type string IIterable (-iterator [_] :l))
+  (is (= :l (test-iterable "a")))
+  (extend-type string ICloneable (-clone [_] :m))
+  (is (= :m (test-cloneable "a")))
+  (extend-type string ICounted (-count [_] :n))
+  (is (= :n (test-counted "a")))
+  (extend-type string IIndexed (-nth [_] :o))
+  (is (= :o (test-indexed "a")))
+  (extend-type number ISeqable (-seq [_] :p))
+  (is (= :p (test-seqable 1)))
+  (extend-type string IReduce (-reduce [_ _] :q))
+  (is (= :q (test-reduceable "a"))))