CLJS-2099: Optimize apply by avoiding .apply

Avoid javascripts .apply in apply function.
Similar to apply-to now walks the passed sequence one by
one with first and next and calls the function efficiently.

Author: rauhs

src/main/cljs/cljs/core.cljs

@@ -3614,11 +3614,12 @@ reduces them without incurring seq initialization"
 
 (defn spread
   [arglist]
-  (cond
-   (nil? arglist) nil
-   (nil? (next arglist)) (seq (first arglist))
-   :else (cons (first arglist)
-               (spread (next arglist)))))
+  (when-not (nil? arglist)
+    (let [n (next arglist)]
+      (if (nil? n)
+        (seq (first arglist))
+        (cons (first arglist)
+              (spread n))))))
 
 (defn concat
   "Returns a lazy seq representing the concatenation of the elements in the supplied colls."
@@ -3729,52 +3730,89 @@ reduces them without incurring seq initialization"
 (gen-apply-to)
 
 (set! *unchecked-if* true)
+
+(defn- apply-to-simple
+  "Internal. DO NOT USE!
+  Assumes args was already called with seq beforehand!"
+  ([f ^seq args]
+   (if (nil? args)
+     (if (.-cljs$core$IFn$_invoke$arity$0 f)
+       (.cljs$core$IFn$_invoke$arity$0 f)
+       (.call f f))
+     (apply-to-simple f (-first args) (next args))))
+  ([f a0 ^seq args]
+   (if (nil? args)
+     (if (.-cljs$core$IFn$_invoke$arity$1 f)
+       (.cljs$core$IFn$_invoke$arity$1 f a0)
+       (.call f f a0))
+     (apply-to-simple f a0 (-first args) (next args))))
+  ([f a0 a1 ^seq args]
+   (if (nil? args)
+     (if (.-cljs$core$IFn$_invoke$arity$2 f)
+       (.cljs$core$IFn$_invoke$arity$2 f a0 a1)
+       (.call f f a0 a1))
+     (apply-to-simple f a0 a1 (-first args) (next args))))
+  ([f a0 a1 a2 ^seq args]
+   (if (nil? args)
+     (if (.-cljs$core$IFn$_invoke$arity$3 f)
+       (.cljs$core$IFn$_invoke$arity$3 f a0 a1 a2)
+       (.call f f a0 a1 a2))
+     (apply-to-simple f a0 a1 a2 (-first args) (next args))))
+  ([f a0 a1 a2 a3 ^seq args]
+   (if (nil? args)
+     (if (.-cljs$core$IFn$_invoke$arity$4 f)
+       (.cljs$core$IFn$_invoke$arity$4 f a0 a1 a2 a3)
+       (.call f f a0 a1 a2 a3))
+     (gen-apply-to-simple f 4 args))))
+
 (defn apply
   "Applies fn f to the argument list formed by prepending intervening arguments to args."
   ([f args]
-     (let [fixed-arity (.-cljs$lang$maxFixedArity f)]
-       (if (.-cljs$lang$applyTo f)
-         (let [bc (bounded-count (inc fixed-arity) args)]
-          (if (<= bc fixed-arity)
-            (apply-to f bc args)
-            (.cljs$lang$applyTo f args)))
-         (.apply f f (to-array args)))))
+   (if (.-cljs$lang$applyTo f)
+     (let [fixed-arity (.-cljs$lang$maxFixedArity f)
+           bc (bounded-count (inc fixed-arity) args)]
+       (if (<= bc fixed-arity)
+         (apply-to f bc args)
+         (.cljs$lang$applyTo f args)))
+     (apply-to-simple f (seq args))))
   ([f x args]
+   (if (.-cljs$lang$applyTo f)
      (let [arglist (list* x args)
-           fixed-arity (.-cljs$lang$maxFixedArity f)]
-       (if (.-cljs$lang$applyTo f)
-         (let [bc (bounded-count (inc fixed-arity) arglist)]
-          (if (<= bc fixed-arity)
-            (apply-to f bc arglist)
-            (.cljs$lang$applyTo f arglist)))
-         (.apply f f (to-array arglist)))))
+           fixed-arity (.-cljs$lang$maxFixedArity f)
+           bc (inc (bounded-count fixed-arity args))]
+       (if (<= bc fixed-arity)
+         (apply-to f bc arglist)
+         (.cljs$lang$applyTo f arglist)))
+     (apply-to-simple f x (seq args))))
   ([f x y args]
+   (if (.-cljs$lang$applyTo f)
      (let [arglist (list* x y args)
-           fixed-arity (.-cljs$lang$maxFixedArity f)]
-       (if (.-cljs$lang$applyTo f)
-         (let [bc (bounded-count (inc fixed-arity) arglist)]
-          (if (<= bc fixed-arity)
-            (apply-to f bc arglist)
-            (.cljs$lang$applyTo f arglist)))
-         (.apply f f (to-array arglist)))))
+           fixed-arity (.-cljs$lang$maxFixedArity f)
+           bc (+ 2 (bounded-count (dec fixed-arity) args))]
+       (if (<= bc fixed-arity)
+         (apply-to f bc arglist)
+         (.cljs$lang$applyTo f arglist)))
+     (apply-to-simple f x y (seq args))))
   ([f x y z args]
+   (if (.-cljs$lang$applyTo f)
      (let [arglist (list* x y z args)
-           fixed-arity (.-cljs$lang$maxFixedArity f)]
-       (if (.-cljs$lang$applyTo f)
-         (let [bc (bounded-count (inc fixed-arity) arglist)]
-          (if (<= bc fixed-arity)
-            (apply-to f bc arglist)
-            (.cljs$lang$applyTo f arglist)))
-         (.apply f f (to-array arglist)))))
+           fixed-arity (.-cljs$lang$maxFixedArity f)
+           bc (+ 3 (bounded-count (- fixed-arity 2) args))]
+       (if (<= bc fixed-arity)
+         (apply-to f bc arglist)
+         (.cljs$lang$applyTo f arglist)))
+     (apply-to-simple f x y z (seq args))))
   ([f a b c d & args]
-     (let [arglist (cons a (cons b (cons c (cons d (spread args)))))
-           fixed-arity (.-cljs$lang$maxFixedArity f)]
-       (if (.-cljs$lang$applyTo f)
-         (let [bc (bounded-count (inc fixed-arity) arglist)]
-          (if (<= bc fixed-arity)
-            (apply-to f bc arglist)
-            (.cljs$lang$applyTo f arglist)))
-         (.apply f f (to-array arglist))))))
+   (if (.-cljs$lang$applyTo f)
+     (let [spread-args (spread args)
+           arglist (cons a (cons b (cons c (cons d spread-args))))
+           fixed-arity (.-cljs$lang$maxFixedArity f)
+           bc (+ 4 (bounded-count (- fixed-arity 3) spread-args))]
+       (if (<= bc fixed-arity)
+         (apply-to f bc arglist)
+         (.cljs$lang$applyTo f arglist)))
+     (apply-to-simple f a b c d (spread args)))))
+
 (set! *unchecked-if* false)
 
 (defn vary-meta

src/main/clojure/cljs/core.cljc

@@ -44,7 +44,7 @@
                                        defcurried rfn specify! js-this this-as implements? array js-obj
                                        simple-benchmark gen-apply-to js-str es6-iterable load-file* undefined?
                                        specify copy-arguments goog-define js-comment js-inline-comment
-                                       unsafe-cast require-macros use-macros])])
+                                       unsafe-cast require-macros use-macros gen-apply-to-simple])])
   #?(:cljs (:require-macros [cljs.core :as core]
                             [cljs.support :refer [assert-args]]))
   (:require clojure.walk
@@ -2668,17 +2668,13 @@
 (core/defn- gen-apply-to-helper
   ([] (gen-apply-to-helper 1))
   ([n]
-   (core/let [prop (symbol (core/str "-cljs$core$IFn$_invoke$arity$" n))
-              f (symbol (core/str "cljs$core$IFn$_invoke$arity$" n))]
-     (if (core/<= n 20)
-       `(let [~(cs (core/dec n)) (-first ~'args)
-              ~'args (-rest ~'args)]
-          (if (== ~'argc ~n)
-            (if (. ~'f ~prop)
-              (. ~'f (~f ~@(take n cs)))
-              (~'f ~@(take n cs)))
-            ~(gen-apply-to-helper (core/inc n))))
-       `(throw (js/Error. "Only up to 20 arguments supported on functions"))))))
+   (if (core/<= n 20)
+     `(let [~(cs (core/dec n)) (-first ~'args)
+            ~'args (-rest ~'args)]
+        (if (== ~'argc ~n)
+          (~'f ~@(take n cs))
+          ~(gen-apply-to-helper (core/inc n))))
+     `(throw (js/Error. "Only up to 20 arguments supported on functions")))))
 
 (core/defmacro gen-apply-to []
   `(do
@@ -2690,6 +2686,34 @@
            ~(gen-apply-to-helper))))
      (set! ~'*unchecked-if* false)))
 
+(core/defn- gen-apply-to-simple-helper
+  [f num-args args]
+  (core/let [new-arg-sym (symbol (core/str "a" num-args))
+             proto-name (core/str "cljs$core$IFn$_invoke$arity$" (core/inc num-args))
+             proto-prop (symbol (core/str ".-" proto-name))
+             proto-inv (symbol (core/str "." proto-name))
+             next-sym (symbol (core/str "next_" num-args))
+             all-args (mapv #(symbol (core/str "a" %)) (range (core/inc num-args)))]
+    `(let [~new-arg-sym (cljs.core/-first ~args)
+           ~next-sym (cljs.core/next ~args)]
+       (if (nil? ~next-sym)
+         (if (~proto-prop ~f)
+           (~proto-inv ~f ~@all-args)
+           (.call ~f ~f ~@all-args))
+         ~(if (core/<= 19 num-args)
+            ;; We've exhausted all protocols, fallback to .apply:
+            `(let [arr# (cljs.core/array ~@all-args)]
+               (loop [s# ~next-sym]
+                 (when s#
+                   (do (.push arr# (cljs.core/-first s#))
+                       (recur (cljs.core/next s#)))))
+               (.apply ~f ~f arr#))
+            (gen-apply-to-simple-helper f (core/inc num-args) next-sym))))))
+
+(core/defmacro gen-apply-to-simple
+  [f num-args args]
+  (gen-apply-to-simple-helper f num-args args))
+
 (core/defmacro with-out-str
   "Evaluates exprs in a context in which *print-fn* is bound to .append
   on a fresh StringBuffer.  Returns the string created by any nested