feat(bigdecimal): .toPlainString — always-plain rendering shared with toString's plain arm

Smell-audited: 1: the plain-digit body was extracted from
writeBigDecimalDigits into a shared writePlainDigits (+ the always-plain
writeBigDecimalPlain entry) instead of a second copy — F-011
commonization; no other smell.

D-564's cheapest named residual: (BigDecimal. "1E+3") .toPlainString →
"1000" while .toString keeps "1E+3" (JVM-exact); negative-scale zero
append + sub-1 zero padding covered. Corpus bigdecimal_plain.txt (6/6
clj-oracle matched); compat_tiers BigDecimal row updated (the
compat_members gate enforces it); D-564 narrowed.

Author: chaploud

.dev/debt.yaml

@@ -40,8 +40,9 @@ active:
       class_name.zig / host_class_resolve / rt.types keys / compat rows
       from a single table — prerequisite: ADR-0174, landed). Named member
       residuals the D9 refresh surfaced (removed from compat_tiers as rot,
-      not implemented this campaign): BigDecimal .toPlainString (commonly
-      used; siblings all exist — cheap wire), ZonedDateTime full build-out
+      not implemented this campaign): BigDecimal .toPlainString DISCHARGED
+      2026-07-17 (shared print.writeBigDecimalPlain body + corpus
+      bigdecimal_plain.txt, 6/6 oracle), ZonedDateTime full build-out
       (= D-105), Socket/MessageDigest build-out (= D-106), and the
       instance-method fills judged out of ADR-0174 scope (StringBuilder
       insert/delete/substring set beyond the landed 8, File

data/compat_tiers.yaml

@@ -608,7 +608,7 @@ tiers:
         files:
           surface: runtime/java/math/BigDecimal.zig
           impl: runtime/numeric/big_decimal.zig
-        methods: [abs, add, compareTo, divide, divideAndRemainder, divideToIntegralValue, doubleValue, intValue, longValue, max, min, movePointLeft, movePointRight, multiply, negate, pow, precision, remainder, round, scale, scaleByPowerOfTen, setScale, signum, stripTrailingZeros, subtract, toBigInteger, ulp, unscaledValue, valueOf]
+        methods: [abs, add, compareTo, divide, divideAndRemainder, divideToIntegralValue, doubleValue, intValue, longValue, max, min, movePointLeft, movePointRight, multiply, negate, pow, precision, remainder, round, scale, scaleByPowerOfTen, setScale, signum, stripTrailingZeros, subtract, toBigInteger, toPlainString, ulp, unscaledValue, valueOf]
         static_fields: ["ONE", "ROUND_CEILING", "ROUND_DOWN", "ROUND_FLOOR", "ROUND_HALF_DOWN", "ROUND_HALF_EVEN", "ROUND_HALF_UP", "ROUND_UNNECESSARY", "ROUND_UP", "TEN", "TWO", "ZERO"]
         clojure_peer_vars: [clojure.core/bigdec]
       # java.math.RoundingMode — the 8 enum constants (UP..UNNECESSARY) as

src/runtime/java/math/BigDecimal.zig

@@ -47,6 +47,20 @@ fn scaleFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) an
     return Value.initInteger(big_decimal.asScale(args[0]));
 }
 
