CLJS-937: local fn name should be lexically munged

Introduce :fn-scope vector to analysis environment. If a function is
supplied with a local name extend :fn-scope in env by conj'ing
the local name var.

Introduce `cljs.compiler/fn-self-name` munging case. Use
:fn-scope to construct the name. The returned symbol starts with
munged namespace, separated from scope name by "_SLASH_".
fn scope names are separated by "_$_". Simplifies fn name demunging
when source mapping stack traces.

Invoke optimizations rewrite the fn :name to a direct string.
Disable :fn-self-name munging in these cases.

Respect :static-fns false even if compiling core.

Remove bogus analyzer tests for local name.

Add better compiler tests for local name.

Author: swannodette

src/clj/cljs/analyzer.clj

@@ -290,6 +290,7 @@
     {:ns (get-namespace *cljs-ns*)
      :context :statement
      :locals {}
+     :fn-scope []
      :js-globals (into {}
                    (map #(vector % {:name %})
                      '(alert window document console escape unescape
@@ -844,12 +845,17 @@
          locals (:locals env)
          name-var (if name
                     (merge
-                     {:name name
-                      :info {:shadow (or (locals name)
-                                         (get-in env [:js-globals name]))}}
+                      {:name name
+                       :info {:fn-self-name true
+                              :fn-scope (:fn-scope env)
+                              :ns (-> env :ns :name)
+                              :shadow (or (locals name)
+                                          (get-in env [:js-globals name]))}}
                      (when-let [tag (-> name meta :tag)]
                        {:ret-tag tag})))
-         env (update-in env [:fn-scope] (fnil conj []) name-var)
+         env (if name
+               (update-in env [:fn-scope] conj name-var)
+               env)
          locals (if (and locals name) (assoc locals name name-var) locals)
          type (-> form meta ::type)
          protocol-impl (-> form meta ::protocol-impl)

src/clj/cljs/compiler.clj

@@ -55,29 +55,45 @@
        (some #{(str name)} (ns-first-segments)) (inc d)
        :else d))))
 
