Fix cljs.seq-test for :lite-mode

- simple-map-entry: add ICollection impl
- RSeq: can use `-count` in lastIndexOf
- Vector: Object.indexOf and Object.lastIndexOf
  inlined, a very small size hit, better for perf
- Vector: implement RSeq
- Set (Lite): need to return 0 from -count
- cljs.seqs-test: elide chunked-seq assertions from lite-mode tests
- cljs.lite-test-runner: run cljs.seqs-test

Author: swannodette

src/main/cljs/cljs/core.cljs

@@ -1768,7 +1768,7 @@ reduces them without incurring seq initialization"
   (indexOf [coll x start]
     (-indexOf coll x start))
   (lastIndexOf [coll x]
-    (-lastIndexOf coll x (count coll)))
+    (-lastIndexOf coll x (-count coll)))
   (lastIndexOf [coll x start]
     (-lastIndexOf coll x start))
 
@@ -10396,6 +10396,9 @@ reduces them without incurring seq initialization"
       (-assoc-n node k v))
     (-contains-key? [node k]
       (or (== k 0) (== k 1)))
+    ICollection
+    (-conj [coll x]
+      (Vector. nil #js [k v x] nil))
     IMapEntry
     (-key [_] k)
     (-val [_] v)
@@ -12262,6 +12265,36 @@ reduces them without incurring seq initialization"
   Object
   (toString [coll]
     (pr-str* coll))
+  (equiv [coll other]
+    (-equiv coll other))
+  (indexOf [coll x start]
+    (let [start (if (nil? start) 0 start)
+          len   (-count coll)]
+      (if (>= start len)
+        -1
+        (loop [idx (cond
+                     (pos? start) start
+                     (neg? start) (max 0 (+ start len))
+                     :else start)]
+          (if (< idx len)
+            (if (= (-nth coll idx) x)
+              idx
+              (recur (inc idx)))
+            -1)))))
+  (lastIndexOf [coll x start]
+    (let [start (if (nil? start) (alength array) start)
+          len   (-count coll)]
+      (if (zero? len)
+        -1
+        (loop [idx (cond
+                     (pos? start) (min (dec len) start)
+                     (neg? start) (+ len start)
+                     :else start)]
+          (if (>= idx 0)
+            (if (= (-nth coll idx) x)
+              idx
+              (recur (dec idx)))
+            -1)))))
 
   IWithMeta
   (-with-meta [coll meta] (Vector. meta array __hash))
@@ -12344,10 +12377,15 @@ reduces them without incurring seq initialization"
       (and (<= 0 k) (< k (alength array)))
       false))
 
-
   IVector
   (-assoc-n [coll n val] (-assoc coll n val))
 
+  IReversible
+  (-rseq [coll]
+    (let [cnt (alength array)]
+      (when (pos? cnt)
+        (RSeq. coll (dec cnt) nil))))
+
   IReduce
   (-reduce [v f]
     (array-reduce array f))
@@ -12830,8 +12868,9 @@ reduces them without incurring seq initialization"
   ICounted
   (-count [coll]
     (let [xs (-seq coll)]
-      (when (some? xs)
-        (-count xs))))
+      (if (some? xs)
+        (-count xs)
+        0)))
 
   ILookup
   (-lookup [coll v]

src/test/cljs/cljs/seqs_test.cljs

@@ -203,20 +203,21 @@
     (is (= (.lastIndexOf (sequence (map inc) '(0 1 0 3 4)) 1) 2))))
 
 (deftest test-chunked
-  (let [r (range 64)
-        v (into [] r)]
-    (testing "Testing Chunked Seqs"
-      (is (= (hash (seq v)) (hash (seq v))))
-      (is (= 6 (reduce + (array-chunk (array 1 2 3)))))
-      (is (instance? ChunkedSeq (seq v)))
-      (is (= r (seq v)))
-      (is (= (map inc r) (map inc v)))
-      (is (= (filter even? r) (filter even? v)))
-      (is (= (filter odd? r) (filter odd? v)))
-      (is (= (concat r r r) (concat v v v)))
-      (is (satisfies? IReduce (seq v)))
-      (is (== 2010 (reduce + (nnext (nnext (seq v))))))
-      (is (== 2020 (reduce + 10 (nnext (nnext (seq v)))))))))
+  (when-not LITE_MODE
+    (let [r (range 64)
+          v (into [] r)]
+      (testing "Testing Chunked Seqs"
+        (is (= (hash (seq v)) (hash (seq v))))
+        (is (= 6 (reduce + (array-chunk (array 1 2 3)))))
+        (is (instance? ChunkedSeq (seq v)))
+        (is (= r (seq v)))
+        (is (= (map inc r) (map inc v)))
+        (is (= (filter even? r) (filter even? v)))
+        (is (= (filter odd? r) (filter odd? v)))
+        (is (= (concat r r r) (concat v v v)))
+        (is (satisfies? IReduce (seq v)))
+        (is (== 2010 (reduce + (nnext (nnext (seq v))))))
+        (is (== 2020 (reduce + 10 (nnext (nnext (seq v)))))))))||||)
 
 (deftest test-778
   (testing "Testing CLJS-778, -rest, -next RSeq"

src/test/cljs/lite_test_runner.cljs

@@ -77,7 +77,7 @@
   'cljs.destructuring-test
   'cljs.printing-test
   'cljs.new-new-test
-  #_'cljs.seqs-test ;; rseq Vector
+  'cljs.seqs-test ;; rseq Vector
   #_'cljs.hashing-test
   #_'cljs.interop-test ;; ES6 stuff
   #_'cljs.iterator-test