feat(interop): D-526 drain 9 (final) — String char[] forms; campaign COMPLETE

Smell-audited: 1: the campaign's REMAINING note claimed (String. char-array)
was missing — probing showed it already works (stale note, corrected in the
discharge); the real gap was valueOf's char[] overloads silently rendering
"#<array>" (a bug, not just a missing method).

String/valueOf gained the char[] and char[]/offset/count overloads
(building the string FROM the characters; bounds-checked window);
String/copyValueOf (1+3 arg JVM alias) registered on the static surface.
Corpus string_join_static +5 clj-byte-matched goldens. D-526 discharged —
9 drains total (java.lang scalars, Objects, Arrays, Collections, String);
deliberate omissions doc'd at their surfaces per the dead-interop lesson.

Author: chaploud

.dev/debt.yaml

@@ -152,85 +152,6 @@ active:
       redundancy + public-readability; merge/prune. SSOT: ADR-0166 row 4.
       (.claude/ edits may hit the self-modification block — surface to user.)
     last_reviewed: "2026-06-24"
-  - id: "D-526"
-    status: |-
-      open (2026-06-24, user-directed; ADR-0166). Java-interop static-member gap
-      catalog + fill: 49 runtime/java/**/*.zig surfaces / 92 compat_tiers fqn.
-      Some static members are missing. If not mechanically enumerable, FIRST
-      catalogue them (extend compat_tiers.yaml / a coverage doc), then fill the
-      "あと少し欠落" tail.
-      DRAIN 1 (2026-06-25): a 63-expr clj-diff sweep over Math/Long/Integer/
-      Character/Double/String statics found the surface near-complete — only
-      `java.lang.String/join` (delim + Iterable form) was missing. Filled it in
-      String.zig (realizes the seqable via clojure.core/vec, then index-walks —
-      no in-loop GC alloc); non-string element raises a ClassCastException-class
-      error like JVM; nil/empty → "". Corpus: test/diff/clj_corpus/string_join_static.txt
-      (7 golden pairs). The 3+-arg varargs form is rejected like JVM Clojure.
-      DRAIN 2 (2026-06-25): the unsigned-arithmetic + JDK-exact static cluster.
-      Added Long/{parseUnsignedLong,sum,divideUnsigned,remainderUnsigned,
-      compareUnsigned,toUnsignedString}, Integer/{parseUnsignedInt,sum,
-      divideUnsigned,remainderUnsigned,compareUnsigned,toUnsignedLong,
-      toUnsignedString}, Math/{absExact,multiplyHigh,clamp} (+ parse.zig
-      parseUnsigned leaf). All happy + error paths match clj (ArithmeticException
-      / IllegalArgumentException / NumberFormatException classes align). Corpus:
-      test/diff/clj_corpus/unsigned_int_statics.txt (24 golden pairs).
-      DRAIN 3 (2026-06-25): the Character surrogate/codePoint cluster + Boolean.
-      Added Character/{charCount,isSurrogate,isHighSurrogate,isLowSurrogate,
-      isSurrogatePair,highSurrogate,lowSurrogate,toCodePoint,isBmpCodePoint,
-      isValidCodePoint,isSupplementaryCodePoint,isISOControl} (pure Unicode-spec
-      arithmetic, no Unicode-DB lookup) + Boolean/{compare,hashCode}. cljw chars
-      ARE codepoints so surrogate values hold numerically (matches clj). Corpus:
-      test/diff/clj_corpus/char_codepoint_bool_statics.txt (27 golden pairs).
-      DEFERRED (Unicode-DB-heavy, low ROI): Character/{getType,isDefined,
-      isMirrored,isJavaIdentifierStart,…} need the full Unicode database.
-      DRAIN 4 (2026-06-25): Double IEEE-754 bit conversion. Added Double/
-      {doubleToLongBits,doubleToRawLongBits,longBitsToDouble,hashCode} (reuses
-      the existing private doubleToLongBits NaN-canonicalizer; bits box as BigInt
-      per D-165, exact). NaN canonical 0x7ff8…/raw split matches clj. Corpus:
-      test/diff/clj_corpus/double_bit_conversion.txt (14 golden pairs). NEXT:
-      java.util.Objects/* is a whole new surface (separate unit); the i48→u64
-      bitcast widening repeats across surfaces (a simplify candidate).
-      DRAIN 5 (2026-06-25): NEW surface java.util.Objects (runtime/java/util/
-      Objects.zig + _host_api + compat_tiers). isNull/nonNull/equals (valueEqual)/
-      requireNonNull (1+2 arg, throws a REAL NullPointerException via the ex_info
-      host-throw path)/requireNonNullElse/toString (1+2 arg). hash/hashCode
-      deferred (Java-hashCode ≠ cljw value hash). Corpus: objects_static.txt
-      (22 golden, incl. catch-by-NullPointerException error cases). REMAINING
-      simplify candidate: the i48→u64 bitcast widening repeated across surfaces.
-      DRAIN 6 (2026-06-25): CLOSE-OUT of the java.lang scalar static surface
-      (Discipline 2 drive-to-zero). Long/Integer/Character hashCode (Java's
-      bit formulas) + Math/{ceilDiv,ceilMod,divideExact,floorDivExact,fma}.
-      Long/Integer divideExact were NOT added (they don't exist in Java — clj
-      compile-errors them, so not a gap). Corpus: scalar_static_close.txt (18
-      golden). The java.lang scalar static surface (Long/Integer/Double/Boolean/
-      Character/Math) is now clj-parity COMPLETE for the common surface; the
-      remaining interop gaps are other packages (java.util.Arrays/Collections,
-      String static char[] forms) — separate units, lower value.
-      DRAIN 7 (2026-07-07): NEW surface java.util.Arrays (runtime/java/util/
-      Arrays.zig + _host_api + compat_tiers keyword `arrays`). asList (returns
-      the D-294 ArrayList host surface — the JVM fixed-size-VIEW aliasing is
-      deliberately not mirrored) / toString ("[e1, e2, …]"; nil arg -> "null") /
-      copyOf (nil-padded like Java's null pad) / sort (in-place natural
-      `compare`, stable) / equals (element value equality, nil-safe) / fill.
-      binarySearch / hashCode / typed-primitive overloads omitted until a real
-      consumer (dead-interop lesson). Corpus: objects_static.txt +9 goldens
-      (clj-byte-matched).
-      DRAIN 8 (2026-07-07): NEW surface java.util.Collections (runtime/java/
-      util/Collections.zig, keyword `collections_util`). emptyList /
-      singletonList (fresh MUTABLE ArrayList hosts — no unmodifiable wrapper
-      in cljw; faking the mutation-throw would lie, noted in the surface doc) /
-      sort + reverse (in-place on an ArrayList via the new pub
-      ArrayList.isArrayList/itemsOf accessors) / max + min (natural compare
-      over vector/array/ArrayList). unmodifiable*/shuffle/synchronized*
-      omitted until a real consumer. Corpus: objects_static.txt +6 goldens.
-      REMAINING: String static char[] forms — the last drain of this row.
-    category: "interop"
-    quality_floor: "public-ization: java-interop static-member gaps (ADR-0166)"
-    barrier: |-
-      Repeatable drain (ADR-0166). Code-touching → diff oracle + corpus apply.
-      Per /continue: catalog or fill one interop surface's missing statics.
-      SSOT: ADR-0166 row 5.
-    last_reviewed: "2026-06-25"
   - id: "D-527"
     status: |-
       USER RECONFIRMED 2026-07-02: direction stands — Clojure stdlib near-total equivalence is the goal; NOT a priority raise (easiest-first order unchanged).
