CLJS-2801: Add :quote AST op and remove :list op

1. add :quote AST op
 - This moves a lot more logic into handling :const in the emitter.
   We rename emit-constant -> emit-constant* and turn emit-constant
   into a function that emits metadata for each form before delegating
   to emit-constant*.
 - Some emit* defmethods are factored out into higher-order function helpers
   (:{map,list,vector,set} -> emit-{map,list,vector,set}) and are now called
   from both emit and emit-constant.
 - analyze-const now registers constants, but throws away the analysis results.

2. remove :list :op
 - subsumed by :quote'd :const. analyze-list still used to register constants.

Author: frenchy64

src/main/cljs/cljs/js.cljs

@@ -1229,11 +1229,11 @@
 (defn- emit-fn [f]
   (print "cljs.js.get_fn(" (put-fn f) ")"))
 
-(defmethod comp/emit-constant js/Function
+(defmethod comp/emit-constant* js/Function
   [f]
   (emit-fn f))
 
-(defmethod comp/emit-constant cljs.core/Var
+(defmethod comp/emit-constant* cljs.core/Var
   [f]
   (emit-fn f))
 

src/main/clojure/cljs/analyzer.cljc

@@ -1249,8 +1249,14 @@
 
 (def BOOLEAN_OR_SEQ '#{boolean seq})
 
+(defn unwrap-quote [{:keys [op] :as expr}]
+  (if #?(:clj (= op :quote)
+         :cljs (keyword-identical? op :quote))
+    (:expr expr)
+    expr))
+
 (defn infer-if [env e]
-  (let [{{:keys [op form]} :test} e
+  (let [{:keys [op form]} (unwrap-quote (:test e))
         then-tag (infer-tag env (:then e))]
     (if (and #?(:clj (= op :const)
                 :cljs (keyword-identical? op :const))
@@ -1314,6 +1320,7 @@
                     true BOOLEAN_SYM
                     false BOOLEAN_SYM
                     ANY_SYM)
+        :quote    (infer-tag env (:expr e))
         :var      (if-some [init (:init e)]
                     (infer-tag env init)
                     (infer-tag env (:info e)))
@@ -1522,10 +1529,19 @@
 
 (defn constant-value?
   [{:keys [op] :as ast}]
-  (or (= :const op)
-      (and (#{:map :set :vector :list} op)
+  (or (#{:quote :const} op)
+      (and (#{:map :set :vector} op)
            (every? constant-value? (ast-children ast)))))
 
+(defn const-expr->constant-value [{:keys [op] :as e}]
+  (case op 
+    :quote  (const-expr->constant-value (:expr e))
+    :const  (:val e)
+    :map    (zipmap (map const-expr->constant-value (:keys e))
+                    (map const-expr->constant-value (:vals e)))
+    :set    (into #{} (map const-expr->constant-value (:items e)))
+    :vector (into [] (map const-expr->constant-value (:items e)))))
+
 (defmethod parse 'def
   [op env form _ _]
   (when (> (count form) 4)
@@ -2062,9 +2078,28 @@
       :exprs exprs
       :children [:exprs])))
 
+(defn analyze-const
+  [env form]
+  (let [;; register constants
+        {:keys [tag]} (analyze (assoc env :quoted? true) form)]
+    {:op       :const
+     :env      env
+     :literal? true
+     :val      form
+     :tag      tag
+     :form     form}))
+
 (defmethod parse 'quote
-  [_ env [_ x] _ _]
-  (analyze (assoc env :quoted? true) x))
+  [_ env [_ x :as form] _ _]
+  (when (not= 2 (count form))
+    (throw (error env "Wrong number of args to quote")))
+  (let [expr (analyze-const env x)]
+    {:op :quote
+     :expr expr
+     :env env
+     :form form
+     :tag (:tag expr)
+     :children [:expr]}))
 
 (defmethod parse 'new
   [_ env [_ ctor & args :as form] _ _]
@@ -3466,6 +3501,8 @@
                         :children [:keys :vals]
                         :tag 'cljs.core/IMap})))
 
+;; :list is not used in the emitter any more, but analyze-list is called from analyze-const
+;; to hit the `register-constant!` cases for symbols and keywords.
 (defn analyze-list
   [env form]
   (let [expr-env (assoc env :context :expr)
@@ -3533,9 +3570,12 @@
 (defn elide-analyzer-meta [m]
   (dissoc m ::analyzed))
 
+(defn elide-irrelevant-meta [m]
+  (-> m elide-reader-meta elide-analyzer-meta))
+
 (defn analyze-wrap-meta [expr]
   (let [form (:form expr)
-        m    (-> (meta form) elide-reader-meta elide-analyzer-meta)]
+        m    (elide-irrelevant-meta (meta form))]
     (if (some? (seq m))
       (let [env (:env expr) ; take on expr's context ourselves
             expr (assoc-in expr [:env :context] :expr) ; change expr to :expr
@@ -3636,15 +3676,15 @@
        (set? form) (analyze-set env form)
        (keyword? form) (analyze-keyword env form)
        (instance? JSValue form) (analyze-js-value env form)
-       (= () form) (analyze-list env form)
        :else
        (let [tag (cond
                    (nil? form) 'clj-nil
                    (number? form) 'number
                    (string? form) 'string
                    (instance? Character form) 'string
                    (true? form) 'boolean
-                   (false? form) 'boolean)]
+                   (false? form) 'boolean
+                   (= () form) 'cljs.core/IList)]
          (cond-> {:op :const :val form :env env :form form}
            tag (assoc :tag tag))))))
 
@@ -3659,14 +3699,14 @@
        (cljs-set? form) (analyze-set env form)
        (keyword? form) (analyze-keyword env form)
        (instance? cljs.tagged-literals/JSValue form) (analyze-js-value env form)
-       (= () form) (analyze-list env form)
        :else
        (let [tag (cond
                    (nil? form) CLJ_NIL_SYM
                    (number? form) NUMBER_SYM
                    (string? form) STRING_SYM
                    (true? form) BOOLEAN_SYM
-                   (false? form) BOOLEAN_SYM)]
+                   (false? form) BOOLEAN_SYM
+                   (= () form) 'cljs.core/IList)]
          (cond-> {:op :const :val form :env env :form form}
            tag (assoc :tag tag))))))
 

src/main/clojure/cljs/closure.clj

@@ -1215,7 +1215,8 @@
 (defn- const-expr-form
   "Returns the :const-expr form for `sym` from `compiler-state`."
   [compiler-state sym]
-  (get-in compiler-state [::ana/namespaces (symbol (namespace sym)) :defs (symbol (name sym)) :const-expr :form]))
+  (let [const-expr (get-in compiler-state [::ana/namespaces (symbol (namespace sym)) :defs (symbol (name sym)) :const-expr])]
+    (some-> const-expr ana/const-expr->constant-value)))
 
 (defn compile-loader
   "Special compilation pass for cljs.loader namespace. cljs.loader must be