Fix #651: allow :require + rename + renamed value in other clause (#652)

Author: borkdude

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 [Squint](https://github.com/squint-cljs/squint): Light-weight ClojureScript dialect
 
+## v0.8.145 (2024-04-11)
+
+- [#651](https://github.com/squint-cljs/squint/issues/651) Support `:require` + `:rename` + allow renamed value to be used in other :require clause
+
 ## v0.8.144 (2025-04-09)
 
 - Fix [#649](https://github.com/squint-cljs/squint/issues/649): reset ns when compiling file and fix initial global object

package.json

@@ -35,7 +35,7 @@
     "prettier": "^2.7.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "shadow-cljs": "^2.19.8",
+    "shadow-cljs": "^2.28.23",
     "squint-cljs": ".",
     "typescript": "^5.3.3"
   },

src/squint/compiler_common.cljc

@@ -300,19 +300,16 @@
                         (when (contains? current-ns expr)
                           (str (when *repl*
                                  (str "globalThis." (munge *cljs-ns*) ".")) (munged-name expr)))
-                        (let [renamed (:rename current-ns)
-                              expr (get renamed expr expr)]
-                          (or
-                           (when (contains? (:refers current-ns) expr)
-                             (str (when *repl*
-                                    (str "globalThis." (munge *cljs-ns*) "."))
-                                  (munged-name expr)))
-                           (some-> (maybe-core-var expr env) munge)
-                           (when (let [alias (get (:aliases current-ns) expr)]
-                                   alias)
-                             (str (when *repl*
-                                    (str "globalThis." (munge *cljs-ns*) "."))
-                                  (munged-name expr)))))
+                        (when (contains? (:refers current-ns) expr)
+                          (str (when *repl*
+                                 (str "globalThis." (munge *cljs-ns*) "."))
+                               (munged-name expr)))
+                        (some-> (maybe-core-var expr env) munge)
+                        (when (let [alias (get (:aliases current-ns) expr)]
+                                alias)
+                          (str (when *repl*
+                                 (str "globalThis." (munge *cljs-ns*) "."))
+                               (munged-name expr)))
                         (let [m (munged-name expr)]
                           m)))))]
         (emit-return (escape-jsx expr env)
@@ -544,21 +541,19 @@
                 (= 'cherry.core libname))
     (let [libname (resolve-ns env libname)
           [libname suffix] (str/split (if (string? libname) libname (str libname)) #"\$" 2)
-          [p & _props] (when suffix
-                         (str/split suffix #"\."))
-          default? (and as (= "default" p))
+          default? (= "default" suffix) ;; we only support a default suffix for now anyway
           as (when as (munge as))
           expr (str
-                (when (and as (= "default" p))
+                (when (and as default?)
                   (if *repl*
-                    (statement (format "const %s = (await import('%s')).default" as libname))
+                    (statement (format "const %s = (await import('%s')).%s" as libname suffix))
                     (statement (format "import %s from '%s'" as libname))))
-                (when (and (not as) (not p) (not refer))
+                (when (and (not as) (not suffix) (not refer))
                   ;; import presumably for side effects
                   (if *repl*
                     (statement (format "await import('%s')" libname))
                     (statement (format "import '%s'" libname))))
-                (when (and as (not= "default" p))
+                (when (and as (not default?))
                   (swap! *imported-vars* update libname (fnil identity #{}))
                   (statement (if *repl*
                                (format "var %s = await import('%s')" as libname)
@@ -569,27 +564,30 @@
                            (let [current (:current ns-state)]
                              (update-in ns-state [current :refers]
                                         (fn [refers]
-                                          (merge refers (zipmap refer (repeat libname))))))))
-                  (when rename
-                    (swap! (:ns-state env)
-                           (fn [ns-state]
-                             (let [current (:current ns-state)]
-                               (update-in ns-state [current :rename]
-                                          merge (zipmap (vals rename) (keys rename)))))))
-                  (let [munged-refers (map munge refer)]
+                                          (merge refers (zipmap (map (fn [refer]
+                                                                       (get rename refer refer)) refer) (repeat libname))))))))
+                  (let [referred+renamed (str/join ", "
+                                                   (map (fn [refer]
+                                                          (str (munge refer)
+                                                               (when-let [renamed (get rename refer)]
+                                                                 (str " as " (munge renamed)))))
+                                                        refer))]
                     (if *repl*
-                      (str (statement (format "var { %s } = (await import ('%s'))%s" (str/join ", " munged-refers) libname
-                                              (if default? ".default"
-                                                  "")))
+                      (str (statement (format "var { %s } = (await import ('%s'))%s" (str/replace referred+renamed " as " ": ") libname
+                                              (if suffix
+                                                (str "." suffix)
+                                                "")))
                            (str/join (map (fn [sym]
                                             (statement (str "globalThis." (munge current-ns-name) "." sym " = " sym)))
-                                          munged-refers)))
+                                          (map (fn [refer]
+                                                 (get rename refer refer))
+                                               refer))))
 
                       (if default?
                         (let [libname* ((:gensym env) "default")]
                           (str (statement (format "import %s from '%s'" libname* libname))
-                               (statement (format "const { %s } = %s" (str/join ", " (map munge refer)) libname*))))
-                        (statement (format "import { %s } from '%s'" (str/join ", " (map munge refer)) libname)))))))]
+                               (statement (format "const { %s } = %s" referred+renamed libname*))))
+                        (statement (format "import { %s } from '%s'" referred+renamed libname)))))))]
       (when as
         (swap! (:ns-state env)
                (fn [ns-state]

test/squint/compiler_test.cljs

@@ -1694,6 +1694,9 @@
   (is (jsv! '(not (some? nil))))
   (is (jsv! '(not (some? js/undefined)))))
 
+
+;;; begin ns / require related tests
+
 (deftest ns-test
   (is (str/includes? (squint/compile-string (pr-str '(ns foo (:require ["./popup.css" ]))))
                      "import './popup.css'"))
@@ -1706,6 +1709,28 @@
        (str/trim (squint/compile-string "(ns foo (:require [\"some-js-lib\" :refer [atom]])) atom" {:repl true}))
        "foo.atom;")))
 
+(deftest require-test
+  (let [s (squint/compile-string "(ns test-namespace (:require [\"some-js-library\" :refer [existsSync] :rename {existsSync exists}])) (exists \"README.md\")")]
+    (is (and
+         (str/includes? s "existsSync as exists")
+         (str/includes? s "exists(\"README.md\")"))))
+  (let [s (squint/compile-string "(ns test-namespace (:require [\"some-js-library\" :refer [existsSync] :rename {existsSync exists}])) (exists \"README.md\")"
+                                 {:repl true})]
+    (is (and
+         (str/includes? s "existsSync: exists")
+         (str/includes? s "globalThis.test_namespace.exists(\"README.md\")"))))
+  (testing "alias + refer"
+    (let [s (squint/compile-string "(ns foo (:require [\"node:fs\" :as \"fs\" :refer [existsSync]]))")]
+      (is (and
+           (str/includes? s "import * as fs from 'node:fs';")
+           (str/includes? s "import { existsSync } from 'node:fs'"))))
+    (let [s (squint/compile-string "(ns foo (:require [\"node:fs\" :as fs :refer [existsSync]]))"
+                                   {:repl true})]
+      (is (str/includes? s "var fs = await import('node:fs');
+var { existsSync } = (await import ('node:fs'));
+globalThis.foo.existsSync = existsSync;
+globalThis.foo.fs = fs;")))))
+
 (deftest default-require-test
   (let [js (squint/compile-string "(ns foo (:require [\"some-js-lib$default\" :as a :refer [atom]])) atom")]
     (is (str/includes? js "import default$1 from 'some-js-lib'"))
@@ -1732,20 +1757,6 @@
         (p/catch (fn [err] (is (throw err))))
         (p/finally done))))
 
-(deftest letfn-test
-  (is (= 3 (jsv! '(letfn [(f [x] (g x)) (g [x] (inc x))] (f 2)))))
-  (is (= 20 (jsv! '(do (defn foo [] (letfn [(g [x] (f x)) (f [x] (* 2 x))] (g 10))) (foo))))))
-
-(deftest refer-clojure-exclude-test
-  (is (= "yolo" (jsv! '(do (ns foo (:refer-clojure :exclude [assoc])) (defn assoc [m x y] :yolo) (assoc {} :foo :bar))))))
-
-(deftest double-names-in-sig-test
-  (is (= 2 (jsv! '(do (defn foo [x x] x) (foo 1 2))))))
-
-(deftest try-catch-test
-  (is (= 2 (jsv! '(try (assoc :foo 1 2) (catch :default _ 2)))))
-  (is (= 2 (jsv! '(try (assoc :foo 1 2) (catch :default _ 2))))))
-
 (deftest require-with-kebab-case-alias-test
   (let [s (squint/compile-string "(ns test-namespace (:require [\"some-js-library$default\" :as some-js-lib])) (some-js-lib/some_fn)")]
     (is (str/includes? s "import some_js_lib from 'some-js-library';"))
@@ -1765,9 +1776,23 @@
   (doseq [repl [false true]]
     (let [js (squint/compile-string "(require '[clojure.string :as str-ing]) (str-ing/join [1 2 3])" {:repl repl})]
       (is (not (str/includes? js "str-ing")))
-      (is (str/includes? js "str_ing"))))
-  (let [s (squint/compile-string "(ns test-namespace (:require [\"some-js-library\" :refer [existsSync] :rename {existsSync exists}])) (exists \"README.md\")")]
-    (is (str/includes? s "existsSync(\"README.md\")"))))
+      (is (str/includes? js "str_ing")))))
+
+;;; end ns / require related tests
+
+(deftest letfn-test
+  (is (= 3 (jsv! '(letfn [(f [x] (g x)) (g [x] (inc x))] (f 2)))))
+  (is (= 20 (jsv! '(do (defn foo [] (letfn [(g [x] (f x)) (f [x] (* 2 x))] (g 10))) (foo))))))
+
+(deftest refer-clojure-exclude-test
+  (is (= "yolo" (jsv! '(do (ns foo (:refer-clojure :exclude [assoc])) (defn assoc [m x y] :yolo) (assoc {} :foo :bar))))))
+
+(deftest double-names-in-sig-test
+  (is (= 2 (jsv! '(do (defn foo [x x] x) (foo 1 2))))))
+
+(deftest try-catch-test
+  (is (= 2 (jsv! '(try (assoc :foo 1 2) (catch :default _ 2)))))
+  (is (= 2 (jsv! '(try (assoc :foo 1 2) (catch :default _ 2))))))
 
 (deftest dissoc!-test
   (is (eq #js {"1" 2 "3" 4} (jsv! '(dissoc! {"1" 2 "3" 4}))))