@@ -6546,6 +6467,12 @@ discharged:
     barrier: "DISCHARGED (was: transient overflow panic, repro lost-then-found)."
     last_reviewed: "2026-07-07"
 
+  - id: "D-526"
+    status: "DISCHARGED 2026-07-07 — the Java-interop static-member catalog+fill campaign is COMPLETE across 9 drains. DRAIN 9 (final): String char[] forms — `String/valueOf` gained the char[] and char[]/offset/count overloads (was falling into the generic \"#<array>\" render — a real bug), `String/copyValueOf` (1+3 arg, the JVM alias) registered, `(String. (char-array …))` verified already working (the campaign's stale REMAINING note). Corpus string_join_static +5 clj-byte-matched goldens. FULL CAMPAIGN LEDGER: D1 java.lang scalar sweep (String/join was the only gap — filled); D2 unsigned-arithmetic + JDK-edge Long/Integer statics; D3-D4 (see history); D5 java.util.Objects (new surface); D6 java.lang scalar close-out (hashCode formulas + Math ceilDiv family); D7 java.util.Arrays (new surface: asList/toString/copyOf/sort/equals/fill); D8 java.util.Collections (new surface: emptyList/singletonList/sort/reverse/max/min); D9 String char[] forms. Deliberate omissions (all doc'd at their surfaces, dead-interop lesson): Arrays binarySearch/hashCode/typed-primitive overloads; Collections unmodifiable*/shuffle/synchronized*; Objects hash/hashCode (Java hashCode contract ≠ cljw value hash). Any future static gap is a NEW discovery against a then-current consumer, not this row."
+    category: "interop"
+    barrier: "DISCHARGED (was: static-member gap catalog+fill, ADR-0166 row 5)."
+    last_reviewed: "2026-07-07"
+
 conventions: |-
   - Structure: two top-level lists — `active:` and `discharged:`. Active entries carry id / status / category / barrier (+ optional quality_floor / last_reviewed); discharged entries carry id / discharged_at / resolution. Edit as YAML (no Markdown table to align).
   - New debt: grep `.dev/debt.yaml` for class-overlap before adding (per `.claude/rules/debt_dedup.md`).

