41.5: Fix try/catch peephole bug + sorted collection support

- Fix peephole optimizer not remapping try_begin jump offset, causing
  catch handler to be silently bypassed when superinstructions removed
  instructions from the try body
- Fix sorted collections: preserve comparator through transient/persistent
  cycle, with-meta, and sorted? predicate
- Fix into to bypass transient path for sorted collections and use JVM
  completion pattern for halt-when compatibility
- Fix take 0 returning nil instead of empty list
- Fix case macro to throw ex-info instead of plain string

Author: chaploud

.dev/memo.md

@@ -42,26 +42,28 @@ Phase 41: Polish & Hardening
 2. [x] 41.2: clojure.edn/read — SKIPPED (needs PushbackReader)
 3. [x] 41.3: clojure.core.reducers — SKIPPED (needs reify, protocols, ForkJoin)
 4. [x] 41.4: Upstream test porting
-5. [ ] 41.5: Additional bug fixes and edge cases
+5. [x] 41.5: Additional bug fixes and edge cases
 
 ## Current Task
 
-41.5: Continue bug fixes and edge cases (round 3).
-- Remaining known issues: control.clj (case throw in VM), sequences (subseq), transducers (interpose transducer+take, halt-when)
+Phase 41 complete. Plan next phase.
 
 ## Previous Task
 
