CLJS-3260: and/or optimization as compiler pass

src/main/cljs/cljs/analyzer/passes/and_or.cljc

@@ -0,0 +1,97 @@
+;; Copyright (c) Rich Hickey. All rights reserved.
+;; The use and distribution terms for this software are covered by the
+;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;; which can be found in the file epl-v10.html at the root of this distribution.
+;; By using this software in any fashion, you are agreeing to be bound by
+;; the terms of this license.
+;; You must not remove this notice, or any other, from this software.
+
+(ns cljs.analyzer.passes.and-or)
+
+(def simple-ops
+  #{:var :js-var :local :invoke :const :host-field :host-call :js :quote})
+
+(defn ->expr-env [ast]
+  (assoc-in ast [:env :context] :expr))
+
+(defn simple-op? [ast]
+  (contains? simple-ops (:op ast)))
+
+(defn simple-test-expr?
+  [{:keys [op] :as ast}]
+  (boolean
+    (and (simple-op? ast)
+         ('#{boolean seq}
+           (or (:tag ast)
+               (when (#{:local :var} op)
+                 (-> ast :info :tag)))))))
+
+(defn single-binding-let? [ast]
+  (and (= :let (:op ast))
+    (= 1 (count (-> ast :bindings)))))
+
+(defn no-statements? [let-ast]
+  (= [] (-> let-ast :body :statements)))
+
+(defn returns-if? [let-ast]
+  (= :if (-> let-ast :body :ret :op)))
+
+(defn simple-test-binding-let? [ast]
+  (and (single-binding-let? ast)
+       (no-statements? ast)
+       (simple-test-expr? (-> ast :bindings first :init))
+       (returns-if? ast)))
+
+(defn test=then? [if-ast]
+  ;; remove :env, if same, local will differ only by
+  ;; :context (:expr | :statement)
+  (= (dissoc (:test if-ast) :env)
+    (dissoc (:then if-ast) :env)))
+
+(defn test=else? [if-ast]
+  ;; remove :env, if same, local will differ only by
+  ;; :context (:expr | :statement)
+  (= (dissoc (:test if-ast) :env)
+     (dissoc (:else if-ast) :env)))
+
+(defn simple-and? [ast]
+  (and (simple-test-binding-let? ast)
+       (test=else? (-> ast :body :ret))))
+
+(defn simple-or? [ast]
+  (and (simple-test-binding-let? ast)
+    (test=then? (-> ast :body :ret))))
+
+(defn optimizable-and? [ast]
+  (and (simple-and? ast)
+       (simple-test-expr? (-> ast :body :ret :then))))
+
+(defn optimizable-or? [ast]
+  (and (simple-or? ast)
+       (simple-test-expr? (-> ast :body :ret :else))))
+
+(defn optimize-and [ast]
+  {:op :js
+   :env (:env ast)
+   :segs ["((" ") && (" "))"]
+   :args [(-> ast :bindings first :init)
+          (->expr-env (-> ast :body :ret :then))]
+   :form (:form ast)
+   :children [:args]
+   :tag 'boolean})
+
+(defn optimize-or [ast]
+  {:op :js
+   :env (:env ast)
+   :segs ["((" ") || (" "))"]
+   :args [(-> ast :bindings first :init)
+          (->expr-env (-> ast :body :ret :else))]
+   :form (:form ast)
+   :children [:args]
+   :tag 'boolean})
+
+(defn optimize [env ast _]
+  (cond
+    (optimizable-and? ast) (optimize-and ast)
+    (optimizable-or? ast)  (optimize-or ast)
+    :else ast))

src/main/clojure/cljs/analyzer.cljc

@@ -14,6 +14,7 @@
                                      no-warn with-warning-handlers wrapping-errors]]
              [cljs.env.macros :refer [ensure]]))
   #?(:clj  (:require [cljs.analyzer.impl :as impl]
+                     [cljs.analyzer.passes.and-or :as and-or]
                      [cljs.env :as env :refer [ensure]]
                      [cljs.externs :as externs]
                      [cljs.js-deps :as deps]
@@ -26,6 +27,7 @@
                      [clojure.tools.reader :as reader]
                      [clojure.tools.reader.reader-types :as readers])
      :cljs (:require [cljs.analyzer.impl :as impl]
+                     [cljs.analyzer.passes.and-or :as and-or]
                      [cljs.env :as env]
                      [cljs.reader :as edn]
                      [cljs.tagged-literals :as tags]
@@ -4194,8 +4196,8 @@
            tag (assoc :tag tag))))))
 
 (def default-passes
-  #?(:clj  [infer-type check-invoke-arg-types ns-side-effects]
-     :cljs [infer-type check-invoke-arg-types]))
+  #?(:clj  [infer-type and-or/optimize check-invoke-arg-types ns-side-effects]
+     :cljs [infer-type and-or/optimize check-invoke-arg-types]))
 
 (defn analyze* [env form name opts]
   (let [passes *passes*

src/main/clojure/cljs/core.cljc

@@ -872,22 +872,8 @@
   ([] true)
   ([x] x)
   ([x & next]
-   (core/let [forms (concat [x] next)]
-     (core/cond
-       (every? #(simple-test-expr? &env %)
-         (map #(cljs.analyzer/no-warn (cljs.analyzer/analyze &env %)) forms))
-       (core/let [and-str (core/->> (repeat (count forms) "(~{})")
-                            (interpose " && ")
-                            (#(concat ["("] % [")"]))
-                            (apply core/str))]
-         (bool-expr `(~'js* ~and-str ~@forms)))
-
-       (typed-expr? &env x '#{boolean})
-       `(if ~x (and ~@next) false)
-
-       :else
-       `(let [and# ~x]
-          (if and# (and ~@next) and#))))))
+   `(let [and# ~x]
+      (if and# (and ~@next) and#))))
 
 (core/defmacro or
   "Evaluates exprs one at a time, from left to right. If a form
@@ -897,16 +883,8 @@
   ([] nil)
   ([x] x)
   ([x & next]
-   (core/let [forms (concat [x] next)]
-     (if (every? #(simple-test-expr? &env %)
-           (map #(cljs.analyzer/no-warn (cljs.analyzer/analyze &env %)) forms))
-       (core/let [or-str (core/->> (repeat (count forms) "(~{})")
-                           (interpose " || ")
-                           (#(concat ["("] % [")"]))
-                           (apply core/str))]
-         (bool-expr `(~'js* ~or-str ~@forms)))
-       `(let [or# ~x]
-          (if or# or# (or ~@next)))))))
+   `(let [or# ~x]
+      (if or# or# (or ~@next)))))
 
 (core/defmacro nil? [x]
   `(coercive-= ~x nil))

src/test/clojure/cljs/analyzer_pass_tests.clj

@@ -0,0 +1,118 @@
+;; Copyright (c) Rich Hickey. All rights reserved.
+;; The use and distribution terms for this software are covered by the
+;; Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)
+;; which can be found in the file epl-v10.html at the root of this distribution.
+;; By using this software in any fashion, you are agreeing to be bound by
+;; the terms of this license.
+;; You must not remove this notice, or any other, from this software.
+
+(ns cljs.analyzer-pass-tests
+  (:require [cljs.analyzer :as ana]
+            [cljs.analyzer.passes.and-or :as and-or]
+            [cljs.analyzer-tests :as ana-tests :refer [analyze]]
+            [cljs.compiler :as comp]
+            [cljs.compiler-tests :as comp-tests :refer [compile-form-seq emit]]
+            [cljs.env :as env]
+            [clojure.string :as string]
+            [clojure.test :as test :refer [deftest is testing]]))
+
+(deftest test-and-or-code-gen-pass
+  (testing "and/or optimization code gen pass"
+    (let [expr-env (assoc (ana/empty-env) :context :expr)
+          ast      (->> `(and true false)
+                     (analyze expr-env))
+          code     (with-out-str (emit ast))]
+      (is (= code "((true) && (false))")))
+    (let [expr-env (assoc (ana/empty-env) :context :expr)
+          ast      (analyze expr-env
+                     `(and true (or true false)))
+          code     (with-out-str (emit ast))]
+      (is (= code "((true) && (((true) || (false))))")))
+    (let [expr-env (assoc (ana/empty-env) :context :expr)
+          ast      (analyze expr-env
+                     `(or true (and false true)))
+          code     (with-out-str (emit ast))]
+      (is (= code "((true) || (((false) && (true))))")))
+    (let [expr-env (assoc (ana/empty-env) :context :expr)
+          local    (gensym)
+          ast      (analyze expr-env
+                     `(let [~local true]
+                        (and true (or ~local false))))
+          code     (with-out-str (emit ast))]
+      (is (= code
+            (string/replace
+              "(function (){var $SYM = true;\nreturn ((true) && ((($SYM) || (false))));\n})()"
+              "$SYM" (str local)))))))
+
+(deftest test-and-or-local
+  (testing "and/or optimizable with boolean local"
+    (let [expr-env (assoc (ana/empty-env) :context :expr)
+          ast      (->> `(let [x# true]
+                           (and x# true false))
+                     (analyze expr-env))
+          code     (with-out-str (emit ast))]
+      (is (= 2 (count (re-seq #"&&" code)))))))
+
+(deftest test-and-or-boolean-fn-arg
+  (testing "and/or optimizable with boolean fn arg"
+    (let [arg  (with-meta 'x {:tag 'boolean})
+          ast  (analyze (assoc (ana/empty-env) :context :expr)
+                 `(fn [~arg]
+                    (and ~arg false false)))
+          code (with-out-str (emit ast))]
+      (is (= 2 (count (re-seq #"&&" code)))))))
+
+(deftest test-and-or-boolean-var
+  (testing "and/or optimizable with boolean var"
+    (let [code (env/with-compiler-env (env/default-compiler-env)
+                 (compile-form-seq
+                   '[(ns foo.bar)
+                     (def baz true)
+                     (defn woz []
+                       (and baz false))]))]
+      (is (= 1 (count (re-seq #"&&" code)))))))
+
+(deftest test-and-or-js-boolean-var
+  (testing "and/or optimizable with js boolean var"
+    (let [code (env/with-compiler-env (env/default-compiler-env)
+                 (compile-form-seq
+                   '[(ns foo.bar)
+                     (defn baz []
+                       (and ^boolean js/woz false))]))]
+      (is (= 1 (count (re-seq #"&&" code)))))))
+
+(deftest test-and-or-host-call
+  (testing "and/or optimizable with host call"
+    (let [code (env/with-compiler-env (env/default-compiler-env)
+                 (compile-form-seq
+                   '[(ns foo.bar)
+                     (defn bar [x]
+                       (and ^boolean (.woz x) false))]))]
+      (is (= 1 (count (re-seq #"&&" code)))))))
+
+(deftest test-and-or-host-field
+  (testing "and/or optimizable with host field"
+    (let [code (env/with-compiler-env (env/default-compiler-env)
+                 (compile-form-seq
+                   '[(ns foo.bar)
+                     (defn bar [x]
+                       (and ^boolean (.-woz x) false))]))]
+      (is (= 1 (count (re-seq #"&&" code)))))))
+
+(deftest test-core-predicates
+  (testing "and/or optimizable with core predicates"
+    (let [code (env/with-compiler-env (env/default-compiler-env)
+                (comp/with-core-cljs {}
+                  (fn []
+                    (compile-form-seq
+                      '[(ns foo.bar)
+                        (defn bar []
+                          (and (even? 1) false))]))))]
+      (is (= 1 (count (re-seq #"&&" code)))))))
+
+(comment
+  (test/run-tests)
+
+  (require '[clojure.pprint :refer [pprint]])
+
+  )