Introduce casts around JSBinaryOps for x | 0 and x >>> 0.

sjrd · sjrd · commit 5fe402b29683 · 2025-06-21T23:11:15.000+02:00
We use these in some low-level routines, notably in `RuntimeLong`.
Introducing casts avoids unnecessary `AsInstanceOf`s around them.
diff --git a/linker/shared/src/main/scala/org/scalajs/linker/frontend/optimizer/OptimizerCore.scala b/linker/shared/src/main/scala/org/scalajs/linker/frontend/optimizer/OptimizerCore.scala
@@ -646,7 +646,40 @@ private[optimizer] abstract class OptimizerCore(
         JSUnaryOp(op, transformExpr(lhs))
 
       case JSBinaryOp(op, lhs, rhs) =>
-        JSBinaryOp(op, transformExpr(lhs), transformExpr(rhs))
+        val newTree = JSBinaryOp(op, transformExpr(lhs), transformExpr(rhs))
+
+        // Introduce casts for some idioms that are guaranteed to return certain types
+
+        // Is `arg` guaranteed to evaluate to a JS `number` (and hence, not a `bigint`)?
+        def isJSNumber(arg: Tree): Boolean = arg.tpe match {
+          case IntType | DoubleType | ByteType | ShortType | FloatType => true
+          case _                                                       => false
+        }
+
+        newTree match {
+          /* Unless it throws, `x | y` returns either a signed 32-bit integer
+           * (an `Int`) or a bigint.
+           *
+           * The only case in which it returns a bigint is when both arguments
+           * are (convertible to) bigint's. Custom objects can be converted to
+           * bigint's if their `valueOf()` method returns a bigint.
+           *
+           * Primitive numbers cannot be implicitly converted to bigint's.
+           * `x | y` throws if one side is a number and the other is (converted
+           * to) a bigint. Therefore, if at least one of the arguments is known
+           * to be a primitive number, we know that `x | y` will return a
+           * signed 32-bit integer (or throw).
+           */
+          case JSBinaryOp(JSBinaryOp.|, x, y) if isJSNumber(x) || isJSNumber(y) =>
+            makeCast(newTree, IntType)
+
+          // >>> always returns a positive number in the unsigned 32-bit range (it rejects bigints)
+          case JSBinaryOp(JSBinaryOp.>>>, _, _) =>
+            makeCast(newTree, DoubleType)
+
+          case _ =>
+            newTree
+        }
 
       case JSArrayConstr(items) =>
         JSArrayConstr(transformExprsOrSpreads(items))
diff --git a/project/Build.scala b/project/Build.scala
@@ -2062,7 +2062,7 @@ object Build {
               Some(ExpectedSizes(
                   fastLink = 425000 to 426000,
                   fullLink = 282000 to 283000,
-                  fastLinkGz = 61000 to 62000,
+                  fastLinkGz = 60000 to 61000,
                   fullLinkGz = 43000 to 44000,
               ))
             }

Original file line number	Diff line number	Diff line change
`@@ -2062,7 +2062,7 @@ object Build {`
`2062`	`2062`	`Some(ExpectedSizes(`
`2063`	`2063`	`fastLink = 425000 to 426000,`
`2064`	`2064`	`fullLink = 282000 to 283000,`
`2065`		`- fastLinkGz = 61000 to 62000,`
	`2065`	`+ fastLinkGz = 60000 to 61000,`
`2066`	`2066`	`fullLinkGz = 43000 to 44000,`
`2067`	`2067`	`))`
`2068`	`2068`	`}`