strings: make write_decimal handle runtime min_i64 without the min_i64 constant

Address the review on #27522: on the JS backend the min_i64 constant lowers
incorrectly, so the 'if n == min_i64' guard was skipped and a genuine runtime
min_i64 (e.g. from '-9223372036854775808'.i64()) fell into the digit loop where
negating it overflows i64.

Compute the magnitude with wrapping unsigned arithmetic (u64(0) - u64(n)) and
delegate to write_u_decimal instead. This is parity-correct for runtime min_i64
on both backends, removes the dependence on the constant, and drops the
allocating n.str() fallback so the C path is now allocation-free for every input.

Author: medvednikov

vlib/strings/builder.c.v

@@ -74,32 +74,20 @@ pub fn (mut b Builder) write_byte(data u8) {
 // write_decimal appends a decimal representation of the number `n` into the builder `b`,
 // without dynamic allocation. The higher order digits come first, i.e. 6123 will be written
 // with the digit `6` first, then `1`, then `2` and `3` last.
-@[direct_array_access]
 pub fn (mut b Builder) write_decimal(n i64) {
 	if n == 0 {
 		b.write_u8(0x30)
 		return
 	}
-	if n == min_i64 {
-		b.write_string(n.str())
-		return
-	}
-
-	mut buf := [25]u8{}
-	mut x := if n < 0 { -n } else { n }
-	mut i := 24
-	for x != 0 {
-		nextx := x / 10
-		r := x % 10
-		buf[i] = u8(r) + 0x30
-		x = nextx
-		i--
-	}
+	mut mag := u64(n)
 	if n < 0 {
-		buf[i] = `-`
-		i--
+		b.write_u8(`-`)
+		// Wrapping unsigned negation yields the correct magnitude even for `min_i64`,
+		// whose absolute value does not fit in an i64, so this stays allocation-free for
+		// every input without a special case for the signed 64-bit minimum.
+		mag = u64(0) - mag
 	}
-	unsafe { b.write_ptr(&buf[i + 1], 24 - i) }
+	b.write_u_decimal(mag)
 }
 
 // write_u_decimal appends a decimal representation of the unsigned number `n` into the

vlib/strings/builder.js.v

@@ -34,25 +34,16 @@ pub fn (mut b Builder) write_decimal(n i64) {
 		b.write_u8(0x30)
 		return
 	}
-	if n == min_i64 {
-		b.write_string(n.str())
-		return
-	}
-	mut buf := [25]u8{}
-	mut x := if n < 0 { -n } else { n }
-	mut i := 24
-	for x != 0 {
-		buf[i] = u8(x % 10) + 0x30
-		x = x / 10
-		i--
-	}
+	mut mag := u64(n)
 	if n < 0 {
-		buf[i] = `-`
-		i--
-	}
-	for j := i + 1; j <= 24; j++ {
-		b.write_u8(buf[j])
-	}
+		b.write_u8(`-`)
+		// Wrapping unsigned negation yields the correct magnitude even for `min_i64`,
+		// whose absolute value does not fit in an i64. It also avoids depending on the
+		// `min_i64` constant, which the JS backend currently lowers incorrectly, so a
+		// runtime `min_i64` (e.g. from `'-9223372036854775808'.i64()`) still formats right.
+		mag = u64(0) - mag
+	}
+	b.write_u_decimal(mag)
 }
 
 // write_u_decimal appends a decimal representation of the unsigned number `n` into the

vlib/strings/builder_test.v

@@ -168,6 +168,8 @@ fn test_write_decimal() {
 	assert sb_i64_str(9223372036854775807) == '9223372036854775807'
 	assert sb_i64_str(-9223372036854775807) == '-9223372036854775807'
 	assert sb_i64_str(min_i64) == '-9223372036854775808'
+	// runtime `min_i64` (parsed, not the constant), whose negation overflows i64:
+	assert sb_i64_str('-9223372036854775808'.i64()) == '-9223372036854775808'
 }
 
 @[manualfree]