Use JS bigint's if possible inside the parseFloat algorithm.

sjrd · sjrd · commit eb01f47c33b2 · 2025-01-10T15:02:24.000+01:00
We use a `linkTimeIf` to select a `bigint`-based implementation of
`parseFloatDecimalCorrection` when they are supported. We need a
`linkTimeIf` in this case because it uses the JS `**` operator,
which does not link below ES 2016.

The `bigint`-based implementation avoids bringing in the entire
`BigInteger` implementation, which is a major code size win if that
was the only reason `BigInteger` was needed.
diff --git a/javalib/src/main/scala/java/lang/Float.scala b/javalib/src/main/scala/java/lang/Float.scala
@@ -13,7 +13,6 @@
 package java.lang
 
 import java.lang.constant.{Constable, ConstantDesc}
-import java.math.BigInteger
 
 import scala.scalajs.js
 
@@ -233,9 +232,11 @@ object Float {
       fractionalPartStr: String, exponentStr: String,
       zDown: scala.Float, zUp: scala.Float, mid: scala.Double): scala.Float = {
 
+    val bigIntImpl = BigIntImpl.getImpl()
+
     // 1. Accurately parse the string with the representation f × 10ᵉ
 
-    val f: BigInteger = new BigInteger(integralPartStr + fractionalPartStr)
+    val f: bigIntImpl.Repr = bigIntImpl.fromString(integralPartStr + fractionalPartStr)
     val e: Int = Integer.parseInt(exponentStr) - fractionalPartStr.length()
 
     /* Note: we know that `e` is "reasonable" (in the range [-324, +308]). If
@@ -268,24 +269,23 @@ object Float {
 
     val mExplicitBits = midBits & ((1L << mbits) - 1)
     val mImplicit1Bit = 1L << mbits // the implicit '1' bit of a normalized floating-point number
-    val m = BigInteger.valueOf(mExplicitBits | mImplicit1Bit)
+    val m = bigIntImpl.fromUnsignedLong53(mExplicitBits | mImplicit1Bit)
     val k = biasedK - bias - mbits
 
     // 3. Accurately compare f × 10ᵉ to m × 2ᵏ
 
-    @inline def compare(x: BigInteger, y: BigInteger): Int =
-      x.compareTo(y)
+    import bigIntImpl.{multiplyBy2Pow, multiplyBy10Pow}
 
     val cmp = if (e >= 0) {
       if (k >= 0)
-        compare(multiplyBy10Pow(f, e), multiplyBy2Pow(m, k))
+        bigIntImpl.compare(multiplyBy10Pow(f, e), multiplyBy2Pow(m, k))
       else
-        compare(multiplyBy2Pow(multiplyBy10Pow(f, e), -k), m) // this branch may be dead code in practice
+        bigIntImpl.compare(multiplyBy2Pow(multiplyBy10Pow(f, e), -k), m) // this branch may be dead code in practice
     } else {
       if (k >= 0)
-        compare(f, multiplyBy2Pow(multiplyBy10Pow(m, -e), k))
+        bigIntImpl.compare(f, multiplyBy2Pow(multiplyBy10Pow(m, -e), k))
       else
-        compare(multiplyBy2Pow(f, -k), multiplyBy10Pow(m, -e))
+        bigIntImpl.compare(multiplyBy2Pow(f, -k), multiplyBy10Pow(m, -e))
     }
 
     // 4. Choose zDown or zUp depending on the result of the comparison
@@ -300,11 +300,75 @@ object Float {
       zUp
   }
 
-  @inline private def multiplyBy10Pow(v: BigInteger, e: Int): BigInteger =
-    v.multiply(BigInteger.TEN.pow(e))
+  /** An implementation of big integer arithmetics that we need in the above method. */
+  private sealed abstract class BigIntImpl {
+    type Repr
+
+    def fromString(str: String): Repr
+
+    /** Creates a big integer from a `Long` that needs at most 53 bits (unsigned). */
+    def fromUnsignedLong53(x: scala.Long): Repr
+
+    def multiplyBy2Pow(v: Repr, e: Int): Repr
+    def multiplyBy10Pow(v: Repr, e: Int): Repr
+
+    def compare(x: Repr, y: Repr): Int
+  }
+
+  private object BigIntImpl {
+    /** Get the best available implementation of big integers for the given platform.
+     *
+     *  If JS bigint's are supported, use them. Otherwise fall back on
+     *  `java.math.BigInteger`.
+     *
+     *  We need a `linkTimeIf` here because the JS bigint implementation uses
+     *  the `**` operator, which does not link when `esVersion < ESVersion.ES2016`.
+     */
+    @inline def getImpl(): BigIntImpl = {
+      import scala.scalajs.LinkingInfo._
+      linkTimeIf[BigIntImpl](esVersion >= ESVersion.ES2020) {
+        JSBigInt
+      } {
+        JBigInteger
+      }
+    }
+
+    private object JSBigInt extends BigIntImpl {
+      type Repr = js.BigInt
 
-  @inline private def multiplyBy2Pow(v: BigInteger, e: Int): BigInteger =
-    v.shiftLeft(e)
+      @inline def fromString(str: String): Repr = js.BigInt(str)
+
+      /* The 53-bit restriction allows us to take twice 31 bits, which avoids
+       * the issue of considering the bit 31 as a sign bit in the rhs of the |.
+       * It also guarantees we can safely build a `Double` out of it.
+       */
+      @inline def fromUnsignedLong53(x: scala.Long): Repr =
+        js.BigInt((x >>> 31).toInt.toDouble * 2147483648.0 + (x.toInt & 0x7fffffff).toDouble)
+
+      @inline def multiplyBy2Pow(v: Repr, e: Int): Repr = v << js.BigInt(e)
+      @inline def multiplyBy10Pow(v: Repr, e: Int): Repr = v * (js.BigInt(10) ** js.BigInt(e))
+
+      @inline def compare(x: Repr, y: Repr): Int = {
+        if (x < y) -1
+        else if (x > y) 1
+        else 0
+      }
+    }
+
+    private object JBigInteger extends BigIntImpl {
+      import java.math.BigInteger
+
+      type Repr = BigInteger
+
+      @inline def fromString(str: String): Repr = new BigInteger(str)
+      @inline def fromUnsignedLong53(x: scala.Long): Repr = BigInteger.valueOf(x)
+
+      @inline def multiplyBy2Pow(v: Repr, e: Int): Repr = v.shiftLeft(e)
+      @inline def multiplyBy10Pow(v: Repr, e: Int): Repr = v.multiply(BigInteger.TEN.pow(e))
+
+      @inline def compare(x: Repr, y: Repr): Int = x.compareTo(y)
+    }
+  }
 
   private def parseFloatHexadecimal(integralPartStr: String,
       fractionalPartStr: String, binaryExpStr: String): scala.Float = {
