CLJS-2093: inline ^:const var values

first cut. Store init expr in the compiler environment. When returning
var AST if we are not def'ing a var then analyze :const-init if it
exists and add as :const-expr to var AST.

During emission of var if :const-expr key exists emit that instead.

Author: dnolen

src/main/clojure/cljs/analyzer.cljc

@@ -1299,6 +1299,7 @@
               ([_ sym doc init] {:sym sym :doc doc :init init}))
         args (apply pfn form)
         sym (:sym args)
+        const? (-> sym meta :const)
         sym-meta (meta sym)
         tag (-> sym meta :tag)
         protocol (-> sym meta :protocol valid-proto)
@@ -1381,6 +1382,8 @@
                          "cljs/core.cljs"
                          f))))}
           (when doc {:doc doc})
+          (when const?
+            {:const-init (:init args)})
           (when (true? dynamic) {:dynamic true})
           (source-info var-name env)
           ;; the protocol a protocol fn belongs to
@@ -2914,7 +2917,10 @@
                          (resolve-existing-var env sym)
                          (resolve-var env sym))]
           (if-not (true? (:def-var env))
-            (assoc ret :op :var :info info)
+            (merge
+              (assoc ret :op :var :info info)
+              (when-let [const-init (:const-init info)]
+                {:const-expr (analyze env const-init)}))
             (let [info (resolve-var env sym)]
               (assoc ret :op :var :info info))))))))
 

src/main/clojure/cljs/compiler.cljc

@@ -330,24 +330,26 @@
 (defmethod emit* :no-op [m])
 
 (defmethod emit* :var
-  [{:keys [info env form] :as arg}]
-  (let [var-name (:name info)
-        info (if (= (namespace var-name) "js")
-               (let [js-module-name (get-in @env/*compiler* [:js-module-index (name var-name)])]
-                 (or js-module-name (name var-name)))
-               info)]
-    ; We need a way to write bindings out to source maps and javascript
-    ; without getting wrapped in an emit-wrap calls, otherwise we get
-    ; e.g. (function greet(return x, return y) {}).
-    (if (:binding-form? arg)
-      ; Emit the arg map so shadowing is properly handled when munging
-      ; (prevents duplicate fn-param-names)
-      (emits (munge arg))
-      (when-not (= :statement (:context env))
-        (emit-wrap env
-          (emits
-            (cond-> info
-              (not= form 'js/-Infinity) munge)))))))
+  [{:keys [info env form] :as ast}]
+  (if-let [const-expr (:const-expr ast)]
+    (emit const-expr)
+    (let [var-name (:name info)
+          info (if (= (namespace var-name) "js")
+                 (let [js-module-name (get-in @env/*compiler* [:js-module-index (name var-name)])]
+                   (or js-module-name (name var-name)))
+                 info)]
+      ; We need a way to write bindings out to source maps and javascript
+      ; without getting wrapped in an emit-wrap calls, otherwise we get
+      ; e.g. (function greet(return x, return y) {}).
+      (if (:binding-form? ast)
+        ; Emit the arg map so shadowing is properly handled when munging
+        ; (prevents duplicate fn-param-names)
+        (emits (munge ast))
+        (when-not (= :statement (:context env))
+          (emit-wrap env
+            (emits
+              (cond-> info
+                (not= form 'js/-Infinity) munge))))))))
 
 (defmethod emit* :var-special
   [{:keys [env var sym meta] :as arg}]