wip

Author: borkdude

src/sci/impl/async_macro.cljc

@@ -92,12 +92,12 @@
             (if (seq acc)
               ;; Have accumulated expressions before promise - mark the do as promise-producing
               (let [then-expr (if rest-body
-                                (promise-then transformed (list 'fn ['_] rest-body))
+                                (promise-then transformed (list 'fn* ['_] rest-body))
                                 transformed)]
                 (mark-promise (list* 'do (conj acc then-expr))))
               ;; No accumulated expressions
               (if rest-body
-                (promise-then transformed (list 'fn ['_] rest-body))
+                (promise-then transformed (list 'fn* ['_] rest-body))
                 transformed)))
           ;; No promise, accumulate
           (recur rest-exprs (conj acc transformed))))
@@ -150,7 +150,7 @@
                         transformed-body
                         (wrap-promise transformed-body))
         ;; Build the loop function
-        loop-fn (list 'fn loop-fn-name param-names promised-body)
+        loop-fn (list 'fn* loop-fn-name param-names promised-body)
         ;; Immediately invoke with initial values
         loop-call (apply list loop-fn init-values)]
     ;; Wrap in js/Promise.resolve so it's recognized as promise-producing
@@ -175,9 +175,9 @@
             (if (seq acc-bindings)
               (list 'let* (vec acc-bindings)
                     (promise-then transformed-init
-                                  (list 'fn [binding-name] rest-body)))
+                                  (list 'fn* [binding-name] rest-body)))
               (promise-then transformed-init
-                            (list 'fn [binding-name] rest-body))))
+                            (list 'fn* [binding-name] rest-body))))
           ;; No await in this binding - accumulate and continue
           (recur (rest pairs)
                  (conj acc-bindings binding-name transformed-init)
@@ -213,25 +213,25 @@
                         (wrap-promise transformed-body))
         ;; Add .catch clauses
         with-catch (reduce
-                       (fn [chain catch-clause]
-                         ;; (catch Type e handler-body...)
-                         (let [[_ _type binding & handler-body] catch-clause
-                               ;; Add catch binding to locals for handler
-                               handler-locals (conj locals binding)
-                               transformed-handler (if (= 1 (count handler-body))
-                                                     (transform-async-body ctx handler-locals (first handler-body))
-                                                     (transform-do ctx handler-locals handler-body))]
-                           (promise-catch chain (list 'fn [binding] transformed-handler))))
-                       promise-chain
-                       catch-clauses)
-          ;; Add .finally if present
-          with-finally (if finally-clause
-                         (let [[_ & finally-body] finally-clause
-                               transformed-finally (if (= 1 (count finally-body))
-                                                     (transform-async-body ctx locals (first finally-body))
-                                                     (transform-do ctx locals finally-body))]
-                           (promise-finally with-catch (list 'fn [] transformed-finally)))
-                         with-catch)]
+                    (fn [chain catch-clause]
+                      ;; (catch Type e handler-body...)
+                      (let [[_ _type binding & handler-body] catch-clause
+                            ;; Add catch binding to locals for handler
+                            handler-locals (conj locals binding)
+                            transformed-handler (if (= 1 (count handler-body))
+                                                  (transform-async-body ctx handler-locals (first handler-body))
+                                                  (transform-do ctx handler-locals handler-body))]
+                        (promise-catch chain (list 'fn* [binding] transformed-handler))))
+                    promise-chain
+                    catch-clauses)
+        ;; Add .finally if present
+        with-finally (if finally-clause
+                       (let [[_ & finally-body] finally-clause
+                             transformed-finally (if (= 1 (count finally-body))
+                                                   (transform-async-body ctx locals (first finally-body))
+                                                   (transform-do ctx locals finally-body))]
+                         (promise-finally with-catch (list 'fn* [] transformed-finally)))
+                       with-catch)]
     with-finally))
 
 (defn- transform-coll-with-await
@@ -240,23 +240,24 @@
   [ctx locals elements rebuild-fn]
   (let [transformed (doall (map #(transform-async-body ctx locals %) elements))]
     (if (some promise-form? transformed)
-      ;; Chain promises sequentially
-      (loop [elems-before []
-             remaining transformed]
-        (if (seq remaining)
-          (let [elem (first remaining)]
-            (if (promise-form? elem)
-              ;; Found promise - chain from here
-              (let [await-sym (gensym "await__")
-                    rest-elems (rest remaining)
-                    rebuilt (rebuild-fn (concat elems-before [await-sym] rest-elems))
-                    ;; Recursively transform in case there are more promises
-                    rest-expr (transform-async-body ctx (conj locals await-sym) rebuilt)]
-                (promise-then elem (list 'fn [await-sym] rest-expr)))
-              ;; Not a promise, accumulate
-              (recur (conj elems-before elem) (rest remaining))))
-          ;; Shouldn't reach here
-          (rebuild-fn transformed)))
+      ;; Chain promises sequentially - don't re-transform already transformed elements
+      (letfn [(chain-remaining [elems-before remaining]
+                (if (seq remaining)
+                  (let [elem (first remaining)]
+                    (if (promise-form? elem)
+                      ;; Found promise - chain from here
+                      (let [await-sym (gensym "await__")
+                            rest-transformed (rest remaining)
+                            ;; Recursively chain the rest WITHOUT re-transforming
+                            rest-expr (chain-remaining (conj elems-before await-sym)
+                                                       rest-transformed)]
+                        (promise-then elem (list 'fn* [await-sym] rest-expr)))
+                      ;; Not a promise, accumulate
+                      (chain-remaining (conj elems-before elem)
+                                       (rest remaining))))
+                  ;; No more elements - rebuild collection
+                  (rebuild-fn elems-before)))]
+        (chain-remaining [] transformed))
       ;; No promises
       (rebuild-fn transformed))))
 
@@ -281,7 +282,7 @@
                       rebuilt (apply list op (concat args-before [await-sym] rest-args))
                       ;; Recursively transform in case there are more promises
                       rest-expr (transform-async-body ctx (conj locals await-sym) rebuilt)]
-                  (promise-then arg (list 'fn [await-sym] rest-expr)))
+                  (promise-then arg (list 'fn* [await-sym] rest-expr)))
                 ;; Not a promise, accumulate
                 (recur (conj args-before arg)
                        (rest remaining-args))))
@@ -302,7 +303,7 @@
         expanded (if (and (seq? body)
                           (symbol? op)
                           (not (contains? locals op))  ;; Don't expand if locally bound
-                          (not (#{'await 'let* 'loop* 'do 'fn 'fn* 'if 'quote 'try 'case*
+                          (not (#{'await 'let* 'loop* 'do 'fn* 'if 'quote 'try 'case*
                                   'sci.impl.async-await/promise} op)))
                    (macroexpand/macroexpand-1 ctx body)
                    body)]
@@ -355,7 +356,7 @@
             (if (promise-form? transformed-test)
               (let [test-binding (gensym "case_test__")]
                 (promise-then transformed-test
-                              (list 'fn [test-binding]
+                              (list 'fn* [test-binding]
                                     (apply list case*-sym test-binding all-transformed))))
               rebuilt-case))
 
@@ -377,27 +378,30 @@
             (if (promise-form? transformed-test)
               (let [test-binding (gensym "test__")]
                 (promise-then transformed-test
-                              (list 'fn [test-binding]
+                              (list 'fn* [test-binding]
                                     (if transformed-else
                                       (list 'if test-binding transformed-then transformed-else)
                                       (list 'if test-binding transformed-then)))))
               (if transformed-else
                 (list 'if transformed-test transformed-then transformed-else)
                 (list 'if transformed-test transformed-then))))
 
-          ;; fn/fn* - don't recurse into (handled by analyzer)
-          (fn fn*)
-          body
+          ;; fn* - don't recurse into (handled by analyzer)
+          fn* body
 
           ;; General expression - transform subforms
           (transform-expr-with-await ctx locals body))
-        ;; Not a seq - check for vector or map
+        ;; Not a seq - check for vector, set, or map
         (cond
           ;; Vector literal - transform elements
           (vector? body)
           (transform-coll-with-await ctx locals body vec)
 
-          ;; Map literal - transform values (keys and values as pairs)
+          ;; Set literal - transform elements
+          (set? body)
+          (transform-coll-with-await ctx locals body set)
+
+          ;; Map literal - transform keys and values as pairs
           (map? body)
           (transform-coll-with-await ctx locals
                                      (mapcat identity body)  ;; flatten to [k1 v1 k2 v2 ...]

test/sci/async_await_test.cljs

@@ -444,6 +444,52 @@
                           (is false (str err))))
                (p/finally done)))))
 
+(deftest async-fn-vector-literal-await-test
+  (testing "^:async fn with await inside vector literal"
+    (async done
+           (-> (p/let [ctx (sci/init {:classes {'js js/globalThis :allow :all}})
+                       v (sci/eval-string* ctx
+                           "(defn ^:async foo []
+                              [(await (js/Promise.resolve 1))
+                               (await (js/Promise.resolve 2))
+                               (+ 1 (await (js/Promise.resolve 2)))])
+                            (foo)")]
+                 (p/let [result v]
+                   (is (= [1 2 3] result))))
+               (p/catch (fn [err]
+                          (is false (str err))))
+               (p/finally done)))))
+
+(deftest async-fn-set-literal-await-test
+  (testing "^:async fn with await inside set literal"
+    (async done
+           (-> (p/let [ctx (sci/init {:classes {'js js/globalThis :allow :all}})
+                       v (sci/eval-string* ctx
+                           "(defn ^:async foo []
+                              #{(await (js/Promise.resolve 1))
+                                (await (js/Promise.resolve 2))})
+                            (foo)")]
+                 (p/let [result v]
+                   (is (= #{1 2} result))))
+               (p/catch (fn [err]
+                          (is false (str err))))
+               (p/finally done)))))
+
+(deftest async-fn-map-literal-await-test
+  (testing "^:async fn with await inside map literal"
+    (async done
+           (-> (p/let [ctx (sci/init {:classes {'js js/globalThis :allow :all}})
+                       v (sci/eval-string* ctx
+                           "(defn ^:async foo []
+                              {(await (js/Promise.resolve :a)) (await (js/Promise.resolve 1))
+                               :b (await (js/Promise.resolve 2))})
+                            (foo)")]
+                 (p/let [result v]
+                   (is (= {:a 1 :b 2} result))))
+               (p/catch (fn [err]
+                          (is false (str err))))
+               (p/finally done)))))
+
 (deftest async-fn-integration-test
   (testing "^:async fn integration test with multiple features combined"
     (async done
@@ -508,18 +554,24 @@
                                              :nested-result)))]
                                     ;; for comprehension with await
                                     p [(vec (for [x (await (js/Promise.resolve [1 2]))]
-                                              (* x 2)))]]
+                                              (* x 2)))]
+                                    ;; set literal with await
+                                    q [#{(await (js/Promise.resolve :x))
+                                         (await (js/Promise.resolve :y))}]
+                                    ;; map literal with await in keys and values
+                                    r [{(await (js/Promise.resolve :key)) (await (js/Promise.resolve :val))}]]
                                 {:a a :b b :c c :d d :e e :f f :g g :h h :i i :j j :k k
                                  :l l :l-side-effects l-side-effects
                                  :m m :m-side-effects m-side-effects
-                                 :n n :o o :p p}))
+                                 :n n :o o :p p :q q :r r}))
                             (test-complex)")]
                  (p/let [result v]
                    (is (= {:a [1] :b [7] :c [17] :d [3] :e [42] :f [:matched-x] :g [10] :h [11] :i [101]
                            :j [:found] :k [3]
                            :l [false] :l-side-effects [0]
                            :m [:truthy] :m-side-effects [0]
-                           :n [9] :o [:nested-result] :p [[2 4]]} result))))
+                           :n [9] :o [:nested-result] :p [[2 4]]
+                           :q [#{:x :y}] :r [{:key :val}]} result))))
                (p/catch (fn [err]
                           (is false (str err))))
                (p/finally done)))))