Remove all user-space asUint/toUint in the libraries.

Instead, we use `Integer.toUnsignedLong(x).toDouble`, which is
semantically equivalent. The only remaining use of `x >>> 0` is in
the JS-only runtime libraries, notably `RuntimeLong`.

We add some optimizations to generate the best possible code on all
targets.

For JS with `RuntimeLong`, we need to mark `RuntimeLong.toDouble`
as fully inline. That is fine, as its body is actually very short
(shorter than most methods of `RuntimeLong`). Moreover, we need a
tailored rewrite in the optimizer to get rid of a `Double` addition
of `0.0 + y` when `y` is provably non-negative.

For JS with `bigint`s, we directly fold
`(double) <toLongUnsigned>(x)` into `x >>> 0`. Otherwise, we
unnecessarily go through a `bigint` with `Number(BigInt(x >>> 0))`.

For Wasm, we fold the same shape into a single operation
`f64.convert_i32_u`, which we add in `WasmTransients`.

Author: sjrd

javalib/src/main/scala/java/lang/Integer.scala

@@ -201,6 +201,9 @@ object Integer {
   @inline def toUnsignedLong(x: Int): scala.Long =
     throw new Error("stub") // body replaced by the compiler back-end
 
+  @inline private[lang] def toUnsignedDouble(x: Int): scala.Double =
+    toUnsignedLong(x).toDouble
+
   // Wasm intrinsic
   def bitCount(i: scala.Int): scala.Int = {
     /* See http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetParallel
@@ -308,16 +311,11 @@ object Integer {
 
   @inline private[this] def toStringBase(i: scala.Int, base: scala.Int): String = {
     import js.JSNumberOps.enableJSNumberOps
-    asUint(i).toString(base)
+    toUnsignedDouble(i).toString(base)
   }
 
   @inline private def asInt(n: scala.Double): scala.Int = {
     import js.DynamicImplicits.number2dynamic
     (n | 0).asInstanceOf[Int]
   }
-
-  @inline private def asUint(n: scala.Int): scala.Double = {
-    import js.DynamicImplicits.number2dynamic
-    (n.toDouble >>> 0).asInstanceOf[scala.Double]
-  }
 }

javalib/src/main/scala/java/lang/Long.scala

@@ -158,7 +158,7 @@ object Long {
     if ((i >>> 32).toInt == 0) {
       // It's an unsigned int32
       import js.JSNumberOps.enableJSNumberOps
-      Utils.toUint(i.toInt).toString(radix)
+      Integer.toUnsignedDouble(i.toInt).toString(radix)
     } else {
       toUnsignedStringInternalLarge(i, radix)
     }

javalib/src/main/scala/java/lang/Utils.scala

@@ -187,9 +187,4 @@ private[java] object Utils {
     false
     // scalastyle:on return
   }
-
-  @inline def toUint(x: scala.Double): scala.Double = {
-    import js.DynamicImplicits.number2dynamic
-    (x >>> 0).asInstanceOf[scala.Double]
-  }
 }

library/src/main/scala/scala/scalajs/js/JSNumberOps.scala

@@ -88,6 +88,7 @@ object JSNumberOps {
   final class ExtOps private[JSNumberOps] (private val self: js.Dynamic)
       extends AnyVal {
 
+    @deprecated("Use Integer.toUnsignedLong(x).toDouble instead.", since = "1.20.0")
     @inline def toUint: Double =
       (self >>> 0.asInstanceOf[js.Dynamic]).asInstanceOf[Double]
   }

linker-private-library/src/main/scala/org/scalajs/linker/runtime/FloatingPointBitsPolyfills.scala

@@ -86,7 +86,7 @@ object FloatingPointBitsPolyfills {
     val fbits = 52
     val hifbits = fbits - 32
     val hi = (bits >>> 32).toInt
-    val lo = toUint(bits.toInt)
+    val lo = (bits & 0xffffffffL).toDouble
     val sign = (hi >> 31) | 1 // -1 or 1
     val e = (hi >> hifbits) & ((1 << ebits) - 1)
     val f = (hi & ((1 << hifbits) - 1)).toDouble * 0x100000000L.toDouble + lo
@@ -181,9 +181,6 @@ object FloatingPointBitsPolyfills {
     }
   }
 
-  @inline private def toUint(x: Int): Double =
-    (x.asInstanceOf[js.Dynamic] >>> 0.asInstanceOf[js.Dynamic]).asInstanceOf[Double]
-
   @inline private def rawToInt(x: Double): Int =
     (x.asInstanceOf[js.Dynamic] | 0.asInstanceOf[js.Dynamic]).asInstanceOf[Int]
 

linker-private-library/src/main/scala/org/scalajs/linker/runtime/RuntimeLong.scala

@@ -667,7 +667,7 @@ object RuntimeLong {
       val divisorInv = 1.0 / divisor.toDouble
 
       // initial approximation of the quotient and remainder
-      val approxNum = asUint(hi) * TwoPow32 + asUint(lo)
+      val approxNum = unsignedToDoubleApprox(lo, hi)
       var approxQuot = scala.scalajs.js.Math.floor(approxNum * divisorInv)
       var approxRem = lo - divisor * unsignedSafeDoubleLo(approxQuot)
 
@@ -691,16 +691,15 @@ object RuntimeLong {
     a.lo
 
   @inline
-  def toDouble(a: RuntimeLong): Double =
-    toDouble(a.lo, a.hi)
-
-  private def toDouble(lo: Int, hi: Int): Double = {
+  def toDouble(a: RuntimeLong): Double = {
+    val lo = a.lo
+    val hi = a.hi
     if (hi < 0) {
-      // We do asUint() on the hi part specifically for MinValue
+      // We need unsignedToDoubleApprox specifically for MinValue
       val neg = inline_negate(lo, hi)
-      -(asUint(neg.hi) * TwoPow32 + asUint(neg.lo))
+      -unsignedToDoubleApprox(neg.lo, neg.hi)
     } else {
-      hi * TwoPow32 + asUint(lo)
+      nonNegativeToDoubleApprox(lo, hi)
     }
   }
 
@@ -757,8 +756,7 @@ object RuntimeLong {
       if (isUnsignedSafeDouble(abs.hi) || (abs.lo & 0xffff) == 0) abs.lo
       else (abs.lo & ~0xffff) | 0x8000
 
-    // We do asUint() on the hi part specifically for MinValue
-    val absRes = (asUint(abs.hi) * TwoPow32 + asUint(compressedAbsLo))
+    val absRes = unsignedToDoubleApprox(compressedAbsLo, abs.hi)
 
     (if (hi < 0) -absRes else absRes).toFloat
   }
@@ -1201,7 +1199,7 @@ object RuntimeLong {
 
   /** Converts an unsigned safe double into its Double representation. */
   @inline def asUnsignedSafeDouble(lo: Int, hi: Int): Double =
-    hi * TwoPow32 + asUint(lo)
+    nonNegativeToDoubleApprox(lo, hi)
 
   /** Converts an unsigned safe double into its RuntimeLong representation. */
   @inline def fromUnsignedSafeDouble(x: Double): RuntimeLong =
@@ -1215,10 +1213,27 @@ object RuntimeLong {
   @inline def unsignedSafeDoubleHi(x: Double): Int =
     rawToInt(x / TwoPow32)
 
+  /** Approximates an unsigned (lo, hi) with a Double. */
+  @inline def unsignedToDoubleApprox(lo: Int, hi: Int): Double =
+    uintToDouble(hi) * TwoPow32 + uintToDouble(lo)
+
+  /** Approximates a non-negative (lo, hi) with a Double.
+   *
+   *  If `hi` is known to be non-negative, this method is equivalent to
+   *  `unsignedToDoubleApprox`, but it can fold away part of the computation if
+   *  `hi` is in fact constant.
+   */
+  @inline def nonNegativeToDoubleApprox(lo: Int, hi: Int): Double =
+    hi.toDouble * TwoPow32 + uintToDouble(lo)
+
   /** Interprets an `Int` as an unsigned integer and returns its value as a
    *  `Double`.
+   *
+   *  In user space, this would be `Integer.toUnsignedLong(x).toDouble`.
+   *  However, we cannot use that, since it would circle back here into an
+   *  infinite recursion.
    */
-  @inline def asUint(x: Int): Double = {
+  @inline def uintToDouble(x: Int): Double = {
     import scala.scalajs.js.DynamicImplicits.number2dynamic
     (x.toDouble >>> 0).asInstanceOf[Double]
   }

linker/shared/src/main/scala/org/scalajs/linker/backend/wasmemitter/WasmTransients.scala

@@ -60,6 +60,8 @@ object WasmTransients {
       case F64Floor   => wa.F64Floor
       case F64Nearest => wa.F64Nearest
       case F64Sqrt    => wa.F64Sqrt
+
+      case F64ConvertI32U => wa.F64ConvertI32U
     }
 
     def printIR(out: IRTreePrinter): Unit = {
@@ -87,6 +89,8 @@ object WasmTransients {
     final val F64Nearest = 9
     final val F64Sqrt = 10
 
+    final val F64ConvertI32U = 11
+
     def resultTypeOf(op: Code): Type = (op: @switch) match {
       case I32Ctz | I32Popcnt =>
         IntType
@@ -97,7 +101,7 @@ object WasmTransients {
       case F32Abs =>
         FloatType
 
-      case F64Abs | F64Ceil | F64Floor | F64Nearest | F64Sqrt =>
+      case F64Abs | F64Ceil | F64Floor | F64Nearest | F64Sqrt | F64ConvertI32U =>
         DoubleType
     }
   }

linker/shared/src/main/scala/org/scalajs/linker/frontend/optimizer/OptimizerCore.scala

@@ -3804,6 +3804,23 @@ private[optimizer] abstract class OptimizerCore(
             PreTransLit(DoubleLiteral(v.toDouble))
           case PreTransUnaryOp(IntToLong, x) =>
             foldUnaryOp(IntToDouble, x)
+
+          /* (double) <toLongUnsigned>(x)  -->  <unsignedIntToDouble>(x)
+           *
+           * On Wasm, there is a dedicated transient. On JS, that is (x >>> 0).
+           *
+           * The latter only kicks in when using bigints for longs. When using
+           * RuntimeLong, we have eagerly expanded the `UnsignedIntToLong`
+           * operation, but further inlining and folding will yield the same
+           * result.
+           */
+          case PreTransUnaryOp(UnsignedIntToLong, x) =>
+            val newX = finishTransformExpr(x)
+            val resultTree =
+              if (isWasm) Transient(WasmUnaryOp(WasmUnaryOp.F64ConvertI32U, newX))
+              else makeCast(JSBinaryOp(JSBinaryOp.>>>, newX, IntLiteral(0)), DoubleType)
+            resultTree.toPreTransform
+
           case _ =>
             default
         }
@@ -5035,6 +5052,20 @@ private[optimizer] abstract class OptimizerCore(
           case (PreTransLit(DoubleLiteral(l)), PreTransLit(DoubleLiteral(r))) =>
             doubleLit(l + r)
 
+          /* ±0.0 + cast(a >>> b, DoubleType)  -->  cast(a >>> b, DoubleType)
+           *
+           * In general, `+0.0 + y -> y` is not a valid rewrite, because it does
+           * not give the same result when y is -0.0. (Paradoxically, with -0.0
+           * on the left it *is* a valid rewrite, though not a very useful one.)
+           *
+           * However, if y is the result of a JS `>>>` operator, we know it
+           * cannot be -0.0, hence the rewrite is valid. That particular shape
+           * appears in the inlining of `Integer.toUnsignedLong(x).toDouble`.
+           */
+          case (PreTransLit(DoubleLiteral(0.0)), // also matches -0.0
+              PreTransTree(Transient(Cast(JSBinaryOp(JSBinaryOp.>>>, _, _), DoubleType)), _)) =>
+            rhs
+
           case _ => default
         }
 

project/Build.scala

@@ -2053,16 +2053,16 @@ object Build {
           case `default212Version` =>
             if (!useMinifySizes) {
               Some(ExpectedSizes(
-                  fastLink = 625000 to 626000,
+                  fastLink = 626000 to 627000,
                   fullLink = 94000 to 95000,
                   fastLinkGz = 75000 to 79000,
                   fullLinkGz = 24000 to 25000,
               ))
             } else {
               Some(ExpectedSizes(
-                  fastLink = 425000 to 426000,
+                  fastLink = 426000 to 427000,
                   fullLink = 283000 to 284000,
-                  fastLinkGz = 60000 to 61000,
+                  fastLinkGz = 61000 to 62000,
                   fullLinkGz = 43000 to 44000,
               ))
             }
@@ -2077,7 +2077,7 @@ object Build {
               ))
             } else {
               Some(ExpectedSizes(
-                  fastLink = 301000 to 302000,
+                  fastLink = 302000 to 303000,
                   fullLink = 259000 to 260000,
                   fastLinkGz = 47000 to 48000,
                   fullLinkGz = 42000 to 43000,