rename ast op :constant -> :const

Author: frenchy64

src/main/clojure/cljs/analyzer.cljc

@@ -1209,7 +1209,7 @@
 (defn analyze-keyword
   [env sym]
   (register-constant! env sym)
-  {:op :constant :env env :form sym :tag 'cljs.core/Keyword})
+  {:op :const :env env :form sym :tag 'cljs.core/Keyword})
 
 (defn get-tag [e]
   (if-some [tag (-> e :form meta :tag)]
@@ -1252,8 +1252,8 @@
 (defn infer-if [env e]
   (let [{{:keys [op form]} :test} e
         then-tag (infer-tag env (:then e))]
-    (if (and #?(:clj (= op :constant)
-                :cljs (keyword-identical? op :constant))
+    (if (and #?(:clj (= op :const)
+                :cljs (keyword-identical? op :const))
              (not (nil? form))
              (not (false? form)))
       then-tag
@@ -1310,7 +1310,7 @@
         :def      (infer-tag env (:init e))
         :invoke   (infer-invoke env e)
         :if       (infer-if env e)
-        :constant (case (:form e)
+        :const    (case (:form e)
                     true BOOLEAN_SYM
                     false BOOLEAN_SYM
                     ANY_SYM)
@@ -1394,7 +1394,7 @@
     (assert (every? (fn [t]
                       (or
                         (-> t :info :const)
-                        (and (= :constant (:op t))
+                        (and (= :const (:op t))
                              ((some-fn number? string? char?) (:form t)))))
               (apply concat tests))
       "case* tests must be numbers, strings, or constants")
@@ -1489,7 +1489,7 @@
 
 (defn constant-value?
   [{:keys [op] :as ast}]
-  (or (= :constant op)
+  (or (= :const op)
       (and (#{:map :set :vector :list} op)
            (every? constant-value? (:children ast)))))
 
@@ -3199,7 +3199,7 @@
   (if ^boolean (:quoted? env)
     (do
       (register-constant! env sym)
-      (analyze-wrap-meta {:op :constant :env env :form sym :tag 'cljs.core/Symbol}))
+      (analyze-wrap-meta {:op :const :env env :form sym :tag 'cljs.core/Symbol}))
     (let [{:keys [line column]} (meta sym)
           env  (if-not (nil? line)
                  (assoc env :line line)
@@ -3591,7 +3591,7 @@
                    (instance? Character form) 'string
                    (true? form) 'boolean
                    (false? form) 'boolean)]
-         (cond-> {:op :constant :env env :form form}
+         (cond-> {:op :const :env env :form form}
            tag (assoc :tag tag))))))
 
 #?(:cljs
@@ -3613,7 +3613,7 @@
                    (string? form) STRING_SYM
                    (true? form) BOOLEAN_SYM
                    (false? form) BOOLEAN_SYM)]
-         (cond-> {:op :constant :env env :form form}
+         (cond-> {:op :const :env env :form form}
            tag (assoc :tag tag))))))
 
 (defn analyze* [env form name opts]

src/main/clojure/cljs/compiler.cljc

@@ -414,7 +414,7 @@
 (def ^:private array-map-threshold 8)
 
 (defn distinct-keys? [keys]
-  (and (every? #(= (:op %) :constant) keys)
+  (and (every? #(= (:op %) :const) keys)
        (= (count (into #{} keys)) (count keys))))
 
 (defmethod emit* :map
@@ -459,7 +459,7 @@
           (emits "cljs.core.PersistentVector.fromArray([" (comma-sep items) "], true)"))))))
 
 (defn distinct-constants? [items]
-  (and (every? #(= (:op %) :constant) items)
+  (and (every? #(= (:op %) :const) items)
        (= (count (into #{} items)) (count items))))
 
 (defmethod emit* :set
@@ -494,21 +494,21 @@
   (emit-wrap env
     (emits ns ".map__GT_" name "(" items ")")))
 
-(defmethod emit* :constant
+(defmethod emit* :const
   [{:keys [form env]}]
   (when-not (= :statement (:context env))
     (emit-wrap env (emit-constant form))))
 
 (defn truthy-constant? [{:keys [op form const-expr]}]
-  (or (and (= op :constant)
+  (or (and (= op :const)
            form
            (not (or (and (string? form) (= form ""))
                     (and (number? form) (zero? form)))))
       (and (some? const-expr)
            (truthy-constant? const-expr))))
 
 (defn falsey-constant? [{:keys [op form const-expr]}]
-  (or (and (= op :constant)
+  (or (and (= op :const)
            (or (false? form) (nil? form)))
       (and (some? const-expr)
            (falsey-constant? const-expr))))
@@ -943,7 +943,7 @@
         (when name
           (emits "catch (" (munge name) "){" catch "}"))
         (when finally
-          (assert (not= :constant (:op finally)) "finally block cannot contain constant")
+          (assert (not= :const (:op finally)) "finally block cannot contain constant")
           (emits "finally {" finally "}"))
         (when (= :expr context)
           (emits "})()")))
@@ -1034,7 +1034,7 @@
                     (not (contains? (::ana/namespaces @env/*compiler*) ns))))
 
         keyword? (or (= 'cljs.core/Keyword (ana/infer-tag env f))
-                     (and (= (-> f :op) :constant)
+                     (and (= (-> f :op) :const)
                           (keyword? (-> f :form))))
         [f variadic-invoke]
         (if fn?

src/main/clojure/cljs/core.cljc

@@ -845,7 +845,7 @@
 
 (core/defn- simple-test-expr? [env ast]
   (core/and
-    (#{:var :invoke :constant :dot :js} (:op ast))
+    (#{:var :invoke :const :dot :js} (:op ast))
     ('#{boolean seq} (cljs.analyzer/infer-tag env ast))))
 
 (core/defmacro and
@@ -2528,7 +2528,7 @@
   ([] '(.-EMPTY cljs.core/PersistentArrayMap))
   ([& kvs]
    (core/let [keys (map first (partition 2 kvs))]
-     (if (core/and (every? #(= (:op %) :constant)
+     (if (core/and (every? #(= (:op %) :const)
                      (map #(cljs.analyzer/no-warn (cljs.analyzer/analyze &env %)) keys))
            (= (count (into #{} keys)) (count keys)))
        `(cljs.core/PersistentArrayMap. nil ~(clojure.core// (count kvs) 2) (array ~@kvs) nil)
@@ -2548,7 +2548,7 @@
   ([] `(.-EMPTY cljs.core/PersistentHashSet))
   ([& xs]
     (if (core/and (core/<= (count xs) 8)
-                  (every? #(= (:op %) :constant)
+                  (every? #(= (:op %) :const)
                     (map #(cljs.analyzer/no-warn (cljs.analyzer/analyze &env %)) xs))
                   (= (count (into #{} xs)) (count xs)))
       `(cljs.core/PersistentHashSet. nil