cleanup

- remove simple-map-entry, more trouble than it's worth
  hassle, and does really save any spaced since need to implement
  everything to pass tests
- add trivial.core6 size ratchet

Author: swannodette

src/main/cljs/cljs/core.cljs

@@ -10384,56 +10384,6 @@ reduces them without incurring seq initialization"
 
 (declare Vector)
 
-(defn- simple-map-entry [k v]
-  (reify
-    ICounted
-    (-count [coll] 2)
-    IHash
-    (-hash [coll] (hash-ordered-coll [k v]))
-    ISequential
-    IEquiv
-    (-equiv [coll other] (equiv-sequential coll other))
-    IVector
-    (-assoc-n [_ n x]
-      (case n
-        0 (simple-map-entry x v)
-        1 (simple-map-entry k x)
-        (throw (js/Error. "Index out of bounds"))))
-    IAssociative
-    (-assoc [node k v]
-      (-assoc-n node k v))
-    (-contains-key? [node k]
-      (or (== k 0) (== k 1)))
-    ICollection
-    (-conj [coll x]
-      (if ^boolean LITE_MODE
-        (Vector. nil #js [k v x] nil)
-        [k v x]))
-    IMapEntry
-    (-key [_] k)
-    (-val [_] v)
-    ISeqable
-    (-seq [_] (IndexedSeq. #js [k v] 0 nil))
-    IIndexed
-    (-nth [_ i]
-      (case i, 0 k, 1 v, (throw (js/Error. "Index out of bounds"))))
-    (-nth [_ i not-found]
-      (case i, 0 k, 1 v, not-found))
-    ILookup
-    (-lookup [coll k] (-nth coll k nil))
-    (-lookup [coll k not-found] (-nth coll k not-found))
-    IFind
-    (-find [node x]
-      (case x
-        0 (simple-map-entry 0 k)
-        1 (simple-map-entry 1 v)
-        nil))
-    IFn
-    (-invoke [coll k]
-      (-nth coll k))
-    (-invoke [coll k not-found]
-      (-nth coll k not-found))))
-
 (defn- pr-writer-impl
   [obj writer opts]
   (cond
@@ -10472,9 +10422,10 @@ reduces them without incurring seq initialization"
             (.map
               (js-keys obj)
               (fn [k]
-                (simple-map-entry
+                (MapEntry.
                   (cond-> k (some? (.match k #"^[A-Za-z_\*\+\?!\-'][\w\*\+\?!\-']*$")) keyword)
-                  (unchecked-get obj k))))
+                  (unchecked-get obj k)
+                  nil)))
             pr-writer writer opts))
 
         (array? obj)
@@ -10655,10 +10606,10 @@ reduces them without incurring seq initialization"
           (when (or (keyword? k) (symbol? k))
             (if ns
               (when (= ns (namespace k))
-                (.push lm (simple-map-entry (strip-ns k) v))
+                (.push lm (MapEntry. (strip-ns k) v nil))
                 (recur ns entries))
               (when-let [new-ns (namespace k)]
-                (.push lm (simple-map-entry (strip-ns k) v))
+                (.push lm (MapEntry. (strip-ns k) v nil))
                 (recur new-ns entries))))
           #js [ns lm])))))
 
@@ -12566,7 +12517,7 @@ reduces them without incurring seq initialization"
   (next [_]
     (let [k (aget strkeys i)]
       (set! i (inc i))
-      (simple-map-entry (obj-map-key->keyword k) (unchecked-get strobj k)))))
+      (MapEntry. (obj-map-key->keyword k) (unchecked-get strobj k) nil))))
 
 (deftype ObjMap [meta strkeys strobj ^:mutable __hash]
   Object
@@ -12621,7 +12572,7 @@ reduces them without incurring seq initialization"
     (when (pos? (alength strkeys))
       (prim-seq
         (.map (.sort strkeys obj-map-compare-keys)
-          #(simple-map-entry (obj-map-key->keyword %) (unchecked-get strobj %))))))
+          #(MapEntry. (obj-map-key->keyword %) (unchecked-get strobj %) nil)))))
 
   ICounted
   (-count [coll] (alength strkeys))
@@ -12822,7 +12773,7 @@ reduces them without incurring seq initialization"
               (loop [j 0]
                 (when (< j len)
                   (do
-                    (.push arr (simple-map-entry (aget bckt j) (aget bckt (inc j))))
+                    (.push arr (MapEntry. (aget bckt j) (aget bckt (inc j)) nil))
                     (recur (+ j 2)))))
               (recur (inc i)))
             (prim-seq arr))))))

