Removes spurious js.AsInstanceOf around the js.LinkTimeIf

tanishiking · sjrd · tanishiking · commit a3a0b432dd5a · 2025-07-16T15:14:08.000+09:00
When B<:A and C<:A, `linkTimeIf[A](cond){ B }{ C }` would generate an `.asInstanceOf[A]` that casts the resulting value to a supertype. However, this cast is redundant, as the linker will prune one branch at linktime, and the remaining expression is already known to be a compatible type. This commit eliminates the surrounding `.asInstanceOf` around the `linkTimeIf[T]` when both `thenp` and `elsep` are surely subtypes of `T`. context: #5168 Co-authored-by: Sébastien Doeraene <sjrdoeraene@gmail.com>
diff --git a/compiler/src/main/scala/org/scalajs/nscplugin/GenJSCode.scala b/compiler/src/main/scala/org/scalajs/nscplugin/GenJSCode.scala
@@ -3207,7 +3207,21 @@ abstract class GenJSCode[G <: Global with Singleton](val global: G)
         case Object_isInstanceOf =>
           genIsAsInstanceOf(obj, targs, cast = false)
         case Object_asInstanceOf =>
-          genIsAsInstanceOf(obj, targs, cast = true)
+          val targetTpe = targs.head.tpe
+          obj match {
+            /* This is an optimization for `linkTimeIf(cond)(thenp)(elsep).asInstanceOf[T]`.
+             * If both `thenp` and `elsep` are subtypes of `T`, the `asInstanceOf`
+             * is redundant and can be removed.
+             */
+            case Apply(fun, List(cond, thenp, elsep))
+                if fun.symbol == jsDefinitions.LinkingInfo_linkTimeIf &&
+                thenp.tpe <:< targetTpe && elsep.tpe <:< targetTpe =>
+              val genObj = genExpr(obj).asInstanceOf[js.LinkTimeIf]
+              // Create a new LinkTimeIf tree with the same children, with the type of the `asInstanceOf`.
+              js.LinkTimeIf(genObj.cond, genObj.thenp, genObj.elsep)(toIRType(targetTpe))(genObj.pos)
+            case _ =>
+              genIsAsInstanceOf(obj, targs, cast = true)
+          }
         case Object_synchronized =>
           genSynchronized(obj, args.head, isStat)
         case _ =>
diff --git a/test-suite/js/src/test/scala/org/scalajs/testsuite/library/LinkTimeIfTest.scala b/test-suite/js/src/test/scala/org/scalajs/testsuite/library/LinkTimeIfTest.scala
@@ -92,4 +92,48 @@ class LinkTimeIfTest {
     }
     assertEquals(pow(2.0, 8.0), 256.0, 0)
   }
+
+  // This test verifies that the compiler can safely compile surrounding
+  // implicit asInstanceOf casts to a supertype.
+  @Test def subtyping(): Unit = {
+    trait A { def value: Int }
+    class B(val value: Int) extends A
+    class C(val value: Int) extends A
+
+    val b = new B(1)
+    val c = new C(2)
+
+    val result1 = linkTimeIf[A](productionMode) { b } { c }
+    assertEquals(if (Platform.isInProductionMode) b.value else c.value, result1.value)
+
+    val result2 = linkTimeIf[A](productionMode) { c } { b }
+    assertEquals(if (Platform.isInProductionMode) c.value else b.value, result2.value)
+  }
+
+  @Test def implPattern(): Unit = {
+    sealed abstract class ArrayImpl {
+      type Repr
+      def empty(): Repr
+      def length(v: Repr): Int
+    }
+
+    object JSArrayImpl extends ArrayImpl {
+      type Repr = js.Array[AnyRef]
+      def empty(): Repr = js.Array[AnyRef]()
+      def length(v: Repr): Int = v.length
+    }
+
+    object ScalaArrayImpl extends ArrayImpl {
+      type Repr = Array[AnyRef]
+      def empty(): Repr = new Array[AnyRef](0)
+      def length(v: Repr): Int = v.length
+    }
+
+    val impl = linkTimeIf[ArrayImpl](productionMode) {
+      JSArrayImpl
+    } {
+      ScalaArrayImpl
+    }
+    assertEquals(0, impl.length(impl.empty()))
+  }
 }