+(declare munge)
+
+(defn fn-self-name [{:keys [name info] :as name-var}]
+  (let [{:keys [ns fn-scope]} info
+        scoped-name (apply str
+                      (interpose "_$_"
+                        (concat (map (comp str :name) fn-scope) [name])))]
+    (symbol
+      (munge
+        (str (string/replace (str ns) "." "$")
+          "_SLASH_" scoped-name)))))
+
 (defn munge
   ([s] (munge s js-reserved))
   ([s reserved]
-    (if (map? s)
-      ; Unshadowing
-      (let [{:keys [name field] :as info} s
-            depth (shadow-depth s)
-            renamed (*lexical-renames* (System/identityHashCode s))
-            munged-name (munge (cond field (str "self__." name)
-                                     renamed renamed
-                                     :else name)
-                               reserved)]
-        (if (or field (zero? depth))
-          munged-name
-          (symbol (str munged-name "__$" depth))))
-      ; String munging
-      (let [ss (string/replace (str s) #"\/(.)" ".$1") ; Division is special
-            ss (apply str (map #(if (reserved %) (str % "$") %)
-                               (string/split ss #"(?<=\.)|(?=\.)")))
-            ms (clojure.lang.Compiler/munge ss)]
-        (if (symbol? s)
-          (symbol ms)
-          ms)))))
+   (if (map? s)
+     (let [{:keys [name field info] :as name-var} s]
+       (if (:fn-self-name info)
+         (fn-self-name s)
+         ;; Unshadowing
+         (let [depth (shadow-depth s)
+               renamed (*lexical-renames* (System/identityHashCode s))
+               munged-name (munge
+                             (cond field (str "self__." name)
+                                   renamed renamed
+                                   :else name)
+                             reserved)]
+           (if (or field (zero? depth))
+             munged-name
+             (symbol (str munged-name "__$" depth))))))
+     ;; String munging
+     (let [ss (string/replace (str s) #"\/(.)" ".$1") ; Division is special
+           ss (apply str
+                (map #(if (reserved %) (str % "$") %)
+                  (string/split ss #"(?<=\.)|(?=\.)")))
+           ms (clojure.lang.Compiler/munge ss)]
+       (if (symbol? s)
+         (symbol ms)
+         ms)))))
 
 (defn- comma-sep [xs]
   (interpose "," xs))
@@ -772,16 +788,24 @@
 
              ;; direct dispatch to variadic case
              (and variadic? (> arity mfa))
-             [(update-in f [:info :name]
-                             (fn [name] (symbol (str (munge info) ".cljs$core$IFn$_invoke$arity$variadic"))))
+             [(update-in f [:info]
+                (fn [info]
+                  (-> info
+                    (assoc :name (symbol (str (munge info) ".cljs$core$IFn$_invoke$arity$variadic")))
+                    ;; bypass local fn-self-name munging, we're emitting direct
+                    (update-in [:info] dissoc :fn-self-name))))
               {:max-fixed-arity mfa}]
 
              ;; direct dispatch to specific arity case
              :else
              (let [arities (map count mps)]
                (if (some #{arity} arities)
-                 [(update-in f [:info :name]
-                             (fn [name] (symbol (str (munge info) ".cljs$core$IFn$_invoke$arity$" arity)))) nil]
+                 [(update-in f [:info]
+                    (fn [info]
+                      (-> info
+                        (assoc :name (symbol (str (munge info) ".cljs$core$IFn$_invoke$arity$" arity)))
+                        ;; bypass local fn-self-name munging, we're emitting direct
+                        (update-in [:info] dissoc :fn-self-name)))) nil]
                  [f nil]))))
           [f nil])]
     (emit-wrap env
@@ -808,6 +832,7 @@
 
        :else
        (if (and ana/*cljs-static-fns* (= (:op f) :var))
+         ;; higher order case, static information missing
          (let [fprop (str ".cljs$core$IFn$_invoke$arity$" (count args))]
            (emits "(" f fprop " ? " f fprop "(" (comma-sep args) ") : " f ".call(" (comma-sep (cons "null" args)) "))"))
          (emits f ".call(" (comma-sep (cons "null" args)) ")"))))))
@@ -1072,7 +1097,10 @@
         (if (.exists src-file)
           (try
             (let [{ns :ns :as ns-info} (ana/parse-ns src-file dest-file opts)
-                  opts (if (= ns 'cljs.core) (assoc opts :static-fns true) opts)]
+                  opts (if (and (= ns 'cljs.core)
+                                (not (false? (:static-fns opts))))
+                         (assoc opts :static-fns true)
+                         opts)]
               (if (requires-compilation? src-file dest-file opts)
                 (do
                   (util/mkdirs dest-file)

test/clj/cljs/analyzer_tests.clj

@@ -33,7 +33,7 @@
 ;; =============================================================================
 ;; NS parsing
 
-(def ns-env (assoc-in (a/empty-env) [:ns [:name]] 'cljs.user))
+(def ns-env (assoc-in (a/empty-env) [:ns :name] 'cljs.user))
 
 (deftest spec-validation
   (is (.startsWith
@@ -324,20 +324,3 @@
     ;; actual: (not (= #{file-reloading dev client} #{file-reloading dev client core}))
     (is (= (set (a/ns-dependents 'utils))
            #{'file-reloading 'dev 'client 'core}))))
-
-;; =============================================================================
-;; Namespace metadata
-
-(deftest test-fn-scope
-  (is (= (get-in
-           (a/analyze ns-env
-             '(fn foo []
-                (fn bar [])))
-           [:children 0 :children 0 :env :fn-scope])
-         '[{:name foo, :info {:shadow nil}} {:name bar, :info {:shadow nil}}]))
-  (is (= (get-in
-           (a/analyze ns-env
-             '(defn foo []
-                (fn bar [])))
-           [:init :children 0 :children 0 :env :fn-scope])
-        '[{:name foo, :info {:shadow nil}} {:name bar, :info {:shadow nil}}])))

test/clj/cljs/compiler_tests.clj

@@ -1,10 +1,14 @@
 (ns cljs.compiler-tests
   (:use clojure.test)
+  (:require [cljs.analyzer :as a])
   (:require [cljs.compiler :as c])
   (:require [cljs.env :as e])
-  (:require [cljs.util :as util])
+  (:require [cljs.util :as util]
+            [cljs.compiler :as comp])
   (:import (java.io File)))
 
+(def ns-env (assoc-in (a/empty-env) [:ns :name] 'cljs.user))
+
 (deftest should-recompile
   (let [src (File. "test/hello.cljs")
         dst (File/createTempFile "compilertest" ".cljs")
@@ -20,3 +24,34 @@
         (c/compile-file src dst optmod)
         (is (not (c/requires-compilation? src dst optmod)))))))
 
+(deftest fn-scope-munge
+  (is (= (c/munge
+           (get-in
+             (a/analyze ns-env
+               '(defn foo []
+                  (fn bar [])))
+             [:init :name]))
+         'cljs$user_SLASH_foo))
+  (is (= (c/munge
+           (get-in
+             (a/analyze ns-env
+               '(defn foo []
+                  (fn bar [])))
+             [:init :children 0 :children 0 :name]))
+          'cljs$user_SLASH_foo_$_bar))
+  (is (= (c/munge
+           (get-in
+             (a/analyze ns-env
+               '(fn []
+                  (fn console [])))
+             [:children 0 :children 0 :name]))
+         'cljs$user_SLASH_console)))
+
+(comment
+  (c/munge
+    (get-in
+      (a/analyze ns-env
+        '(defn foo []
+           (fn bar [])))
+      [:init :children 0 :children 0 :name]))
+  )