Make the dynamic methods of reflect.Selectable final.

By making them final, the Scala.js back-end can process them not
only for `reflectiveSelectable`, but for any custom subclass of
`reflect.Selectable`. This removes its main limitation on Scala.js.

We add `@inline` to the default implementation in
`reflectiveSelectable` (which requires to make it a named class) so
that the Scala.js optimizer can completely optimize it away at
link time. On the JVM, this change has no effect.

Author: sjrd

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -3562,40 +3562,48 @@ class JSCodeGen()(using genCtx: Context) {
    *  )
    *  }}}
    *
-   *  and eventually reach the back-end as
+   *  When the original `structural` value is already of a subtype of
+   *  `scala.reflect.Selectable`, there is no conversion involved. There could
+   *  also be any other arbitrary conversion, such as the deprecated bridge for
+   *  Scala 2's `import scala.language.reflectiveCalls`. In general, the shape
+   *  is therefore the following, for some `selectable: reflect.Selectable`:
    *
    *  {{{
-   *  reflectiveSelectable(structural).selectDynamic("foo") // same as above
-   *  reflectiveSelectable(structural).applyDynamic("bar",
-   *    wrapRefArray([ classOf[Int], classOf[String] : jl.Class ]
+   *  selectable.selectDynamic("foo")
+   *  selectable.applyDynamic("bar",
+   *    classOf[Int], classOf[String]
    *  )(
-   *    genericWrapArray([ Int.box(6), "hello" : Object ])
+   *    6, "hello"
    *  )
    *  }}}
    *
-   *  If we use the deprecated `import scala.language.reflectiveCalls`, the
-   *  wrapper for the receiver `structural` are the following instead:
+   *  and eventually reaches the back-end as
    *
    *  {{{
-   *  reflectiveSelectableFromLangReflectiveCalls(structural)(
-   *    using scala.languageFeature.reflectiveCalls)
+   *  selectable.selectDynamic("foo") // same as above
+   *  selectable.applyDynamic("bar",
+   *    wrapRefArray([ classOf[Int], classOf[String] : jl.Class ]
+   *  )(
+   *    genericWrapArray([ Int.box(6), "hello" : Object ])
+   *  )
    *  }}}
    *
-   *  (in which case we don't care about the contextual argument).
-   *
    *  In SJSIR, they must be encoded as follows:
    *
    *  {{{
-   *  structural.foo;R()
-   *  structural.bar;I;Ljava.lang.String;R(
+   *  selectable.selectedValue;O().foo;R()
+   *  selectable.selectedValue;O().bar;I;Ljava.lang.String;R(
    *    Int.box(6).asInstanceOf[int],
    *    "hello".asInstanceOf[java.lang.String]
    *  )
    *  }}}
    *
+   *  where `selectedValue;O()` is declared in `scala.reflect.Selectable` and
+   *  holds the actual instance on which to perform the reflective operations.
+   *  For the typical use case from the first snippet, it returns `structural`.
+   *
    *  This means that we must deconstruct the elaborated calls to recover:
    *
-   *  - the original receiver `structural`
    *  - the method name as a compile-time string `foo` or `bar`
    *  - the `tp: Type`s that have been wrapped in `classOf[tp]`, as a
    *    compile-time List[Type], from which we'll derive `jstpe.Type`s for the
@@ -3607,26 +3615,10 @@ class JSCodeGen()(using genCtx: Context) {
    */
   private def genReflectiveCall(tree: Apply, isSelectDynamic: Boolean): js.Tree = {
     implicit val pos = tree.span
-    val Apply(fun @ Select(receiver0, _), args) = tree
+    val Apply(fun @ Select(receiver, _), args) = tree
 
-    /* Extract the real receiver, which is the first argument to one of the
-     * implicit conversions scala.reflect.Selectable.reflectiveSelectable or
-     * scala.Selectable.reflectiveSelectableFromLangReflectiveCalls.
-     */
-    val receiver = receiver0 match {
-      case Apply(fun1, receiver :: _)
-          if fun1.symbol == jsdefn.ReflectSelectable_reflectiveSelectable ||
-              fun1.symbol == jsdefn.Selectable_reflectiveSelectableFromLangReflectiveCalls =>
-        genExpr(receiver)
-
-      case _ =>
-        report.error(
-            "The receiver of Selectable.selectDynamic or Selectable.applyDynamic " +
-            "must be a call to the (implicit) method scala.reflect.Selectable.reflectiveSelectable. " +
-            "Other uses are not supported in Scala.js.",
-            tree.sourcePos)
-        js.Undefined()
-    }
+    val selectedValueTree = js.Apply(js.ApplyFlags.empty, genExpr(receiver),
+        js.MethodIdent(selectedValueMethodName), Nil)(jstpe.AnyType)
 
     // Extract the method name as a String
     val methodNameStr = args.head match {
@@ -3682,7 +3674,7 @@ class JSCodeGen()(using genCtx: Context) {
 
     val methodName = MethodName.reflectiveProxy(methodNameStr, formalParamTypeRefs)
 
-    js.Apply(js.ApplyFlags.empty, receiver, js.MethodIdent(methodName), actualArgs)(jstpe.AnyType)
+    js.Apply(js.ApplyFlags.empty, selectedValueTree, js.MethodIdent(methodName), actualArgs)(jstpe.AnyType)
   }
 
   /** Gen actual actual arguments to Scala method call.
@@ -4296,10 +4288,13 @@ object JSCodeGen {
   private val NullPointerExceptionClass = ClassName("java.lang.NullPointerException")
   private val JSObjectClassName = ClassName("scala.scalajs.js.Object")
 
+  private val ObjectClassRef = jstpe.ClassRef(ir.Names.ObjectClass)
+
   private val newSimpleMethodName = SimpleMethodName("new")
 
-  private val ObjectArgConstructorName =
-    MethodName.constructor(List(jstpe.ClassRef(ir.Names.ObjectClass)))
+  private val selectedValueMethodName = MethodName("selectedValue", Nil, ObjectClassRef)
+
+  private val ObjectArgConstructorName = MethodName.constructor(List(ObjectClassRef))
 
   private val thisOriginalName = OriginalName("this")
 

library/src/scala/reflect/Selectable.scala

@@ -1,8 +1,12 @@
 package scala.reflect
 
 /** A class that implements structural selections using Java reflection.
+ *
  *  It can be used as a supertrait of a class or be made available
  *  as an implicit conversion via `reflectiveSelectable`.
+ *
+ *  In Scala.js, it is implemented using a separate Scala.js-specific
+ *  mechanism, since Java reflection is not available.
  */
 trait Selectable extends scala.Selectable:
 
@@ -12,8 +16,9 @@ trait Selectable extends scala.Selectable:
    */
   protected def selectedValue: Any = this
 
+  // The Scala.js codegen relies on this method being final for correctness
   /** Select member with given name */
-  def selectDynamic(name: String): Any =
+  final def selectDynamic(name: String): Any =
     val rcls = selectedValue.getClass
     try
       val fld = rcls.getField(name)
@@ -22,12 +27,13 @@ trait Selectable extends scala.Selectable:
     catch case ex: NoSuchFieldException =>
       applyDynamic(name)()
 
+  // The Scala.js codegen relies on this method being final for correctness
   /** Select method and apply to arguments.
    *  @param name       The name of the selected method
    *  @param paramTypes The class tags of the selected method's formal parameter types
    *  @param args       The arguments to pass to the selected method
    */
-  def applyDynamic(name: String, paramTypes: Class[_]*)(args: Any*): Any =
+  final def applyDynamic(name: String, paramTypes: Class[_]*)(args: Any*): Any =
     val rcls = selectedValue.getClass
     val mth = rcls.getMethod(name, paramTypes: _*)
     ensureAccessible(mth)
@@ -39,4 +45,7 @@ object Selectable:
    *  such that structural selections are performed on that value.
    */
   implicit def reflectiveSelectable(x: Any): Selectable =
-    new Selectable { override val selectedValue = x }
+    new DefaultSelectable(x)
+
+  @inline // important for Scala.js
+  private final class DefaultSelectable(override protected val selectedValue: Any) extends Selectable

tests/neg-scalajs/reflective-calls.scala

@@ -6,40 +6,34 @@ object Test {
    * ensuring that the error cases we test are actually testing the right things.
    */
   def sanityCheck(): Unit = {
-    val receiver: Any = ???
-    reflectiveSelectable(receiver).selectDynamic("foo") // OK
-    reflectiveSelectable(receiver).applyDynamic("foo")() // OK
-    reflectiveSelectable(receiver).applyDynamic("foo", classOf[String], classOf[List[_]])("bar", Nil) // OK
-  }
-
-  def badReceider(): Unit = {
     val receiver: ReflectSel = ???
-    receiver.selectDynamic("foo") // error
-    receiver.applyDynamic("foo")() // error
+    receiver.selectDynamic("foo") // OK
+    receiver.applyDynamic("foo")() // OK
+    receiver.applyDynamic("foo", classOf[String], classOf[List[_]])("bar", Nil) // OK
   }
 
   def nonLiteralMethodName(): Unit = {
-    val receiver: Any = ???
+    val receiver: ReflectSel = ???
     val methodName: String = "foo"
-    reflectiveSelectable(receiver).selectDynamic(methodName) // error
-    reflectiveSelectable(receiver).applyDynamic(methodName)() // error
+    receiver.selectDynamic(methodName) // error
+    receiver.applyDynamic(methodName)() // error
   }
 
   def nonLiteralClassOf(): Unit = {
-    val receiver: Any = ???
+    val receiver: ReflectSel = ???
     val myClassOf: Class[String] = classOf[String]
-    reflectiveSelectable(receiver).applyDynamic("foo", myClassOf, classOf[List[_]])("bar", Nil) // error
+    receiver.applyDynamic("foo", myClassOf, classOf[List[_]])("bar", Nil) // error
   }
 
   def classOfVarArgs(): Unit = {
-    val receiver: Any = ???
+    val receiver: ReflectSel = ???
     val classOfs: List[Class[_]] = List(classOf[String], classOf[List[_]])
-    reflectiveSelectable(receiver).applyDynamic("foo", classOfs: _*)("bar", Nil) // error
+    receiver.applyDynamic("foo", classOfs: _*)("bar", Nil) // error
   }
 
   def argsVarArgs(): Unit = {
-    val receiver: Any = ???
+    val receiver: ReflectSel = ???
     val args: List[Any] = List("bar", Nil)
-    reflectiveSelectable(receiver).applyDynamic("foo", classOf[String], classOf[List[_]])(args: _*) // error
+    receiver.applyDynamic("foo", classOf[String], classOf[List[_]])(args: _*) // error
   }
 }

tests/sjs-junit/test/org/scalajs/testsuite/compiler/CustomSelectableTestScala3.scala

@@ -0,0 +1,28 @@
+package org.scalajs.testsuite.compiler
+
+import scala.reflect.Selectable
+
+import org.junit.Assert._
+import org.junit.Test
+
+class CustomSelectableTestScala3 {
+  import CustomSelectableTestScala3._
+
+  @Test def selectField(): Unit = {
+    val obj: Selectable { val x: Int } = new CustomSelectable(42)
+    assertEquals(47, obj.x)
+  }
+
+  @Test def callMethod(): Unit = {
+    val obj: Selectable { def foo(x: Int, y: String): String } = new CustomSelectable(42)
+    assertEquals("3 bar 42", obj.foo(3, "bar"))
+  }
+}
+
+object CustomSelectableTestScala3 {
+  class CustomSelectable(param: Int) extends Selectable {
+    val x: Int = 5 + param
+
+    def foo(x: Int, y: String): String = s"$x $y $param"
+  }
+}