CLJS-2046: Optimize expression in call position

If a function expression like `(@x :m)` is seen, the compiler
first binds the `@x` so efficient calls that check for the IFn
protocol are emitted.
Also add a test for CLJS-855

Author: rauhs

src/main/clojure/cljs/analyzer.cljc

@@ -2859,7 +2859,18 @@
         argc    (count args)
         fn-var? (-> fexpr :info :fn-var)
         kw?     (= 'cljs.core/Keyword (:tag fexpr))
-        cur-ns  (-> env :ns :name)]
+        cur-ns  (-> env :ns :name)
+        HO-invoke? (and (boolean *cljs-static-fns*)
+                        (not fn-var?)
+                        (not kw?)
+                        (not (analyzed? f)))
+        ;; function expressions, eg: ((deref m) x) or ((:x m) :a)
+        bind-f-expr? (and HO-invoke?
+                          (not (symbol? f)))
+        ;; Higher order invokes with (some) argument expressions. Bind the arguments
+        ;; to avoid exponential complexity that is created by the IFn arity check branch.
+        bind-args? (and HO-invoke?
+                        (not (all-values? args)))]
     (when ^boolean fn-var?
       (let [{:keys [^boolean variadic max-fixed-arity method-params name ns macro]} (:info fexpr)]
         ;; don't warn about invalid arity when when compiling a macros namespace
@@ -2881,19 +2892,20 @@
         (warning :fn-deprecated env {:fexpr fexpr})))
     (when (some? (-> fexpr :info :type))
       (warning :invoke-ctor env {:fexpr fexpr}))
-    (if (or (not (boolean *cljs-static-fns*))
-            (not (symbol? f))
-            fn-var?
-            (analyzed? f)
-            (all-values? args))
+    (if (or bind-args? bind-f-expr?)
+      (let [arg-syms (when bind-args? (take argc (repeatedly gensym)))
+            f-sym (when bind-f-expr? (gensym "fexpr__"))
+            bindings (cond-> []
+                       bind-args? (into (interleave arg-syms args))
+                       bind-f-expr? (conj f-sym f))]
+        (analyze env
+                 `(let [~@bindings]
+                    (~(vary-meta (if bind-f-expr? f-sym f) assoc ::analyzed true)
+                      ~@(if bind-args? arg-syms args)))))
       (let [ana-expr #(analyze enve %)
             argexprs (map ana-expr args)]
         {:env env :op :invoke :form form :f fexpr :args (vec argexprs)
-         :children (into [fexpr] argexprs)})
-      (let [arg-syms (take argc (repeatedly gensym))]
-        (analyze env
-                 `(let [~@(vec (interleave arg-syms args))]
-                    (~(vary-meta f assoc ::analyzed true) ~@arg-syms)))))))
+         :children (into [fexpr] argexprs)}))))
 
 (defn parse-invoke
   [env form]

src/test/cljs/cljs/invoke_test.cljs

@@ -9,6 +9,22 @@
   ([a] a)
   ([a b] a))
 
+(defn hof-fn-expr-should-be-bound
+  [funexpr0 normal-arg]
+  ((complement funexpr0) normal-arg))
+
+(defn hof-arg-should-be-bound
+  [hofinvoke inv-arg0]
+  (hofinvoke (inv-arg0)))
+
+(defn hof-fn-expr+args-should-be-bound
+  [funexpr1 inv-arg1]
+  ((complement funexpr1) (inv-arg1)))
+
+;; A keyword should not be bound in a let:
+(def foo (delay
+           (:dont-bind-this js/x)))
+
 (multi-fn 2)
 
 (gstr/urlEncode "foo")

src/test/clojure/cljs/compiler_tests.clj

@@ -237,8 +237,27 @@
       ;; closure js code must never use .call(
       (is (str/includes? content "goog.string.urlEncode("))
       ;; js/goog.string.urlDecode should not use .call
-      (is (str/includes? content "goog.string.urlDecode(")))
-    ))
+      (is (str/includes? content "goog.string.urlDecode("))
+      ;; We should NOT emit a let binding for simple (:dont-bind-this js/x)
+      (is (str/includes? content
+                         (str "new cljs.core.Keyword(null,\"dont-bind-this\",\"dont-bind-this\","
+                              "-140451389).cljs$core$IFn$_invoke$arity$1(x);")))
+      ;; CLJS-2046: Emit bindings for expressions like: (@m a0) or ((:x m) a0)
+      ;; The test: ((complement funexpr0) normal-arg)
+      (is (re-find #"(?m)^.*var fexpr.*=.*cljs.core.complement\(funexpr0\);$"
+                   content))
+      ;; CLJS-855: Emit binding for expressions like:
+      ;; (hofinvoke (inv-arg0))
+      (is (re-find #"(?m)^.*var .*=.*inv_arg0.cljs.core.IFn._invoke.arity.0 \?.*$"
+                   content))
+
+      ;; Now test both (855,2046) together:
+      ;; ((complement funexpr1) (inv-arg1))
+      (is (re-find #"(?m)^.*var fexpr.*=.*cljs.core.complement\(funexpr1\);$"
+                   content))
+      (is (re-find #"(?m)^.*var .*=.*inv_arg1.cljs.core.IFn._invoke.arity.0 \?.*$"
+                   content)))))
+#_(test-vars [#'test-optimized-invoke-emit])
 
 ;; CLJS-1225