CLJS-1536: REPL def symbol init collision

Author: anmonteiro

src/main/clojure/cljs/analyzer.cljc

@@ -1022,7 +1022,10 @@
 
 (defn- var-ast
   [env sym]
-  (let [var (resolve-var env sym (confirm-var-exists-throw))
+  ;; we need to dissoc locals for the `(let [x 1] (def x x))` case, because we
+  ;; want the var's AST and `resolve-var` will check locals first. - António Monteiro
+  (let [env (dissoc env :locals)
+        var (resolve-var env sym (confirm-var-exists-throw))
         expr-env (assoc env :context :expr)]
     (if-let [var-ns (:ns var)]
       {:var (analyze expr-env sym)
@@ -1384,9 +1387,10 @@
 
 (defmethod parse 'fn*
   [op env [_ & args :as form] name _]
-  (let [[name meths] (if (symbol? (first args))
-                       [(first args) (next args)]
-                       [name (seq args)])
+  (let [named-fn?    (symbol? (first args))
+        [name meths] (if named-fn?
+                         [(first args) (next args)]
+                         [name (seq args)])
         ;; turn (fn [] ...) into (fn ([]...))
         meths        (if (vector? (first meths))
                        (list meths)
@@ -1397,7 +1401,7 @@
                        (update-in env [:fn-scope] conj name-var)
                        env)
         locals       (if (and (not (nil? locals))
-                              (not (nil? name)))
+                              named-fn?)
                        (assoc locals name name-var)
                        locals)
         form-meta    (meta form)
@@ -1413,7 +1417,7 @@
         methods      (map #(disallowing-ns* (analyze-fn-method menv locals % type)) meths)
         mfa          (apply max (map :max-fixed-arity methods))
         variadic     (boolean (some :variadic methods))
-        locals       (if-not (nil? name)
+        locals       (if named-fn?
                        (update-in locals [name] assoc
                          ;; TODO: can we simplify? - David
                          :fn-var true

src/main/clojure/cljs/compiler.cljc

@@ -609,9 +609,9 @@
   (when (or init (:def-emits-var env))
     (let [mname (munge name)]
      (emit-comment env doc (concat jsdoc (:jsdoc init)))
-     (when (:def-emits-var env)
-       (when (= :return (:context env))
+     (when (= :return (:context env))
          (emitln "return ("))
+     (when (:def-emits-var env)
        (emitln "(function (){"))
      (emits var)
      (when init
@@ -625,9 +625,9 @@
                 {:op  :var-special
                  :env (assoc env :context :expr)}
                 var-ast))
-       (emitln ");})()")
-       (when (= :return (:context env))
-         (emitln ")")))
+       (emitln ");})()"))
+     (when (= :return (:context env))
+         (emitln ")"))
      ;; NOTE: JavaScriptCore does not like this under advanced compilation
      ;; this change was primarily for REPL interactions - David
      ;(emits " = (typeof " mname " != 'undefined') ? " mname " : undefined")

src/test/cljs/cljs/core_test.cljs

@@ -1135,6 +1135,20 @@
   (is (= (nth "012"  3 :not-found) :not-found))
   (is (= (nth "012" -1 :not-found) :not-found)))
 
+(let [foo-1536 2]
+  (def foo-1536 foo-1536))
+
+(let [foo-1536-2 1]
+  (defn foo-1536-2 []
+    foo-1536-2))
+
+(deftest test-cljs-1536
+  (is (= foo-1536 2))
+  (is (= (foo-1536-2) 1))
+  ;; these two lines generate a `:redef-in-file` warning, which is caused by `cljs.test/is`
+  (is (= ((let [z 1] (defn z [] z))) 1))
+  (is (= (let [w 1] ((defn w [] w))) 1)))
+
 (comment
   ;; ObjMap
   ;; (let [ks (map (partial str "foo") (range 500))

src/test/clojure/cljs/analyzer_tests.clj

@@ -591,3 +591,13 @@
           nsb (str (a/gen-user-ns b))]
       (is (not= (.substring nsa (- (count nsa) 7)) (.substring nsb (- (count nsb) 7))))
       (is (= (.substring nsa 0 (- (count nsa) 7)) (.substring nsb 0 (- (count nsb) 7)))))))
+
+(deftest test-cljs-1536
+  (let [parsed (e/with-compiler-env test-cenv
+                 (a/analyze (assoc test-env :def-emits-var true)
+                   '(def x 1)))]
+    (is (some? (:var-ast parsed))))
+  (let [parsed (e/with-compiler-env test-cenv
+                 (a/analyze (assoc test-env :def-emits-var true)
+                   '(let [y 1] (def y 2))))]
+    (is (some? (-> parsed :expr :ret :var-ast)))))