refactor: deduplicate render utilities and add overflow guards

Motivation:
Combined review of PR databricks#776 + databricks#778 identified ~130 lines of duplicated
SWAR string rendering and long-to-char conversion code, plus two
missing overflow checks in StringModule.

Modification:
- Extract renderQuotedStringSWAR as protected method in BaseCharRenderer,
  delegate from MaterializeJsonRenderer (removes ~60 lines duplication)
- Make escapeCharInline protected, remove duplicate in Renderer
- Consolidate Renderer.visitFloat64 onto inherited writeLongDirect,
  remove standalone RenderUtils.appendLong (~40 lines)
- Add totalLen > Int.MaxValue guard in Join pre-sized allocation
- Add Long overflow detection in parseDigits
- Leverage _asciiSafe flag in Substr/Join to skip redundant scans

Result:
Net -132 lines. All tests pass across JVM/JS/Native/WASM.

Author: He-Pin

sjsonnet/src/sjsonnet/BaseCharRenderer.scala

@@ -259,53 +259,7 @@ class BaseCharRenderer[T <: upickle.core.CharOps.Output](
     flushBuffer()
     s match {
       case str: String if !escapeUnicode =>
-        val len = str.length
-        if (len == 0) {
-          elemBuilder.ensureLength(2)
-          elemBuilder.appendUnsafe('"')
-          elemBuilder.appendUnsafe('"')
-        } else {
-          // Convert to char[] for SWAR scanning + bulk copy
-          val chars = new Array[Char](len)
-          str.getChars(0, len, chars, 0)
-          val firstEscape = CharSWAR.findFirstEscapeCharChar(chars, 0, len)
-          if (firstEscape < 0) {
-            // Clean string — direct bulk copy
-            elemBuilder.ensureLength(len + 2)
-            elemBuilder.appendUnsafe('"')
-            val cbArr = elemBuilder.arr
-            val pos = elemBuilder.getLength
-            System.arraycopy(chars, 0, cbArr, pos, len)
-            elemBuilder.length = pos + len
-            elemBuilder.appendUnsafe('"')
-          } else {
-            // Dirty string — chunked rendering: bulk copy clean segments, escape inline
-            elemBuilder.ensureLength(len + len + 2)
-            elemBuilder.appendUnsafe('"')
-            var from = 0
-            var escPos = firstEscape
-            while (escPos >= 0) {
-              if (escPos > from) {
-                val chunkLen = escPos - from
-                val cbArr = elemBuilder.arr
-                val pos = elemBuilder.getLength
-                System.arraycopy(chars, from, cbArr, pos, chunkLen)
-                elemBuilder.length = pos + chunkLen
-              }
-              escapeCharInline(chars(escPos))
-              from = escPos + 1
-              escPos = if (from < len) CharSWAR.findFirstEscapeCharChar(chars, from, len) else -1
-            }
-            if (from < len) {
-              val tailLen = len - from
-              val cbArr = elemBuilder.arr
-              val pos = elemBuilder.getLength
-              System.arraycopy(chars, from, cbArr, pos, tailLen)
-              elemBuilder.length = pos + tailLen
-            }
-            elemBuilder.appendUnsafe('"')
-          }
-        }
+        renderQuotedStringSWAR(str)
       case _ =>
         upickle.core.RenderUtils.escapeChar(
           null,
@@ -319,8 +273,55 @@ class BaseCharRenderer[T <: upickle.core.CharOps.Output](
     out
   }
 
+  protected def renderQuotedStringSWAR(str: String): Unit = {
+    val len = str.length
+    if (len == 0) {
+      elemBuilder.ensureLength(2)
+      elemBuilder.appendUnsafe('"')
+      elemBuilder.appendUnsafe('"')
+      return
+    }
+    val chars = new Array[Char](len)
+    str.getChars(0, len, chars, 0)
+    val firstEscape = CharSWAR.findFirstEscapeCharChar(chars, 0, len)
+    if (firstEscape < 0) {
+      elemBuilder.ensureLength(len + 2)
+      elemBuilder.appendUnsafe('"')
+      val cbArr = elemBuilder.arr
+      val pos = elemBuilder.getLength
+      System.arraycopy(chars, 0, cbArr, pos, len)
+      elemBuilder.length = pos + len
+      elemBuilder.appendUnsafe('"')
+    } else {
+      elemBuilder.ensureLength(len + len + 2)
+      elemBuilder.appendUnsafe('"')
+      var from = 0
+      var escPos = firstEscape
+      while (escPos >= 0) {
+        if (escPos > from) {
+          val chunkLen = escPos - from
+          val cbArr = elemBuilder.arr
+          val pos = elemBuilder.getLength
+          System.arraycopy(chars, from, cbArr, pos, chunkLen)
+          elemBuilder.length = pos + chunkLen
+        }
+        escapeCharInline(chars(escPos))
+        from = escPos + 1
+        escPos = if (from < len) CharSWAR.findFirstEscapeCharChar(chars, from, len) else -1
+      }
+      if (from < len) {
+        val tailLen = len - from
+        val cbArr = elemBuilder.arr
+        val pos = elemBuilder.getLength
+        System.arraycopy(chars, from, cbArr, pos, tailLen)
+        elemBuilder.length = pos + tailLen
+      }
+      elemBuilder.appendUnsafe('"')
+    }
+  }
+
   /** Inline JSON escape for a single char. */
-  private def escapeCharInline(c: Char): Unit = {
+  protected def escapeCharInline(c: Char): Unit = {
     elemBuilder.ensureLength(6)
     (c: @scala.annotation.switch) match {
       case '"'  => elemBuilder.appendUnsafe('\\'); elemBuilder.appendUnsafe('"')

sjsonnet/src/sjsonnet/Renderer.scala

@@ -17,9 +17,7 @@ class Renderer(out: Writer = new java.io.StringWriter(), indent: Int = -1)
     flushBuffer()
     val i = d.toLong
     if (d == i) {
-      // Fast path: render integers directly to char buffer, avoiding String allocation.
-      // Most numbers in Jsonnet output are integers (array indices, counters, etc.).
-      RenderUtils.appendLong(elemBuilder, i)
+      writeLongDirect(i)
     } else if (d % 1 == 0) {
       appendString(
         BigDecimal(d).setScale(0, BigDecimal.RoundingMode.HALF_EVEN).toBigInt.toString()
@@ -352,81 +350,7 @@ final case class MaterializeJsonRenderer(
   }
 
   /** Render a quoted string into elemBuilder (char-based) with chunked SWAR scanning. */
-  private def renderQuotedString(str: String): Unit = {
-    val len = str.length
-    if (len == 0) {
-      elemBuilder.ensureLength(2)
-      elemBuilder.appendUnsafe('"')
-      elemBuilder.appendUnsafe('"')
-      return
-    }
-    // Convert to char[] for SWAR scanning + bulk copy
-    val chars = new Array[Char](len)
-    str.getChars(0, len, chars, 0)
-    val firstEscape = CharSWAR.findFirstEscapeCharChar(chars, 0, len)
-    if (firstEscape < 0) {
-      // Clean string — direct bulk copy
-      elemBuilder.ensureLength(len + 2)
-      elemBuilder.appendUnsafe('"')
-      val cbArr = elemBuilder.arr
-      val pos = elemBuilder.getLength
-      System.arraycopy(chars, 0, cbArr, pos, len)
-      elemBuilder.length = pos + len
-      elemBuilder.appendUnsafe('"')
-    } else {
-      // Dirty string — chunked rendering: bulk copy clean segments, escape inline
-      elemBuilder.ensureLength(len + len + 2)
-      elemBuilder.appendUnsafe('"')
-      var from = 0
-      var escPos = firstEscape
-      while (escPos >= 0) {
-        // Copy clean chunk before escape char
-        if (escPos > from) {
-          val chunkLen = escPos - from
-          val cbArr = elemBuilder.arr
-          val pos = elemBuilder.getLength
-          System.arraycopy(chars, from, cbArr, pos, chunkLen)
-          elemBuilder.length = pos + chunkLen
-        }
-        // Escape the char inline
-        escapeCharInline(chars(escPos))
-        from = escPos + 1
-        // Find next escape char using SWAR
-        escPos = if (from < len) CharSWAR.findFirstEscapeCharChar(chars, from, len) else -1
-      }
-      // Copy remaining clean tail
-      if (from < len) {
-        val tailLen = len - from
-        val cbArr = elemBuilder.arr
-        val pos = elemBuilder.getLength
-        System.arraycopy(chars, from, cbArr, pos, tailLen)
-        elemBuilder.length = pos + tailLen
-      }
-      elemBuilder.appendUnsafe('"')
-    }
-  }
-
-  /** Inline JSON escape for a single char. */
-  private def escapeCharInline(c: Char): Unit = {
-    elemBuilder.ensureLength(6)
-    (c: @scala.annotation.switch) match {
-      case '"'  => elemBuilder.appendUnsafe('\\'); elemBuilder.appendUnsafe('"')
-      case '\\' => elemBuilder.appendUnsafe('\\'); elemBuilder.appendUnsafe('\\')
-      case '\b' => elemBuilder.appendUnsafe('\\'); elemBuilder.appendUnsafe('b')
-      case '\f' => elemBuilder.appendUnsafe('\\'); elemBuilder.appendUnsafe('f')
-      case '\n' => elemBuilder.appendUnsafe('\\'); elemBuilder.appendUnsafe('n')
-      case '\r' => elemBuilder.appendUnsafe('\\'); elemBuilder.appendUnsafe('r')
-      case '\t' => elemBuilder.appendUnsafe('\\'); elemBuilder.appendUnsafe('t')
-      case _    =>
-        // Control chars → \\u00XX
-        elemBuilder.appendUnsafe('\\')
-        elemBuilder.appendUnsafe('u')
-        elemBuilder.appendUnsafe('0')
-        elemBuilder.appendUnsafe('0')
-        elemBuilder.appendUnsafe(BaseByteRenderer.HEX_CHARS((c >> 4) & 0xf))
-        elemBuilder.appendUnsafe(BaseByteRenderer.HEX_CHARS(c & 0xf))
-    }
-  }
+  private def renderQuotedString(str: String): Unit = renderQuotedStringSWAR(str)
 
   /** Render a double value directly into the char buffer. */
   @inline private def renderDouble(d: Double): Unit = {
@@ -653,54 +577,4 @@ object RenderUtils {
       BigDecimal(d).setScale(0, BigDecimal.RoundingMode.HALF_EVEN).toBigInt.toString()
     } else d.toString
   }
-
-  /** Maximum number of digits in a Long value (Long.MinValue = -9223372036854775808, 20 chars). */
-  private final val MaxLongChars = 20
-
-  /**
-   * Render a long value directly into a [[upickle.core.CharBuilder]], avoiding the intermediate
-   * `String` allocation that `Long.toString` would create. For small absolute values (the common
-   * case in Jsonnet output — array lengths, indices, counters), this saves one allocation per
-   * number. The algorithm writes digits in reverse then reverses in-place.
-   */
-  def appendLong(cb: upickle.core.CharBuilder, value: Long): Unit = {
-    if (value == 0) {
-      cb.append('0')
-      return
-    }
-
-    cb.ensureLength(MaxLongChars)
-    val arr = cb.arr
-    var pos = cb.getLength
-
-    val negative = value < 0
-    // Use negative accumulator to handle Long.MinValue correctly
-    var n = if (negative) value else -value
-    val startPos = pos
-
-    while (n != 0) {
-      val digit = -(n % 10).toInt
-      arr(pos) = ('0' + digit).toChar
-      pos += 1
-      n /= 10
-    }
-
-    if (negative) {
-      arr(pos) = '-'
-      pos += 1
-    }
-
-    // Reverse the digits in-place
-    var lo = startPos
-    var hi = pos - 1
-    while (lo < hi) {
-      val tmp = arr(lo)
-      arr(lo) = arr(hi)
-      arr(hi) = tmp
-      lo += 1
-      hi -= 1
-    }
-
-    cb.length = pos
-  }
 }

sjsonnet/src/sjsonnet/stdlib/StringModule.scala

@@ -62,9 +62,7 @@ object StringModule extends AbstractFunctionModule {
         case _ => Error.fail("Expected a number for len in substr, got " + len.value.prettyName)
       }
 
-      // Fast path: ASCII-only strings have 1:1 char-to-codepoint mapping,
-      // avoiding expensive codePointCount/offsetByCodePoints scans.
-      if (CharSWAR.isAllAscii(str)) {
+      if (srcAsciiSafe || CharSWAR.isAllAscii(str)) {
         val strLen = str.length
         val safeOffset = math.min(offset, strLen)
         val safeLength = math.min(length, strLen - safeOffset)
@@ -288,7 +286,9 @@ object StringModule extends AbstractFunctionModule {
           val sepLen = s.length
           var totalLen = 0L
           var count = 0
-          var allAsciiSafe = CharSWAR.isAllAscii(s) && !CharSWAR.hasEscapeChar(s)
+          val sepVal = sep.value.asInstanceOf[Val.Str]
+          var allAsciiSafe =
+            sepVal._asciiSafe || (CharSWAR.isAllAscii(s) && !CharSWAR.hasEscapeChar(s))
           var i = 0
           while (i < arr.length) {
             arr.value(i) match {
@@ -303,6 +303,8 @@ object StringModule extends AbstractFunctionModule {
             i += 1
           }
           if (count == 0) return Val.Str(pos, "")
+          if (totalLen > Int.MaxValue)
+            Error.fail("Join result too large: " + totalLen + " characters")
           // Pass 2: build result in pre-sized char array.
           val chars = new Array[Char](totalLen.toInt)
           var cPos = 0
@@ -440,7 +442,10 @@ object StringModule extends AbstractFunctionModule {
         else -1
       if (d < 0 || d >= base)
         Error.fail("Cannot parse '" + s + "' as an integer in base " + base)
-      result = result * base + d
+      val next = result * base + d
+      if (next < result)
+        Error.fail("Integer overflow parsing '" + s + "' in base " + base)
+      result = next
       i += 1
     }
     if (isNeg) -result else result

sjsonnet/test/src/sjsonnet/RendererTests.scala

@@ -43,26 +43,14 @@ object RendererTests extends TestSuite {
         |]""".stripMargin
     }
 
-    test("appendLong") {
-      def render(v: Long): String = {
-        val cb = new upickle.core.CharBuilder
-        RenderUtils.appendLong(cb, v)
-        cb.makeString()
-      }
-      test("zero") { render(0L) ==> "0" }
-      test("positive") { render(42L) ==> "42" }
-      test("negative") { render(-1L) ==> "-1" }
-      test("large") { render(9999999999L) ==> "9999999999" }
-      test("maxValue") { render(Long.MaxValue) ==> Long.MaxValue.toString }
-      test("minValue") { render(Long.MinValue) ==> Long.MinValue.toString }
-    }
-
     test("visitFloat64Integers") {
-      // Verify that integer-valued doubles render correctly via the Renderer
       ujson.transform(ujson.Num(0), new Renderer()).toString ==> "0"
       ujson.transform(ujson.Num(42), new Renderer()).toString ==> "42"
       ujson.transform(ujson.Num(-1), new Renderer()).toString ==> "-1"
       ujson.transform(ujson.Num(1e15), new Renderer()).toString ==> "1000000000000000"
+      ujson.transform(ujson.Num(9999999999.0), new Renderer()).toString ==> "9999999999"
+      ujson.transform(ujson.Num(Long.MaxValue.toDouble), new Renderer()).toString ==>
+        Long.MaxValue.toDouble.toLong.toString
     }
 
     test("indentZero") {