data/compat_tiers.yaml

@@ -209,7 +209,8 @@ tiers:
         clojure_peer_vars: []
       # java.lang.StringBuilder — mutable growable buffer (ADR-0114, host_instance).
       # hiccup's compiler builds HTML with it. java.lang.String also has the
-      # static surface `valueOf` + `join` (delim+Iterable) in String.zig
+      # static surface `valueOf` (incl. the char[] + char[]/offset/count
+      # overloads) + `copyValueOf` + `join` (delim+Iterable) in String.zig
       # (instances stay installNativeMethods).
       - fqn: java.lang.StringBuilder
         cljw_ns: cljw.java.lang.StringBuilder

src/runtime/java/lang/String.zig

@@ -594,14 +594,59 @@ const print_mod = @import("../../print.zig");
 /// `(String/valueOf x)` — Java `String.valueOf(Object)`: the str-rendering of
 /// `x`, with `nil` → `"null"` (JVM valueOf(null) is the literal "null").
 fn valueOf(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
-    try error_catalog.checkArity("String/valueOf", args, 1, loc);
+    if (args.len != 1 and args.len != 3)
+        return error_catalog.raise(.arity_not_expected, loc, .{ .fn_name = "String/valueOf", .expected = 1, .got = args.len });
     if (args[0].tag() == .nil) return string_collection.alloc(rt, "null");
+    // Java String.valueOf(char[]) / (char[], offset, count) — the char-array
+    // overloads build the string FROM the characters, not a render of the
+    // array object (D-526; was falling into the generic "#<array>" arm).
+    if (java_array.isArray(args[0])) return charsToString(rt, args, "String/valueOf", loc);
+    try error_catalog.checkArity("String/valueOf", args, 1, loc);
     var aw: std.Io.Writer.Allocating = .init(rt.gpa);
     defer aw.deinit();
     try print_mod.writeStrValue(rt, env, &aw.writer, args[0]);
     return string_collection.alloc(rt, aw.writer.buffered());
 }
 
