loop/recur lands with its corpus lines: a block, a br, and a stack swap

0022 D's shape verbatim: loop is locals set before a (loop ...) label,
recur a br back to it. Rebinding is simultaneous — every recur argument
is evaluated onto the value stack under the current bindings, then
popped into the loop locals in reverse; the loop-recur-simultaneous
entry exists to fail if that ever becomes a sequential local.set.
Nested loops get distinct labels and the inner recur binds to the inner
loop (loop-nested). fn-recur stays out of the slice and says so.

Claude-Session: https://claude.ai/code/session_01XF5Hfq4Ca2N2XYEzWQQuHt

Author: chaploud

corpus/s3.edn

@@ -27,6 +27,21 @@
  {:id "if-false"        :forms [(if false 1 2)]}
  {:id "if-zero-truthy"  :forms [(if 0 1 2)]}
  {:id "if-untaken-arm"  :forms [(if true 3 (quot 1 0))]}
+ {:id "loop-countdown"  :forms [(loop [i 10 acc 0]
+                                  (if (< 0 i) (recur (- i 1) (+ acc i)) acc))]}
+ {:id "loop-fib-iter"   :forms [(loop [n 10 a 0 b 1]
+                                  (if (< 0 n) (recur (- n 1) b (+ a b)) a))]}
+ ;; recur rebinds simultaneously: a sequential-assignment bug makes the
+ ;; swap collapse (a=b, then b=that same value) and this entry catch it.
+ {:id "loop-recur-simultaneous"
+  :forms [(loop [a 1 b 2 n 3]
+            (if (< 0 n) (recur b a (- n 1)) (- (* a 10) b)))]}
+ {:id "loop-nested"     :forms [(loop [i 3 total 0]
+                                  (if (< 0 i)
+                                    (recur (- i 1)
+                                           (+ total (loop [j i s 0]
+                                                      (if (< 0 j) (recur (- j 1) (+ s j)) s))))
+                                    total))]}
  {:id "let-shadow"      :forms [(let [x 1] (let [x (+ x 1)] (* x 10)))]}
  {:id "let-sequential"  :forms [(let [x 2 y (+ x 3)] (* x y))]}
  {:id "top-level-forms" :forms [(+ 1 1) (+ 2 2)]}

src/cljwit/emit.clj

@@ -40,6 +40,37 @@
     :nil    "(ref.null eq)"
     (out-of-slice! (str "literal of type " type) ast)))
 
+(defn- emit-loop
+  "`0022` D: a block and a br. The loop's locals are set before entry;
+   `recur` re-enters via `br` to the loop label."
+  [ctx {:keys [bindings body loop-id]}]
+  (let [[ctx' sets]
+        (reduce (fn [[c acc] {:keys [name init]}]
+                  (let [wl (fresh-local! c)]
+                    [(assoc-in c [:locals name] wl)
+                     (conj acc (format "(local.set %s %s)" wl (emit-expr c init)))]))
+                [ctx []] bindings)
+        label (str "$loop" (swap! (:counter ctx) inc))
+        ctx'' (assoc-in ctx' [:loops loop-id]
+                        {:label label
+                         :locals (mapv #(get-in ctx' [:locals (:name %)]) bindings)})]
+    (format "(block (result (ref null eq)) %s (loop %s (result (ref null eq)) %s))"
+            (str/join " " sets) label (emit-expr ctx'' body))))
+
+(defn- emit-recur
+  "Rebinding is simultaneous: every argument is evaluated onto the value
+   stack under the *current* bindings, then popped into the loop locals in
+   reverse — a sequential `local.set` would let later arguments observe
+   earlier rebinds."
+  [ctx {:keys [exprs loop-id] :as ast}]
+  (let [{:keys [label locals]} (get-in ctx [:loops loop-id])]
+    (when-not label
+      (out-of-slice! "recur outside an enclosing loop (fn recur is a later unit)" ast))
+    (format "(block (result (ref null eq)) %s %s (br %s))"
+            (str/join " " (map #(emit-expr ctx %) exprs))
+            (str/join " " (map #(format "(local.set %s)" %) (reverse locals)))
+            label)))
+
 (defn- emit-let [ctx {:keys [bindings body]}]
   (let [[ctx' sets]
         (reduce (fn [[c acc] {:keys [name init]}]
@@ -100,6 +131,8 @@
                     (emit-expr ctx (:then ast))
                     (emit-expr ctx (:else ast)))
     :let    (emit-let ctx ast)
+    :loop   (emit-loop ctx ast)
+    :recur  (emit-recur ctx ast)
     :local  (if-let [wl (get-in ctx [:locals (:name ast)])]
               (format "(local.get %s)" wl)
               (out-of-slice! (str "unresolved local " (:name ast)) ast))