Fix %d/%o/%x overflow for large doubles (#605)

This PR fixes an overflow bug when large doubles are used in jsonnet
string formatting:

- `%d`, `%o`, and `%x` format specs used `Double.toLong` to convert to
an integer, which silently clamps to `Long.MAX_VALUE` (~9.2e18) for
large double values like `1e19` or `1e20`
- Add a `truncateToInteger` helper (mirroring the idiom in
[`RenderUtils.renderDouble`](https://github.com/databricks/sjsonnet/blame/9bd52b5ea0564cbb532d72bc345a65f54233c2d3/sjsonnet/src/sjsonnet/Renderer.scala#L256-L264))
that uses `Long` as a fast path and falls back to `BigDecimal.toBigInt`
for values exceeding `Long` range
- Sign and digits both derive from the truncated `BigInt`, so edge cases
like `-0.3` (which truncates to `0`) are handled naturally.

**Test plan**

- Added unit tests for `%d`, `%o`, `%x` with values exceeding Long range
(`1e19`, `1e20`, `-1e19`)
- Added edge cases for fractional negatives (`-0.3`, `-0.9`) that
truncate to zero
- Expected values verified against official C and Go jsonnet
implementations
- Existing `format.jsonnet` test suite covers format strings that
produce outputs with leading negative signs.

---

All code written by Claude Opus 4.6.

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: JoshRosen

sjsonnet/src/sjsonnet/Format.scala

@@ -236,21 +236,28 @@ object Format {
     output.toString()
   }
 
-  private def formatInteger(formatted: FormatSpec, s: Double): String = {
+  // Truncate a double toward zero, returning the integer part as a BigInt.
+  // Uses Long as a fast path (mirrors RenderUtils.renderDouble); falls back to
+  // BigDecimal for values that exceed Long range (~9.2e18).
+  private def truncateToInteger(s: Double): BigInt = {
     val sl = s.toLong
-    val (lhs, rhs) = if (sl < 0) {
-      ("-", sl.toString.substring(1))
-    } else {
-      ("", sl.toString)
-    }
+    if (sl.toDouble == s) BigInt(sl)
+    else BigDecimal(s).toBigInt
+  }
+
+  private def formatInteger(formatted: FormatSpec, s: Double): String = {
+    val i = truncateToInteger(s)
+    val negative = i.signum < 0
+    val lhs = if (negative) "-" else ""
+    val rhs = i.abs.toString(10)
     val rhs2 = precisionPad(lhs, rhs, formatted.precision)
     widen(
       formatted,
       lhs,
       "",
       rhs2,
       numeric = true,
-      signedConversion = sl >= 0
+      signedConversion = !negative
     )
   }
 
@@ -275,36 +282,34 @@ object Format {
   }
 
   private def formatOctal(formatted: FormatSpec, s: Double): String = {
-    val (lhs, rhs) = if (s < 0) {
-      ("-", s.toLong.abs.toOctalString)
-    } else {
-      ("", s.toLong.toOctalString)
-    }
+    val i = truncateToInteger(s)
+    val negative = i.signum < 0
+    val lhs = if (negative) "-" else ""
+    val rhs = i.abs.toString(8)
     val rhs2 = precisionPad(lhs, rhs, formatted.precision)
     widen(
       formatted,
       lhs,
       if (!formatted.alternate || rhs2(0) == '0') "" else "0",
       rhs2,
       numeric = true,
-      signedConversion = s > 0
+      signedConversion = !negative
     )
   }
 
   private def formatHexadecimal(formatted: FormatSpec, s: Double): String = {
-    val (lhs, rhs) = if (s < 0) {
-      ("-", s.toLong.abs.toHexString)
-    } else {
-      ("", s.toLong.toHexString)
-    }
+    val i = truncateToInteger(s)
+    val negative = i.signum < 0
+    val lhs = if (negative) "-" else ""
+    val rhs = i.abs.toString(16)
     val rhs2 = precisionPad(lhs, rhs, formatted.precision)
     widen(
       formatted,
       lhs,
       if (!formatted.alternate) "" else "0x",
       rhs2,
       numeric = true,
-      signedConversion = s > 0
+      signedConversion = !negative
     )
   }
 

sjsonnet/test/src/sjsonnet/EvaluatorTests.scala

@@ -572,6 +572,24 @@ object EvaluatorTests extends TestSuite {
         "-123.45600"
       )
     }
+    test("formatIntegerOverflow") {
+      // %d, %o, %x should not overflow to Long.MAX_VALUE for large doubles
+      eval("'%d' % 1e19", useNewEvaluator = useNewEvaluator) ==> ujson.Str("10000000000000000000")
+      eval("'%d' % 1e20", useNewEvaluator = useNewEvaluator) ==> ujson.Str(
+        "100000000000000000000"
+      )
+      eval("'%d' % -1e19", useNewEvaluator = useNewEvaluator) ==> ujson.Str(
+        "-10000000000000000000"
+      )
+      eval("'%o' % 1e19", useNewEvaluator = useNewEvaluator) ==> ujson.Str(
+        "1053071060221172000000"
+      )
+      eval("'%x' % 1e19", useNewEvaluator = useNewEvaluator) ==> ujson.Str("8ac7230489e80000")
+      // Sign should be determined from the truncated integer, not the original double:
+      // -0.3 truncates to 0, so no minus sign should appear.
+      eval("'%5.3d' % -0.3", useNewEvaluator = useNewEvaluator) ==> ujson.Str("  000")
+      eval("'%d' % -0.9", useNewEvaluator = useNewEvaluator) ==> ujson.Str("0")
+    }
     test("strict") {
       eval("({ a: 1 } { b: 2 }).a", strict = false, useNewEvaluator = useNewEvaluator) ==> ujson
         .Num(1)