CLJS-1719: Port destructuring namespaced keys and symbols

Author: anmonteiro

src/main/clojure/cljs/core.cljc

@@ -657,24 +657,40 @@
                                                         (if (:as b)
                                                           (conj ret (:as b) gmap)
                                                           ret))))
-                                             bes (reduce
-                                                  (core/fn [bes entry]
-                                                    (reduce #(assoc %1 %2 ((val entry) %2))
-                                                            (dissoc bes (key entry))
-                                                            ((key entry) bes)))
-                                                  (dissoc b :as :or)
-                                                  {:keys #(if (core/keyword? %) % (keyword (core/str %))),
-                                                   :strs core/str, :syms #(core/list `quote %)})]
+                                             bes (core/let [transforms
+                                                            (reduce
+                                                              (core/fn [transforms mk]
+                                                                (if (core/keyword? mk)
+                                                                  (core/let [mkns (namespace mk)
+                                                                        mkn (name mk)]
+                                                                    (core/cond (= mkn "keys") (assoc transforms mk #(keyword (core/or mkns (namespace %)) (name %)))
+                                                                               (= mkn "syms") (assoc transforms mk #(core/list `quote (symbol (core/or mkns (namespace %)) (name %))))
+                                                                               (= mkn "strs") (assoc transforms mk core/str)
+                                                                               :else transforms))
+                                                                  transforms))
+                                                              {}
+                                                              (keys b))]
+                                                   (reduce
+                                                     (core/fn [bes entry]
+                                                       (reduce #(assoc %1 %2 ((val entry) %2))
+                                                         (dissoc bes (key entry))
+                                                         ((key entry) bes)))
+                                                     (dissoc b :as :or)
+                                                     transforms))]
                                    (if (seq bes)
                                      (core/let [bb (key (first bes))
                                                 bk (val (first bes))
-                                                bv (if (contains? defaults bb)
-                                                     (core/list 'cljs.core/get gmap bk (defaults bb))
+                                                local (if #?(:clj  (core/instance? clojure.lang.Named bb)
+                                                             :cljs (cljs.core/implements? INamed bb))
+                                                          (symbol nil (name bb))
+                                                        bb)
+                                                bv (if (contains? defaults local)
+                                                     (core/list 'cljs.core/get gmap bk (defaults local))
                                                      (core/list 'cljs.core/get gmap bk))]
-                                       (recur (core/cond
-                                                (core/symbol? bb) (core/-> ret (conj (if (namespace bb) (symbol (name bb)) bb)) (conj bv))
-                                                (core/keyword? bb) (core/-> ret (conj (symbol (name bb)) bv))
-                                                :else (pb ret bb bv))
+                                       (recur
+                                         (if (core/or (core/keyword? bb) (core/symbol? bb)) ;(ident? bb)
+                                           (core/-> ret (conj local bv))
+                                           (pb ret bb bv))
                                               (next bes)))
                                      ret))))]
                     (core/cond

src/test/cljs/cljs/core_test.cljs

@@ -989,6 +989,43 @@
           (is (= y 2))))
       )))
 
+(deftest keywords-in-destructuring
+  (let [m {:a 1 :b 2}]
+    (let [{:keys [:a :b]} m]
+      (is (= [1 2] [a b])))
+    (let [{:keys [:a :b :c] :or {c 3}} m]
+      (is (= [1 2 3] [a b c])))))
+
+(deftest namespaced-keywords-in-destructuring
+  (let [m {:a/b 1 :c/d 2}]
+    (let [{:keys [:a/b :c/d]} m]
+      (is (= [1 2] [b d])))
+    (let [{:keys [:a/b :c/d :e/f] :or {f 3}} m]
+      (is (= [1 2 3] [b d f])))))
+
+(deftest namespaced-keys-in-destructuring
+  (let [m {:a/b 1 :c/d 2}]
+    (let [{:keys [a/b c/d]} m]
+      (is (= [1 2] [b d])))
+    (let [{:keys [a/b c/d e/f] :or {f 3}} m]
+      (is (= [1 2 3] [b d f])))))
+
+(deftest namespaced-syms-in-destructuring
+  (let [{:syms [a/b c/d e/f] :or {f 3}} {'a/b 1 'c/d 2}]
+    (is (= [1 2 3] [b d f]))))
+
+(deftest namespaced-keys-syntax
+  (let [{:a/keys [b c d] :or {d 3}} {:a/b 1 :a/c 2}]
+    (is (= [1 2 3] [b c d]))))
+
+(deftest namespaced-syms-syntax
+  (let [{:a/syms [b c d] :or {d 3}} {'a/b 1 'a/c 2}]
+    (is (= [1 2 3] [b c d]))))
+
+(deftest resolve-keyword-ns-alias-in-destructuring
+  (let [{:keys [::s/x ::s/y ::s/z] :or {z 3}} {:clojure.string/x 1 :clojure.string/y 2}]
+    (is (= [1 2 3] [x y z]))))
+
 (deftest test-in-operations
   (testing "Testing update-in"
     (is (= {:foo {:bar {:baz 1}}}

src/test/clojure/cljs/compiler_tests.clj

@@ -102,6 +102,21 @@
 (defmacro capture-warnings [& body]
   `(capture-warnings* (fn [] ~@body)))
 
+(deftest or-doesnt-create-bindings
+  (let [cenv (atom @cenv)]
+    (binding [ana/*cljs-static-fns* true
+              ana/*analyze-deps* false]
+      (env/with-compiler-env cenv
+        (ana/analyze-file (File. "src/main/cljs/cljs/core.cljs"))
+        (let [warnings (-> (capture-warnings
+                             (with-out-str
+                               (comp/emit
+                                 (ana/analyze aenv
+                                   '(let [{:keys [a] :or {b 2}} {:a 1}] [a b]))))))]
+          (is (= (ffirst warnings) :undeclared-var))
+          (is (.startsWith (-> warnings first second)
+                "WARNING: Use of undeclared Var cljs.user/b")))))))
+
 (deftest no-warn-on-emit-invoke-protocol-method
   (let [define-foo #(assoc-in % [::ana/namespaces 'cljs.user :defs 'foo]
                               {:ns 'cljs.user