Merge pull request #11 from BuddhiLW/staging

v1.13.2 — clj-parity: munge/demunge $, slurp on *in*, stack-element-str

Author: BuddhiLW

CHANGELOG.md

@@ -7,6 +7,33 @@ first stable `1.0.0` tag; pre-1.0 `alpha` / `rc` tags may still change surfaces.
 
 ## [Unreleased]
 
+### Added
+
+- **`clojure.core/munge`.** Escapes each character illegal in a Java identifier
+  as a `_TOKEN_` (the inverse of `clojure.repl/demunge`), preserving the
+  argument's type: a string munges to a string, a symbol to a symbol.
+  `(munge "foo-bar?")` is `"foo_bar_QMARK_"`. cljw carried `namespace-munge`
+  and `demunge` but not the full `munge`; found while writing dev tooling.
+
+- **`clojure.repl/stack-element-str`.** Renders one stack frame as
+  `<ns>/<fn> (<file>:<line>)`. cljw has no JVM `StackTraceElement` and only
+  Clojure frames, so it takes the cljw-native frame map `{:ns :fn :file :line}`
+  (as returned by `stack-trace`) and produces exactly clj's Clojure-frame form,
+  e.g. `"clojure.core/map (core.clj:2743)"`.
+
+### Fixed
+
+- **`clojure.repl/demunge` maps the `$` nested-class separator to `/`.**
+  `(demunge "clojure.core$map")` now returns `"clojure.core/map"` as in clj;
+  cljw reversed the munge tokens but left `$` in place.
+
+- **`slurp` reads from `*in*` and any text reader.** `(slurp *in*)` and
+  `(with-in-str s (slurp *in*))` raised "expected string, got host_instance"
+  because the `*in*` reader is a cljw-native text reader, not a host stream, so
+  it fell through slurp's reader arm. slurp now drains a text reader's unread
+  remainder (blocking to stdin EOF for `*in*`), and it respects a prior
+  `read-line`, matching clj.
+
 ## [1.13.1] - 2026-08-31
 
 ### Added

data/placement.yaml

@@ -24,10 +24,10 @@
 schema_version: "2.0"
 summary:
   namespaces_required: 34
-  total: 1418
+  total: 1421
   zig: 405
-  clj: 793
-  value: 214
+  clj: 795
+  value: 215
   unbound: 6
 vars:
   "cljw.error/*error-context*": { impl: value, flags: "dynamic" }
@@ -626,6 +626,8 @@ vars:
   "clojure.core/mod": { impl: zig, flags: "-" }
   "clojure.core/monitor-enter": { impl: zig, flags: "-" }
   "clojure.core/monitor-exit": { impl: zig, flags: "-" }
+  "clojure.core/munge": { impl: clj, flags: "-" }
+  "clojure.core/munge-char-map": { impl: value, flags: "private" }
   "clojure.core/name": { impl: zig, flags: "-" }
   "clojure.core/namespace": { impl: zig, flags: "-" }
   "clojure.core/namespace-munge": { impl: clj, flags: "-" }
@@ -1037,6 +1039,7 @@ vars:
   "clojure.repl/root-cause": { impl: clj, flags: "-" }
   "clojure.repl/source": { impl: clj, flags: "macro" }
   "clojure.repl/source-fn": { impl: clj, flags: "-" }
+  "clojure.repl/stack-element-str": { impl: clj, flags: "-" }
   "clojure.set/difference": { impl: clj, flags: "-" }
   "clojure.set/index": { impl: clj, flags: "-" }
   "clojure.set/intersect2": { impl: clj, flags: "private" }

src/lang/clj/clojure/core.clj

@@ -1812,6 +1812,24 @@
   "Convert a Clojure namespace name to a legal Java package name."
   [ns]
   (.replace (str ns) \- \_))
+
+;; `munge` escapes every character illegal in a Java identifier as a `_TOKEN_`
+;; (the inverse of clojure.repl/demunge). clj routes through Compiler.munge;
+;; cljw carries the same char-map here. The map is a cljw implementation
+;; detail (clj has no `clojure.core/char-map`), so it stays ^:private.
+(def ^:private munge-char-map
+  {\- "_", \: "_COLON_", \+ "_PLUS_", \> "_GT_", \< "_LT_", \= "_EQ_",
+   \~ "_TILDE_", \! "_BANG_", \@ "_CIRCA_", \# "_SHARP_", \' "_SINGLEQUOTE_",
+   \" "_DOUBLEQUOTE_", \% "_PERCENT_", \^ "_CARET_", \& "_AMPERSAND_",
+   \* "_STAR_", \| "_BAR_", \{ "_LBRACE_", \} "_RBRACE_", \[ "_LBRACK_",
+   \] "_RBRACK_", \/ "_SLASH_", \\ "_BSLASH_", \? "_QMARK_"})
+
+(defn munge
+  "Munges a name string or symbol into a legal Java identifier, escaping each
+  special character as a `_TOKEN_`. Returns the same type as its argument."
+  [s]
+  ((if (symbol? s) symbol str)
+   (apply str (map (fn [c] (get munge-char-map c c)) (str s)))))
 ;; `(take-nth n)` / `(take-nth n coll)` — every nth item. The 1-arg form is a
 ;; stateful transducer (emit when the running index is a multiple of n); the
 ;; 2-arg form is lazy.

