Fix #1001: regression of #987: interop with reserved JS keyword fails

Author: borkdude

src/sci/impl/analyzer.cljc

@@ -957,7 +957,7 @@
                           (subs method-name 1)
                           method-name)
               meth-name* meth-name
-              meth-name (munge meth-name)
+              meth-name (#?(:clj munge :cljs utils/munge-str) meth-name)
               stack (assoc (meta expr)
                            :ns @utils/current-ns
                            :file @utils/current-file)]

src/sci/impl/resolve.cljc

@@ -71,7 +71,7 @@
             [sym (if (and call? #?(:clj (not (str/starts-with? sym-name-str "."))))
                    (with-meta
                      [clazz #?(:clj sym-name
-                               :cljs (.split (str sym-name) "."))
+                               :cljs (.split (utils/munge-str (str sym-name)) "."))
                       sym-ns]
                      #?(:clj
                         (if (= "new" sym-name-str)
@@ -87,7 +87,8 @@
                       (let [stack (assoc (meta sym)
                                          :file @utils/current-file
                                          :ns @utils/current-ns)
-                            path (.split (str sym-name) ".")
+                            sym-name (utils/munge-str (str sym-name))
+                            path (.split sym-name ".")
                             len (alength path)]
                         (if (== 1 len)
                           (->Node
@@ -250,6 +251,7 @@
            #?(:cljs
               (when-let [[v segments] (resolve-prefix+path ctx sym m)]
                 (let [v (if (utils/var? v) (deref v) v)
+                      segments (mapv utils/munge-str segments)
                       segments (into-array segments)]
                   ;; NOTE: there is a reloading implication here...
                   (if call?

src/sci/impl/utils.cljc

@@ -2,10 +2,12 @@
   {:no-doc true}
   (:refer-clojure :exclude [eval demunge var? macroexpand macroexpand-1])
   (:require [clojure.string :as str]
+            #?(:cljs [goog.object :as gobject])
             [sci.impl.macros :as macros]
             [sci.impl.types :as t]
             [sci.impl.vars :as vars]
             [sci.lang :as lang])
+  #?(:cljs (:import [goog.string StringBuffer]))
   #?(:cljs (:require-macros [sci.impl.utils :refer [kw-identical? dotimes+]])))
 
 #?(:clj (set! *warn-on-reflection* true))
@@ -307,3 +309,16 @@
            '*unchecked-math* clojure.core/*unchecked-math*
            {:ns clojure-core-ns
             :doc "While bound to true, compilations of +, -, *, inc, dec and the\n  coercions will be done without overflow checks. While bound\n  to :warn-on-boxed, same behavior as true, and a warning is emitted\n  when compilation uses boxed math. Default: false."})))
+
+#?(:cljs
+   (defn ^string munge-str [name]
+     (let [sb (StringBuffer.)]
+       (loop [i 0]
+         (when (< i (. name -length))
+           (let [c (.charAt name i)
+                 sub (gobject/get CHAR_MAP c)]
+             (if-not (nil? sub)
+               (.append sb sub)
+               (.append sb c))
+             (recur (inc i)))))
+       (.toString sb))))

test/sci/interop_test.cljc

@@ -394,10 +394,19 @@
 ))
 
 #?(:cljs
-   (deftest issue-987-munged-property-name-test
+   (deftest issue-987-munged-method-or-property-name-test
      (is (= 1 (sci/eval-string "(def x #js {:foo_bar 1}) (.-foo-bar x)" {:classes {:allow :all}})))
      (is (= 1 (sci/eval-string "(def x #js {:foo_bar (fn [] 1)}) (.foo-bar x)" {:classes {:allow :all}})))
-     (is (= {:foo_bar 1} (sci/eval-string "(js->clj (doto #js {} (set! -foo-bar 1)) :keywordize-keys true)" {:classes {:allow :all}})))))
+     (testing "reserved keyword munging is bypassed"
+       (is (= 1 (sci/eval-string "(def x #js {:catch (fn [] 1)}) (.catch x)" {:classes {:allow :all}})))
+       (is (= 1 (sci/eval-string "d/foo-bar" {:imports {'d 'dude}
+                                              :classes {:allow :all 'dude #js {:foo_bar 1}}})))
+       (is (= 1 (sci/eval-string "(d/foo-bar)" {:imports {'d 'dude}
+                                                :classes {:allow :all 'dude #js {:foo_bar (fn [] 1)}}}))))
+     (is (= {:foo_bar 1} (sci/eval-string "(js->clj (doto #js {} (set! -foo-bar 1)) :keywordize-keys true)" {:classes {:allow :all}})))
+     (testing "dotted access"
+       (is (= 2 (sci/eval-string "(def x #js {:a 1 :foo_bar #js {:catch 2}}) x.foo-bar.catch" {:classes {'js goog/global}})))
+       (is (= 3 (sci/eval-string "(let [a #js {:foo_bar #js {:catch 3}}] a.foo-bar.catch)"))))))
 
 #?(:clj
    (deftest issue-987-deftype-munged-fields-test