-41.5: Bug fixes and edge cases (round 2).
-- Fixed LazySeq.realize re-entrancy: clear thunk BEFORE calling it (prevents infinite recursion)
-  - Root cause: thunk evaluation could re-enter realize on same LazySeq before result was cached
-  - Fixes: repeat, cycle, interpose, repeatedly, iterate — all infinite lazy-seq patterns
-- Fixed cons to seq-ify rest argument (JVM RT.cons compatible)
-  - Only non-seq types (vector, set, map, hash_map, string) get converted
-  - Seq types (nil, list, cons, lazy_seq, chunked_cons) pass through
-  - Fixes (cons 1 #{2 3}) → (1 2 3) instead of (1 . #{2 3})
-- Fixed builtins table count test (42→43)
-- Result: sequences 393/394 pass (was crashing), transducers 97/99 (was 97/99)
-- Both VM + TreeWalk verified
+41.5: Bug fixes and edge cases (round 3).
+- Fixed peephole optimizer not updating try_begin jump offset (compiler.zig)
+  - Root cause: when superinstructions removed instructions, try_begin operand wasn't remapped
+  - Caused try/catch to silently bypass catch handler in specific patterns
+  - Fix: add .try_begin to jump fixup pass alongside .jump/.jump_if_false/.jump_back
+- Fixed sorted collection support:
+  - TransientHashSet: preserve comparator through transient/persistent cycle
+  - with-meta for sets/maps: preserve comparator field
+  - sorted? predicate: check comparator != null (was always false)
+  - into: bypass transient path for sorted collections, use reduce conj
+  - into 3-arity: match JVM (persistent! in rf completion, not outside transduce)
+- Fixed take 0 returning nil instead of empty list (= (take 0 x) () now true)
+- Fixed case macro throwing plain string instead of ex-info
+- Result: control 157/157, sequences 593/593, transducers 100/100 (all 0 errors)
 
 ## Known Issues
 

src/clj/clojure/core.clj

@@ -1085,7 +1085,7 @@
                    pairs)
          ~@(if default
              (list true default)
-             (list true `(throw (str "No matching clause: " ~gexpr))))))))
+             (list true `(throw (ex-info (str "No matching clause: " ~gexpr) {}))))))))
 
 (defmacro condp
   "Takes a binary predicate, an expression, and a set of clauses.
@@ -1648,13 +1648,21 @@
   ([] [])
   ([to] to)
   ([to from]
-   (if (or (vector? to) (map? to) (set? to))
+   (if (and (or (vector? to) (map? to) (set? to)) (not (sorted? to)))
      (with-meta (persistent! (reduce conj! (transient to) from)) (meta to))
-     (reduce conj to from)))
+     (if (or (map? to) (set? to))
+       (with-meta (reduce conj to from) (meta to))
+       (reduce conj to from))))
   ([to xform from]
-   (if (or (vector? to) (map? to) (set? to))
-     (with-meta (persistent! (transduce xform conj! (transient to) from)) (meta to))
-     (transduce xform conj to from))))
+   (if (and (or (vector? to) (map? to) (set? to)) (not (sorted? to)))
+     (let [tm (meta to)
+           rf (fn
+                ([coll] (-> (persistent! coll) (with-meta tm)))
+                ([coll v] (conj! coll v)))]
+       (transduce xform rf (transient to) from))
+     (if (or (map? to) (set? to))
+       (with-meta (transduce xform conj to from) (meta to))
+       (transduce xform conj to from)))))
 
 (defn- preserving-reduced
   [rf]

src/common/builtin/metadata.zig

@@ -166,7 +166,7 @@ pub fn withMetaFn(allocator: Allocator, args: []const Value) anyerror!Value {
         .map => blk: {
             const m = obj.asMap();
             const new_map = try allocator.create(PersistentArrayMap);
-            new_map.* = .{ .entries = m.entries, .meta = meta_ptr };
+            new_map.* = .{ .entries = m.entries, .meta = meta_ptr, .comparator = m.comparator };
             break :blk Value.initMap(new_map);
         },
         .hash_map => blk: {
@@ -184,7 +184,7 @@ pub fn withMetaFn(allocator: Allocator, args: []const Value) anyerror!Value {
         .set => blk: {
             const s = obj.asSet();
             const new_set = try allocator.create(@import("../collections.zig").PersistentHashSet);
-            new_set.* = .{ .items = s.items, .meta = meta_ptr };
+            new_set.* = .{ .items = s.items, .meta = meta_ptr, .comparator = s.comparator };
             break :blk Value.initSet(new_set);
         },
         .fn_val => blk: {

src/common/builtin/predicates.zig

@@ -535,8 +535,11 @@ fn reversiblePred(_: Allocator, args: []const Value) anyerror!Value {
 /// (sorted? x) — Returns true if coll implements Sorted.
 fn sortedPred(_: Allocator, args: []const Value) anyerror!Value {
     if (args.len != 1) return err.setErrorFmt(.eval, .arity_error, .{}, "Wrong number of args ({d}) passed to sorted?", .{args.len});
-    // No sorted collections in ClojureWasm yet
-    return Value.false_val;
+    return Value.initBoolean(switch (args[0].tag()) {
+        .set => args[0].asSet().comparator != null,
+        .map => args[0].asMap().comparator != null,
+        else => false,
+    });
 }
 
 /// (record? x) — Returns true if x is a record.

src/common/builtin/sequences.zig

@@ -390,7 +390,13 @@ pub fn zigLazyTakeFn(allocator: Allocator, args: []const Value) anyerror!Value {
         .float => if (n_val.asFloat() <= 0) 0 else @intFromFloat(n_val.asFloat()),
         else => return err.setErrorFmt(.eval, .type_error, .{}, "__zig-lazy-take requires numeric n", .{}),
     };
-    if (n == 0) return Value.nil_val;
+    if (n == 0) {
+        // Return empty list (not nil) to match JVM behavior.
+        // (= (take 0 x) ()) is true in JVM Clojure.
+        const empty = try allocator.create(PersistentList);
+        empty.* = .{ .items = &.{} };
+        return Value.initList(empty);
+    }
     const meta = try allocator.create(LazySeq.Meta);
     meta.* = .{ .lazy_take = .{ .n = n, .source = args[1] } };
     const ls = try allocator.create(LazySeq);

src/common/bytecode/compiler.zig

@@ -1360,6 +1360,14 @@ fn peepholeOptimize(
                 const new_target = ip_map[old_target];
                 instr.operand = @intCast(@as(i32, @intCast(nip)) + 1 - @as(i32, new_target));
             },
+            .try_begin => {
+                // try_begin operand is a forward offset to catch handler (same as jump)
+                const old_ip2: usize = old_ip_for_new[nip];
+                const old_target: usize = old_ip2 + 1 + instr.operand;
+                const clamped = @min(old_target, n);
+                const new_target = ip_map[clamped];
+                instr.operand = @intCast(@as(i32, new_target) - @as(i32, @intCast(nip)) - 1);
+            },
             else => {},
         }
     }

src/common/collections.zig

@@ -274,10 +274,11 @@ pub const TransientArrayMap = struct {
 pub const TransientHashSet = struct {
     items: std.ArrayList(Value) = .empty,
     consumed: bool = false,
+    comparator: ?Value = null,
 
     pub fn initFrom(allocator: std.mem.Allocator, source: *const PersistentHashSet) !*TransientHashSet {
         const ts = try allocator.create(TransientHashSet);
-        ts.* = .{};
+        ts.* = .{ .comparator = source.comparator };
         try ts.items.appendSlice(allocator, source.items);
         return ts;
     }
@@ -317,7 +318,7 @@ pub const TransientHashSet = struct {
         const items = try allocator.alloc(Value, self.items.items.len);
         @memcpy(items, self.items.items);
         const s = try allocator.create(PersistentHashSet);
-        s.* = .{ .items = items };
+        s.* = .{ .items = items, .comparator = self.comparator };
         return s;
     }
 };