+/// `(.toPlainString bd)` — the value WITHOUT exponent notation, whatever the
+/// scale (`(BigDecimal. "1E+3")` → "1000"; `.toString` keeps "1E+3").
+/// JVM `BigDecimal.toPlainString()`. Rendering shared with the toString
+/// plain arm via `print.writeBigDecimalPlain` (D-564 residual).
+fn toPlainStringFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
+    _ = env;
+    try error_catalog.checkArity("toPlainString", args, 1, loc);
+    try requireBd(args[0], "toPlainString", loc);
+    var aw: std.Io.Writer.Allocating = .init(rt.gpa);
+    defer aw.deinit();
+    try print_mod.writeBigDecimalPlain(&aw.writer, args[0]);
+    return string_collection.alloc(rt, aw.writer.buffered());
+}
+
 /// `(.signum bd)` — -1 / 0 / 1 by the sign of the value. JVM `BigDecimal.signum()`.
 fn signumFn(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anyerror!Value {
     _ = rt;
@@ -494,6 +508,7 @@ pub fn installNativeMethods(rt: *Runtime) !void {
     const specs = .{
         .{ "setScale", &setScale },
         .{ "scale", &scaleFn },
+        .{ "toPlainString", &toPlainStringFn },
         .{ "signum", &signumFn },
         .{ "unscaledValue", &unscaledValueFn },
         .{ "precision", &precisionFn },

src/runtime/print.zig

@@ -1085,6 +1085,53 @@ fn printBigDecimal(w: *Writer, v: Value) anyerror!void {
     try w.writeByte('M');
 }
 
+/// Plain (no-exponent) rendering of unsigned `digits` at `scale` — the body
+/// both `BigDecimal.toString`'s plain arm and `.toPlainString` share.
+/// scale < 0 appends zeros (unscaled × 10^-scale); scale > 0 places the
+/// decimal point, zero-padding a sub-1 magnitude.
+fn writePlainDigits(w: *Writer, digits: []const u8, scale: i32) anyerror!void {
+    if (scale == 0) {
+        try w.writeAll(digits);
+    } else if (scale < 0) {
+        try w.writeAll(digits);
+        const zeros: usize = @intCast(-@as(i64, scale));
+        for (0..zeros) |_| try w.writeByte('0');
+    } else {
+        const scale_u: usize = @intCast(scale);
+        if (scale_u >= digits.len) {
+            try w.writeAll("0.");
+            for (0..scale_u - digits.len) |_| try w.writeByte('0');
+            try w.writeAll(digits);
+        } else {
+            const dot_pos = digits.len - scale_u;
+            try w.writeAll(digits[0..dot_pos]);
+            try w.writeByte('.');
+            try w.writeAll(digits[dot_pos..]);
+        }
+    }
+}
+
+/// JVM `BigDecimal.toPlainString` — ALWAYS plain notation, whatever the
+/// scale/adjusted exponent (`1E+3M` renders "1000", `1E-10M` renders
+/// "0.0000000001"). The `.toPlainString` surface method writes through this;
+/// `writeBigDecimalDigits` (= toString) uses the same digit body only in its
+/// plain arm.
+pub fn writeBigDecimalPlain(w: *Writer, v: Value) anyerror!void {
+    const bd = v.decodePtr(*const big_decimal_mod.BigDecimal);
+    var buf: [1024]u8 = undefined;
+    var sw: std.Io.Writer = .fixed(&buf);
+    sw.print("{f}", .{bd.unscaled.m}) catch {
+        // Unscaled wider than the buffer — lossy digits-only fallback,
+        // mirroring writeBigDecimalDigits' stance.
+        return w.print("{f}", .{bd.unscaled.m});
+    };
+    const written = buf[0..sw.end];
+    const neg = written.len > 0 and written[0] == '-';
+    const digits = if (neg) written[1..] else written;
+    if (neg) try w.writeByte('-');
+    try writePlainDigits(w, digits, bd.scale);
+}
+
 pub fn writeBigDecimalDigits(w: *Writer, v: Value) anyerror!void {
     // value = unscaled * 10^(-scale). Reproduces JVM `BigDecimal.toString`:
     // plain notation when `scale >= 0` AND the adjusted exponent
@@ -1107,22 +1154,7 @@ pub fn writeBigDecimalDigits(w: *Writer, v: Value) anyerror!void {
 
     if (neg) try w.writeByte('-');
     if (bd.scale >= 0 and adj_exp >= -6) {
-        // Plain notation (toPlainString).
-        if (bd.scale == 0) {
-            try w.writeAll(digits);
-        } else {
-            const scale_u: usize = @intCast(bd.scale);
-            if (scale_u >= digits.len) {
-                try w.writeAll("0.");
-                for (0..scale_u - digits.len) |_| try w.writeByte('0');
-                try w.writeAll(digits);
-            } else {
-                const dot_pos = digits.len - scale_u;
-                try w.writeAll(digits[0..dot_pos]);
-                try w.writeByte('.');
-                try w.writeAll(digits[dot_pos..]);
-            }
-        }
+        try writePlainDigits(w, digits, bd.scale);
     } else {
         // Scientific: one digit, optional fraction, `E`, signed exponent.
         try w.writeByte(digits[0]);

test/diff/clj_corpus/bigdecimal_plain.txt

@@ -0,0 +1,12 @@
+(.toPlainString 1.5M)
+;;=> "1.5"
+(.toPlainString (java.math.BigDecimal. "1E+3"))
+;;=> "1000"
+(.toPlainString 0.00001M)
+;;=> "0.00001"
+(.toPlainString -2.50M)
+;;=> "-2.50"
+(.toPlainString 123M)
+;;=> "123"
+(.toPlainString (java.math.BigDecimal. "1E-10"))
+;;=> "0.0000000001"