Merge branch 'master' into cljs-3454/set-identical

Author: swannodette

src/main/cljs/cljs/core.cljs

@@ -3110,7 +3110,7 @@ reduces them without incurring seq initialization"
   ([] "")
   ([x] (if (nil? x)
          ""
-         (.join #js [x] "")))
+         (.toString x)))
   ([x & ys]
    (loop [sb (StringBuffer. (str x)) more ys]
      (if more
@@ -6002,6 +6002,10 @@ reduces them without incurring seq initialization"
   (-empty [coll]
     ())
 
+  ICounted
+  (-count [coll]
+    (- (-count vec) (+ i off)))
+
   IChunkedSeq
   (-chunked-first [coll]
     (array-chunk node off))
@@ -12611,10 +12615,14 @@ reduces them without incurring seq initialization"
     (let [k (if-not (keyword? k) k (keyword->obj-map-key k))]
       (if (string? k)
         (if-not (nil? (scan-array 1 k strkeys))
-          (let [new-strobj (obj-clone strobj strkeys)]
-            (gobject/set new-strobj k v)
-            (ObjMap. meta strkeys new-strobj nil))             ;overwrite
-          (let [new-strobj (obj-clone strobj strkeys)          ; append
+          (if (identical? v (gobject/get strobj k))
+            coll
+            ; overwrite
+            (let [new-strobj (obj-clone strobj strkeys)]
+              (gobject/set new-strobj k v)
+              (ObjMap. meta strkeys new-strobj nil))) 
+          ; append
+          (let [new-strobj (obj-clone strobj strkeys) 
                 new-keys (aclone strkeys)]
             (gobject/set new-strobj k v)
             (.push new-keys k)
@@ -12820,10 +12828,12 @@ reduces them without incurring seq initialization"
               i (scan-array-equiv 2 k new-bucket)]
           (aset new-hashobj h new-bucket)
           (if (some? i)
-            (do
-              ; found key, replace
-              (aset new-bucket (inc i) v)
-              (HashMap. meta count new-hashobj nil))
+            (if (identical? v (aget new-bucket (inc i)))
+              coll
+              (do
+                ; found key, replace
+                (aset new-bucket (inc i) v)
+                (HashMap. meta count new-hashobj nil)))
             (do
               ; did not find key, append
               (.push new-bucket k v)
@@ -12962,7 +12972,10 @@ reduces them without incurring seq initialization"
 
   ICollection
   (-conj [coll o]
-    (Set. meta (assoc hash-map o o) nil))
+    (let [new-hash-map (assoc hash-map o o)]
+      (if (identical? new-hash-map hash-map)
+        coll
+        (Set. meta new-hash-map nil))))
 
   IEmptyableCollection
   (-empty [coll] (with-meta (. Set -EMPTY) meta))

src/main/clojure/cljs/core.cljc

@@ -866,23 +866,29 @@
                             (apply core/str))]
      (string-expr (list* 'js* (core/str "[" strs "].join('')") x ys)))))
 
+(core/defn- compile-time-constant? [x]
+  (core/or
+   (core/string? x)
+   (core/keyword? x)
+   (core/boolean? x)
+   (core/number? x)))
+
 ;; TODO: should probably be a compiler pass to avoid the code duplication
 (core/defmacro str
-  ([] "")
-  ([x]
-   (if (typed-expr? &env x '#{string})
-     x
-     (string-expr (core/list 'js* "cljs.core.str.cljs$core$IFn$_invoke$arity$1(~{})" x))))
-  ([x & ys]
-   (core/let [interpolate (core/fn [x]
-                            (if (typed-expr? &env x '#{string clj-nil})
-                              "~{}"
-                              "cljs.core.str.cljs$core$IFn$_invoke$arity$1(~{})"))
-              strs        (core/->> (core/list* x ys)
-                            (map interpolate)
-                            (interpose ",")
-                            (apply core/str))]
-     (string-expr (list* 'js* (core/str "[" strs "].join('')") x ys)))))
+  [& xs]
+  (core/let [interpolate (core/fn [x]
+                           (core/cond
+                             (typed-expr? &env x '#{clj-nil})
+                             nil
+                             (compile-time-constant? x)
+                             ["+~{}" x]
+                             :else
+                             ;; Note: can't assume non-nil despite tag here, so we go through str 1-arity
+                             ["+cljs.core.str.cljs$core$IFn$_invoke$arity$1(~{})" x]))
+             strs+args (keep interpolate xs)
+             strs (string/join (map first strs+args))
+             args (map second strs+args)]
+    (string-expr (list* 'js* (core/str "(\"\"" strs ")") args))))
 
 (core/defn- bool-expr [e]
   (vary-meta e assoc :tag 'boolean))

src/test/cljs/cljs/core_test.cljs

@@ -1978,3 +1978,11 @@
   (is (= "1two:threefour#{:five}[:six]#{:seven}{:eight :nine}"
          (apply cljs.core/str_ 1 ["two" :three 'four #{:five} [:six] #{:seven} {:eight :nine}])))
   (is (= "1234" (apply cljs.core/str_ 1 2 [3 4]))))
+
+(deftest test-cljs-3452
+  (let [obj #js {:valueOf (fn [] "dude")
+                 :toString (fn [] "correct")}
+        str-fn (fn [x y]
+                 (str x obj y "\"foobar\"" 1 :foo nil))]
+    (testing "object is stringified using toString"
+      (is (= "correct6\"foobar\"1:foo" (str-fn nil (+ 1 2 3)))))))

src/test/cljs/cljs/lite_collections_test.cljs

@@ -28,6 +28,14 @@
   (= 1 (aget (clj->js (obj-map :x 1)) "x"))
   (= 1 (aget (clj->js {:x 1}) "x")))
 
+(deftest test-unchanged-identical?
+  (let [m (obj-map :foo 1)]
+    (identical? m (assoc m :foo 1)))
+  (let [m (simple-hash-map :foo 1)]
+    (identical? m (assoc m :foo 1)))
+  (let [s (simple-set [:foo])]
+    (identical? s (conj s :foo))))
+
 (comment
 
   (require '[cljs.lite-collections-test] :reload)

src/test/cljs_build/cljs_3452_str_optimizations/core.cljs

@@ -0,0 +1,9 @@
+(ns cljs-3452-str-optimizations.core)
+
+(defn my-str-fn [x y]
+  (str x y nil ::foobar "my
+
+multiline
+
+string with `backticks`"
+       true false 3.14))

src/test/clojure/cljs/build_api_tests.clj

@@ -940,3 +940,21 @@
       (.delete (io/file "package.json"))
       (test/delete-node-modules)
       (test/delete-out-files out))))
+
+(deftest test-cljs-3452-str-optimizations
+  (testing "Test that uses compile time optimizations from str macro"
+    (let [out (.getPath (io/file (test/tmp-dir) "cljs-3452-str-optimizations-out"))]
+      (test/delete-out-files out)
+      (let [{:keys [inputs opts]} {:inputs (str (io/file "src" "test" "cljs_build"))
+                                   :opts {:main 'cljs-3452-str-optimizations.core
+                                          :output-dir out
+                                          :optimizations :none
+                                          :closure-warnings {:check-types :off}}}
+            cenv (env/default-compiler-env)]
+        (build/build (build/inputs (io/file inputs "cljs_3452_str_optimizations/core.cljs")) opts cenv))
+      (let [source (slurp (io/file out "cljs_3452_str_optimizations/core.js"))]
+        (testing "only seven string concats, compile time nil is ignored"
+          (is (= 7 (count (re-seq #"[\+]" source)))))
+        (testing "only two 1-arity str calls, compile time constants are optimized"
+          (is (= 2 (count (re-seq #"\$1\(.*?\)" source))))))
+      (test/delete-out-files out))))