src/lang/clj/clojure/repl.clj

@@ -25,8 +25,22 @@
       (clojure.string/replace "_EQ_" "=")
       (clojure.string/replace "_PLUS_" "+")
       (clojure.string/replace "_SLASH_" "/")
+      (clojure.string/replace "$" "/")
       (clojure.string/replace "_" "-")))
 
+;; `stack-element-str` renders one cljw stack frame map {:ns :fn :file :line}
+;; as `<ns>/<fn> (<file>:<line>)`. clj takes a JVM StackTraceElement and yields
+;; `class.method (file:line)` for a Java frame or a demunged `ns/fn` for a
+;; Clojure frame; cljw has no StackTraceElement and only Clojure frames
+;; (ADR-0059 / ADR-0120), so it takes the cljw-native frame map and produces
+;; exactly clj's Clojure-frame form. Same render string as
+;; clojure.stacktrace/print-trace-element (both fixed by ADR-0140).
+(defn stack-element-str
+  "Returns a string representation of one cljw stack frame map
+  {:ns :fn :file :line}, as `<ns>/<fn> (<file>:<line>)`."
+  [{:keys [ns fn file line]}]
+  (str (when ns (str ns "/")) fn " (" (or file "") ":" line ")"))
+
 (defn dir-fn
   "Returns a sorted seq of symbols naming public vars in
   a namespace or namespace alias."

src/lang/primitive/file_io.zig

@@ -21,6 +21,7 @@ const keyword_mod = @import("../../runtime/keyword.zig");
 const print_mod = @import("../../runtime/print.zig");
 const host_instance = @import("../../runtime/host_instance.zig");
 const host_stream = @import("../../runtime/io/host_stream.zig");
+const text_io = @import("../../runtime/io/text_io.zig");
 
 /// Coerce the file arg of `slurp`/`spit` to a path string: a `.string` directly,
 /// or a `java.io.File` host instance (its path lives in `state[0]`, ADR-0126) —
@@ -56,6 +57,10 @@ fn raiseFileIoError(op: []const u8, path: []const u8, e: anyerror, loc: SourceLo
 pub fn slurp(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
     _ = env;
     try error_catalog.checkArity("slurp", args, 1, loc);
+    // The `*in*` / with-in-str reader is a text_io Reader (not a host_stream
+    // stream): drain its unread remainder (blocking to stdin EOF for `*in*`).
+    if (try text_io.drainRemaining(rt, args[0])) |rest_bytes|
+        return try string_collection.alloc(rt, rest_bytes);
     // D-471 IOFactory arm: an open Reader/InputStream drains its remainder
     // (clj's slurp routes any IOFactory-coercible arg through io/reader).
     if (host_stream.drainRemaining(args[0])) |rest_bytes|

src/runtime/io/text_io.zig

@@ -218,6 +218,30 @@ pub fn isTextReader(v: Value) bool {
         host_instance.asHostInstance(v).descriptor == &reader_descriptor;
 }
 
+/// The unread remainder of a text_io Reader as bytes, for `slurp` / `(slurp
+/// *in*)`. Null unless `v` is a text_io Reader. A stdin reader blocks pulling
+/// process stdin to EOF first; a pending 1-slot pushback is re-inserted ahead of
+/// the cursor so it is included. Advances the cursor to the end; the returned
+/// slice points into the reader's own buffer, so the caller copies it.
+pub fn drainRemaining(rt: *Runtime, v: Value) !?[]const u8 {
+    if (!isTextReader(v)) return null;
+    const st = readerStateOf(v);
+    if (st.stdin) {
+        while (fillFromStdin(rt, st)) {
+            // drain every stdin chunk into st.data until EOF
+        }
+    }
+    if (st.pushback) |cp| {
+        var buf: [4]u8 = undefined;
+        const n = std.unicode.utf8Encode(cp, &buf) catch 0;
+        if (n > 0) try st.data.insertSlice(rt.gc.infra, st.pos, buf[0..n]);
+        st.pushback = null;
+    }
+    const rest = st.data.items[st.pos..];
+    st.pos = st.data.items.len;
+    return rest;
+}
+
 /// Decode the codepoint at `st.pos` + its UTF-8 byte length, or null at EOF.
 /// Invalid UTF-8 degrades to the raw byte as a 1-byte codepoint (no crash).
 const Decoded = struct { cp: u21, len: usize };

test/clj/suites/io_test.clj

@@ -38,3 +38,16 @@
       (is (= :loaded @(resolve 'load-file-fixture-marker))))
     (testing "*file* is bound during the load (not the default)"
       (is (some? @(resolve 'load-file-fixture-file))))))
+
+;; --- slurp on a Reader (*in* / with-in-str) ---
+;; slurp drains a text_io Reader's unread remainder. The `*in*` / with-in-str
+;; reader is a text_io Reader, not a host_stream stream, so it fell through the
+;; IOFactory arm and slurp raised "expected string". Found writing dev tooling
+;; that did (slurp *in*).
+(deftest slurp-drains-a-reader
+  (testing "with-in-str: slurp returns the whole string"
+    (is (= "hello world" (with-in-str "hello world" (slurp *in*)))))
+  (testing "slurp drains only the UNREAD remainder after read-line"
+    (is (= "ab|cd\nef" (with-in-str "ab\ncd\nef" (str (read-line) "|" (slurp *in*))))))
+  (testing "an empty reader slurps to an empty string"
+    (is (= "" (with-in-str "" (slurp *in*))))))

test/clj/suites/repl_test.clj

@@ -0,0 +1,46 @@
+;; clojure.repl parity (F-011).
+(ns suites.repl-test
+  (:require [clojure.test :refer [deftest is testing]]
+            [clojure.repl :as repl]))
+
+;; --- demunge ---
+;; demunge maps every `$` (the JVM nested-class separator) to `/`, on top of
+;; reversing the munge char tokens. cljw reversed the tokens but left `$`
+;; in place, found while writing the dev tooling in cljw.
+(deftest demunge-maps-dollar-to-slash
+  (testing "the class$fn separator becomes ns/fn"
+    (is (= "clojure.core/map" (repl/demunge "clojure.core$map"))))
+  (testing "every $ maps to / (nested classes)"
+    (is (= "a/b/c" (repl/demunge "a$b$c"))))
+  (testing "$ maps alongside the munge tokens"
+    (is (= "foo/fn?" (repl/demunge "foo$fn_QMARK_")))
+    (is (= "//x" (repl/demunge "_SLASH_$x"))))
+  (testing "a name with no $ still reverses the munge tokens"
+    (is (= "no-dollar" (repl/demunge "no_dollar")))))
+
+;; --- munge (clojure.core, the inverse of demunge) ---
+;; Escapes every character illegal in a Java identifier as a `_TOKEN_`,
+;; preserving the argument's type (string or symbol).
+(deftest munge-escapes-special-chars
+  (testing "string in, string out"
+    (is (= "foo_bar_QMARK_" (munge "foo-bar?")))
+    (is (= "a_SLASH_b.c_d" (munge "a/b.c-d")))
+    (is (= "a_AMPERSAND_b_BAR_c" (munge "a&b|c"))))
+  (testing "symbol in, symbol out"
+    (is (= 'foo_bar_QMARK_ (munge 'foo-bar?)))
+    (is (symbol? (munge 'a))))
+  (testing "a name needing no escaping is unchanged"
+    (is (= "ok" (munge "ok"))))
+  (testing "munge then demunge round-trips a hyphenated name"
+    (is (= "foo-bar" (repl/demunge (munge "foo-bar"))))))
+
+;; --- stack-element-str (cljw-native frame map input) ---
+;; clj takes a JVM StackTraceElement; cljw has only Clojure frames, so it
+;; takes a frame map and produces clj's Clojure-frame render string.
+(deftest stack-element-str-renders-a-frame
+  (testing "a frame map renders as ns/fn (file:line)"
+    (is (= "clojure.core/map (core.clj:2743)"
+           (repl/stack-element-str {:ns "clojure.core" :fn "map" :file "core.clj" :line 2743}))))
+  (testing "a frame with no ns omits the ns/ prefix"
+    (is (= "eval1 (NO_SOURCE_FILE:1)"
+           (repl/stack-element-str {:fn "eval1" :file "NO_SOURCE_FILE" :line 1})))))

test/e2e/phase16_stdin_read_line.sh

@@ -49,4 +49,14 @@ assert_eq 'read_codepoint' \
   "$(printf 'あZ' | "$BIN" -e '(pr-str [(.read *in*) (.read *in*) (.read *in*)])' | tail -1)" \
   '"[12354 90 -1]"'
 
+# slurp on process stdin drains the whole remainder to EOF (-e pr-prints it).
+assert_eq 'slurp_stdin' \
+  "$(printf 'piped-stdin-content' | "$BIN" -e '(slurp *in*)' | tail -1)" \
+  '"piped-stdin-content"'
+
+# slurp drains only the UNREAD remainder after a read-line consumed a line.
+assert_eq 'slurp_stdin_after_read_line' \
+  "$(printf 'first\nrest-of-stream' | "$BIN" -e '(do (read-line) (slurp *in*))' | tail -1)" \
+  '"rest-of-stream"'
+
 echo "ALL phase16_stdin_read_line PASS"