src/test/cljs/cljs/collections_test.cljs

@@ -1216,12 +1216,6 @@
   (is (= (simple-set [[3 4] [1 2] [5 6]])
          (into #{} [[3 4] [1 2] [5 6]]))))
 
-(deftest test-simple-map-entry
-  (is (= (simple-map-entry :foo 1)
-         (MapEntry. :foo 1 nil)))
-  (is (= (hash (simple-map-entry :foo 1))
-         (hash (MapEntry. :foo 1 nil)))))
-
 (comment
 
   (run-tests)

src/test/cljs/cljs/lite_collections_test.cljs

@@ -18,37 +18,12 @@
   (let [a {:foo 1}]
     (is (== 1 (:foo a)))))
 
-(deftest test-simple-map-entry-eq-hash
-  (is (= (simple-map-entry 1 2) (simple-map-entry 1 2)))
-  (is (= (simple-map-entry 1 2)
-        (MapEntry. 1 2 nil)))
-  (is (== (hash (simple-map-entry 1 2))
-          (hash (MapEntry. 1 2 nil)))))
-
 (deftest test-simple-set-with-set
   (is (= (simple-set []) (set [])))
   (is (= (set []) (simple-set [])))
-  (is (= (simple-set [(simple-map-entry 1 2)])
+  (is (= (simple-set [(MapEntry. 1 2 nil)])
          (set [(MapEntry. 1 2 nil)]))))
 
-(deftest test-hash-map-simple-map-entry
-  (let [m (assoc (. HashMap -EMPTY) (simple-map-entry 1 2) true)]
-    (is (contains? m (simple-map-entry 1 2)))))
-
-(deftest test-simple-set-simple-map-entry
-  (let [a (simple-set [(simple-map-entry 1 2)])]
-    (is (contains? a (simple-map-entry 1 2)))))
-
-(deftest test-simple-map-entry-lookups
-  (let [me (simple-map-entry :foo "bar")]
-    (is (= :foo (get me 0)))
-    (is (= "bar" (get me 1)))
-    (is (= [0 :foo]
-          (vec (find (simple-map-entry :foo "bar") 0))))
-    (is (= [:foo "b"]
-          (vec (update (simple-map-entry :foo "bar") 1 first))
-          (vec (update-in (simple-map-entry :foo "bar") [1] first))))))
-
 (comment
 
   (require '[cljs.lite-collections-test] :reload)

src/test/cljs_build/trivial/core6.cljs

@@ -0,0 +1,3 @@
+(ns trivial.core6)
+
+(.log js/console (->> (map inc (range 10)) (filter even?) (partition 2) (drop 1) (mapcat identity) into-array)})

src/test/clojure/cljs/build_api_tests.clj

@@ -804,6 +804,22 @@
      (build/build (build/inputs (io/file inputs "trivial/core5.cljs")) opts cenv)
      (is (< (.length out-file) 32768)))))
 
+(deftest lite-mode-api-code-size-ratchet
+  (testing ":lite-mode + :elide-to-string, typical cljs.core api usage < 32K"
+   (let [out (.getPath (io/file (test/tmp-dir) "trivial-output-map-test-out"))
+         out-file (io/file out "main.js")
+         {:keys [inputs opts]} {:inputs (str (io/file "src" "test" "cljs_build"))
+                                :opts {:main 'trivial.core6
+                                       :output-dir out
+                                       :output-to (.getPath out-file)
+                                       :lite-mode true
+                                       :elide-to-string true
+                                       :optimizations :advanced}}
+         cenv (env/default-compiler-env)]
+     (test/delete-out-files out)
+     (build/build (build/inputs (io/file inputs "trivial/core6.cljs")) opts cenv)
+     (is (< (.length out-file) 32768)))))
+
 (deftest cljs-3255-nil-inputs-build
   (let [out (.getPath (io/file (test/tmp-dir) "3255-test-out"))
         out-file (io/file out "main.js")