+/// Shared body of the char-array string builders: `(f arr)` uses the whole
+/// array, `(f arr offset count)` a validated window (JVM
+/// StringIndexOutOfBounds → cljw bounds error). Non-char elements raise a
+/// type error (a Java char[] cannot hold anything else).
+fn charsToString(rt: *Runtime, args: []const Value, comptime fn_name: []const u8, loc: SourceLocation) anyerror!Value {
+    const items = java_array.asArray(args[0]).items();
+    var start: usize = 0;
+    var count: usize = items.len;
+    if (args.len == 3) {
+        const off = try error_catalog.expectInteger(args[1], fn_name, loc);
+        const cnt = try error_catalog.expectInteger(args[2], fn_name, loc);
+        if (off < 0 or cnt < 0 or off + cnt > items.len)
+            return error_catalog.raise(.index_out_of_range, loc, .{ .fn_name = fn_name });
+        start = @intCast(off);
+        count = @intCast(cnt);
+    }
+    var aw: std.Io.Writer.Allocating = .init(rt.gpa);
+    defer aw.deinit();
+    for (items[start .. start + count]) |e| {
+        if (e.tag() != .char)
+            return error_catalog.raise(.type_arg_invalid, loc, .{ .fn_name = fn_name, .expected = "a char array", .actual = @tagName(e.tag()) });
+        var buf: [4]u8 = undefined;
+        const n = std.unicode.utf8Encode(e.asChar(), &buf) catch 0;
+        try aw.writer.writeAll(buf[0..n]);
+    }
+    return string_collection.alloc(rt, aw.writer.buffered());
+}
+
+/// `(String/copyValueOf chars)` / `(String/copyValueOf chars offset count)` —
+/// JVM aliases of the char-array valueOf overloads.
+fn copyValueOf(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
+    _ = env;
+    if (args.len != 1 and args.len != 3)
+        return error_catalog.raise(.arity_not_expected, loc, .{ .fn_name = "String/copyValueOf", .expected = 1, .got = args.len });
+    if (!java_array.isArray(args[0]))
+        return error_catalog.raise(.type_arg_invalid, loc, .{ .fn_name = "String/copyValueOf", .expected = "a char array", .actual = @tagName(args[0].tag()) });
+    return charsToString(rt, args, "String/copyValueOf", loc);
+}
+
 /// `(String/join delim coll)` — Java `String.join(CharSequence, Iterable)`: the
 /// elements of `coll` concatenated with `delim` between adjacent pairs. Each
 /// element must be a string; JVM requires `CharSequence` and throws
@@ -685,10 +730,11 @@ fn stringCtor(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation)
 
 fn initStringStatics(td: *type_descriptor.TypeDescriptor, gpa: std.mem.Allocator) anyerror!void {
     if (td.method_table.len != 0) return; // idempotent
-    const entries = try gpa.alloc(type_descriptor.TypeDescriptor.MethodEntry, 3);
+    const entries = try gpa.alloc(type_descriptor.TypeDescriptor.MethodEntry, 4);
     entries[0] = .{ .protocol_name = "", .method_name = try gpa.dupe(u8, "valueOf"), .method_val = Value.initBuiltinFn(&valueOf) };
     entries[1] = .{ .protocol_name = "", .method_name = try gpa.dupe(u8, "<init>"), .method_val = Value.initBuiltinFn(&stringCtor) };
     entries[2] = .{ .protocol_name = "", .method_name = try gpa.dupe(u8, "join"), .method_val = Value.initBuiltinFn(&join) };
+    entries[3] = .{ .protocol_name = "", .method_name = try gpa.dupe(u8, "copyValueOf"), .method_val = Value.initBuiltinFn(&copyValueOf) };
     td.method_table = entries;
 }
 

test/diff/clj_corpus/string_join_static.txt

@@ -12,3 +12,13 @@
 ;;=> "z"
 (String/join ", " ["x" "y" "z"])
 ;;=> "x, y, z"
+(String/valueOf (char-array [\a \b \c]))
+;;=> "abc"
+(String/valueOf (char-array [\a \b \c]) 1 2)
+;;=> "bc"
+(String/copyValueOf (char-array [\x \y]))
+;;=> "xy"
+(String/copyValueOf (char-array [\p \q \r]) 0 2)
+;;=> "pq"
+(String. (char-array [\a \b]))
+;;=> "ab"