Scala.js: Support for reflective calls.

sjrd · sjrd · commit 73b34b1d0b04 · 2020-07-26T11:11:35.000+02:00
This is significantly different from the code in scalac. In scalac,
reflective calls reach the back-end as dedicated `ApplyDynamic`
nodes. In dotc however, they are expanded by the type-checker into
user-level calls to method of `scala.reflect.Selectable`.

We must therefore reverse-engineer the patterns of code produced by
the compiler to construct SJSIR `Apply` nodes with reflective proxy
method names.

The big comment on `JSCodeGen.genReflectiveCall` explains the
translation in detail.
diff --git a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
@@ -2815,9 +2815,181 @@ class JSCodeGen()(using genCtx: Context) {
             js.ForIn(objVarDef.ref, keyVarIdent, NoOriginalName, {
               js.JSFunctionApply(fVarDef.ref, List(keyVarRef))
             }))
+
+      case REFLECT_SELECTABLE_SELECTDYN =>
+        // scala.reflect.Selectable.selectDynamic
+        genReflectiveCall(tree, isSelectDynamic = true)
+      case REFLECT_SELECTABLE_APPLYDYN =>
+        // scala.reflect.Selectable.applyDynamic
+        genReflectiveCall(tree, isSelectDynamic = false)
     }
   }
 
+  /** Gen the SJSIR for a reflective call.
+   *
+   *  Reflective calls are calls to a structural type field or method that
+   *  involve a reflective Selectable. They look like the following in source
+   *  code:
+   *  {{{
+   *  import scala.reflect.Selectable.reflectiveSelectable
+   *
+   *  type Structural = {
+   *    val foo: Int
+   *    def bar(x: Int, y: String): String
+   *  }
+   *
+   *  val structural: Structural = new {
+   *    val foo: Int = 5
+   *    def bar(x: Int, y: String): String = x.toString + y
+   *  }
+   *
+   *  structural.foo
+   *  structural.bar(6, "hello")
+   *  }}}
+   *
+   *  After expansion by the Scala 3 rules for structural member selections and
+   *  calls, they look like
+   *
+   *  {{{
+   *  reflectiveSelectable(structural).selectDynamic("foo")
+   *  reflectiveSelectable(structural).applyDynamic("bar",
+   *    ClassTag(classOf[Int]), ClassTag(classOf[String])
+   *  )(
+   *    6, "hello"
+   *  )
+   *  }}}
+   *
+   *  and eventually reach the back-end as
+   *
+   *  {{{
+   *  reflectiveSelectable(structural).selectDynamic("foo") // same as above
+   *  reflectiveSelectable(structural).applyDynamic("bar",
+   *    wrapRefArray([ ClassTag(classOf[Int]), ClassTag(classOf[String]) : ClassTag ]
+   *  )(
+   *    genericWrapArray([ Int.box(6), "hello" : Object ])
+   *  )
+   *  }}}
+   *
+   *  If we use the deprecated `import scala.language.reflectiveCalls`, the
+   *  wrapper for the receiver `structural` are the following instead:
+   *
+   *  {{{
+   *  reflectiveSelectableFromLangReflectiveCalls(structural)(
+   *    using scala.languageFeature.reflectiveCalls)
+   *  }}}
+   *
+   *  (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(
+   *    Int.box(6).asInstanceOf[int],
+   *    "hello".asInstanceOf[java.lang.String]
+   *  )
+   *  }}}
+   *
+   *  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 `ClassTag(classOf[tp])`, as a
+   *    compile-time List[Type], from which we'll derive `jstpe.Type`s for the
+   *    `asInstanceOf`s and `jstpe.TypeRef`s for the `MethodName.reflectiveProxy`
+   *  - the actual arguments as a compile-time `List[Tree]`
+   *
+   *  Virtually all of the code in `genReflectiveCall` deals with recovering
+   *  those elements. Constructing the IR Tree is the easy part after that.
+   */
+  private def genReflectiveCall(tree: Apply, isSelectDynamic: Boolean): js.Tree = {
+    implicit val pos = tree.span
+    val Apply(fun @ Select(receiver0, _), 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()
+    }
+
+    // Extract the method name as a String
+    val methodNameStr = args.head match {
+      case Literal(Constants.Constant(name: String)) =>
+        name
+      case _ =>
+        report.error(
+            "The method name given to Selectable.selectDynamic or Selectable.applyDynamic " +
+            "must be a literal string. " +
+            "Other uses are not supported in Scala.js.",
+            args.head.sourcePos)
+        "erroneous"
+    }
+
+    val (formalParamTypeRefs, actualArgs) = if (isSelectDynamic) {
+      (Nil, Nil)
+    } else {
+      // Extract the param type refs and actual args from the 2nd and 3rd argument to applyDynamic
+      args.tail match {
+        case WrapArray(classTagsArray: JavaSeqLiteral) :: WrapArray(actualArgsAnyArray: JavaSeqLiteral) :: Nil =>
+          // Extract jstpe.Type's and jstpe.TypeRef's from the ClassTag.apply(_) trees
+          val formalParamTypesAndTypeRefs = classTagsArray.elems.map {
+            // ClassTag.apply(classOf[tp]) -> tp
+            case Apply(fun, Literal(const) :: Nil)
+                if fun.symbol == defn.ClassTagModule_apply && const.tag == Constants.ClazzTag =>
+              toIRTypeAndTypeRef(const.typeValue)
+            // ClassTag.SpecialType -> erasure(SepecialType.typeRef) (e.g., ClassTag.Any -> Object)
+            case Apply(Select(classTagModule, name), Nil)
+                if classTagModule.symbol == defn.ClassTagModule &&
+                    defn.SpecialClassTagClasses.exists(_.name == name.toTypeName) =>
+              toIRTypeAndTypeRef(TypeErasure.erasure(
+                  defn.SpecialClassTagClasses.find(_.name == name.toTypeName).get.typeRef))
+            // Anything else is invalid
+            case classTag =>
+              report.error(
+                  "The ClassTags passed to Selectable.applyDynamic must be " +
+                  "literal ClassTag(classOf[T]) expressions " +
+                  "(typically compiler-generated). " +
+                  "Other uses are not supported in Scala.js.",
+                  classTag.sourcePos)
+              (jstpe.AnyType, jstpe.ClassRef(jsNames.ObjectClass))
+          }
+
+          // Gen the actual args, downcasting them to the formal param types
+          val actualArgs = actualArgsAnyArray.elems.zip(formalParamTypesAndTypeRefs).map {
+            (actualArgAny, formalParamTypeAndTypeRef) =>
+              val genActualArgAny = genExpr(actualArgAny)
+              js.AsInstanceOf(genActualArgAny, formalParamTypeAndTypeRef._1)(genActualArgAny.pos)
+          }
+
+          (formalParamTypesAndTypeRefs.map(_._2), actualArgs)
+
+        case _ =>
+          report.error(
+              "Passing the varargs of Selectable.applyDynamic with `: _*` " +
+              "is not supported in Scala.js.",
+              tree.sourcePos)
+          (Nil, Nil)
+      }
+    }
+
+    val methodName = MethodName.reflectiveProxy(methodNameStr, formalParamTypeRefs)
+
+    js.Apply(js.ApplyFlags.empty, receiver, js.MethodIdent(methodName), actualArgs)(jstpe.AnyType)
+  }
+
   /** Gen actual actual arguments to Scala method call.
    *  Returns a list of the transformed arguments.
    *
@@ -2992,8 +3164,9 @@ class JSCodeGen()(using genCtx: Context) {
     lazy val isWrapArray: Set[Symbol] = {
       val names0 = defn.ScalaValueClasses().map(sym => nme.wrapXArray(sym.name))
       val names1 = names0 ++ Set(nme.wrapRefArray, nme.genericWrapArray)
-      val names2 = names1.map(defn.ScalaPredefModule.requiredMethod(_))
-      names2.toSet
+      val symsInPredef = names1.map(defn.ScalaPredefModule.requiredMethod(_))
+      val symsInScalaRunTime = names1.map(defn.ScalaRuntimeModule.requiredMethod(_))
+      (symsInPredef ++ symsInScalaRunTime).toSet
     }
 
     def unapply(tree: Apply): Option[Tree] = tree match {
diff --git a/compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala b/compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala
@@ -173,6 +173,23 @@ final class JSDefinitions()(using Context) {
     @threadUnsafe lazy val Reflect_registerInstantiatableClassR = ReflectModule.requiredMethodRef("registerInstantiatableClass")
     def Reflect_registerInstantiatableClass(using Context) = Reflect_registerInstantiatableClassR.symbol
 
+  @threadUnsafe lazy val ReflectSelectableType: TypeRef = requiredClassRef("scala.reflect.Selectable")
+  def ReflectSelectableClass(using Context) = ReflectSelectableType.symbol.asClass
+    @threadUnsafe lazy val ReflectSelectable_selectDynamicR = ReflectSelectableClass.requiredMethodRef("selectDynamic")
+    def ReflectSelectable_selectDynamic(using Context) = ReflectSelectable_selectDynamicR.symbol
+    @threadUnsafe lazy val ReflectSelectable_applyDynamicR = ReflectSelectableClass.requiredMethodRef("applyDynamic")
+    def ReflectSelectable_applyDynamic(using Context) = ReflectSelectable_applyDynamicR.symbol
+
+  @threadUnsafe lazy val ReflectSelectableModuleRef = requiredModuleRef("scala.reflect.Selectable")
+  def ReflectSelectableModule(using Context) = ReflectSelectableModuleRef.symbol
+    @threadUnsafe lazy val ReflectSelectable_reflectiveSelectableR = ReflectSelectableModule.requiredMethodRef("reflectiveSelectable")
+    def ReflectSelectable_reflectiveSelectable(using Context) = ReflectSelectable_reflectiveSelectableR.symbol
+
+  @threadUnsafe lazy val SelectableModuleRef = requiredModuleRef("scala.Selectable")
+  def SelectableModule(using Context) = SelectableModuleRef.symbol
+    @threadUnsafe lazy val Selectable_reflectiveSelectableFromLangReflectiveCallsR = SelectableModule.requiredMethodRef("reflectiveSelectableFromLangReflectiveCalls")
+    def Selectable_reflectiveSelectableFromLangReflectiveCalls(using Context) = Selectable_reflectiveSelectableFromLangReflectiveCallsR.symbol
+
   private var allRefClassesCache: Set[Symbol] = _
   def allRefClasses(using Context): Set[Symbol] = {
     if (allRefClassesCache == null) {
diff --git a/compiler/src/dotty/tools/backend/sjs/JSEncoding.scala b/compiler/src/dotty/tools/backend/sjs/JSEncoding.scala
@@ -253,8 +253,15 @@ object JSEncoding {
     }
   }
 
-  def toIRType(tp: Type)(using Context): jstpe.Type = {
+  def toIRTypeAndTypeRef(tp: Type)(using Context): (jstpe.Type, jstpe.TypeRef) = {
     val typeRefInternal = toTypeRefInternal(tp)
+    (toIRTypeInternal(typeRefInternal), typeRefInternal._1)
+  }
+
+  def toIRType(tp: Type)(using Context): jstpe.Type =
+    toIRTypeInternal(toTypeRefInternal(tp))
+
+  private def toIRTypeInternal(typeRefInternal: (jstpe.TypeRef, Symbol))(using Context): jstpe.Type = {
     typeRefInternal._1 match {
       case jstpe.PrimRef(irTpe) =>
         irTpe
diff --git a/compiler/src/dotty/tools/backend/sjs/JSPrimitives.scala b/compiler/src/dotty/tools/backend/sjs/JSPrimitives.scala
@@ -40,7 +40,10 @@ object JSPrimitives {
 
   final val THROW = DEBUGGER + 1
 
-  final val LastJSPrimitiveCode = THROW
+  final val REFLECT_SELECTABLE_SELECTDYN = THROW + 1                       // scala.reflect.Selectable.selectDynamic
+  final val REFLECT_SELECTABLE_APPLYDYN = REFLECT_SELECTABLE_SELECTDYN + 1 // scala.reflect.Selectable.applyDynamic
+
+  final val LastJSPrimitiveCode = REFLECT_SELECTABLE_APPLYDYN
 
   def isJSPrimitive(code: Int): Boolean =
     code >= FirstJSPrimitiveCode && code <= LastJSPrimitiveCode
@@ -112,6 +115,9 @@ class JSPrimitives(ictx: Context) extends DottyPrimitives(ictx) {
 
     addPrimitive(defn.throwMethod, THROW)
 
+    addPrimitive(jsdefn.ReflectSelectable_selectDynamic, REFLECT_SELECTABLE_SELECTDYN)
+    addPrimitive(jsdefn.ReflectSelectable_applyDynamic, REFLECT_SELECTABLE_APPLYDYN)
+
     primitives.toMap
   }
 
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -1164,6 +1164,8 @@ class Definitions {
 
   @tu lazy val NotRuntimeClasses: Set[Symbol] = Set(AnyClass, AnyValClass, NullClass, NothingClass)
 
+  @tu lazy val SpecialClassTagClasses: Set[Symbol] = Set(UnitClass, AnyClass, AnyValClass)
+
   /** Classes that are known not to have an initializer irrespective of
    *  whether NoInits is set. Note: FunctionXXLClass is in this set
    *  because if it is compiled by Scala2, it does not get a NoInit flag.
diff --git a/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala b/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala
@@ -36,10 +36,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             val sym = tp.typeSymbol
             val classTag = ref(defn.ClassTagModule)
             val tag =
-              if sym == defn.UnitClass
-                 || sym == defn.AnyClass
-                 || sym == defn.AnyValClass
-              then
+              if defn.SpecialClassTagClasses.contains(sym) then
                 classTag.select(sym.name.toTermName)
               else
                 classTag.select(nme.apply).appliedToType(tp).appliedTo(clsOf(erasure(tp)))
@@ -425,4 +422,4 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         EmptyTree
     recur(specialHandlers)
 
-end Synthesizer
+end Synthesizer
diff --git a/project/Build.scala b/project/Build.scala
@@ -1059,7 +1059,7 @@ object Build {
           ++ (dir / "shared/src/test/scala/org/scalajs/testsuite/niocharset" ** (("*.scala": FileFilter)  -- "BaseCharsetTest.scala" -- "Latin1Test.scala" -- "USASCIITest.scala" -- "UTF16Test.scala" -- "UTF8Test.scala")).get
           ++ (dir / "shared/src/test/scala/org/scalajs/testsuite/scalalib" ** (("*.scala": FileFilter)  -- "ArrayBuilderTest.scala" -- "ClassTagTest.scala" -- "EnumerationTest.scala" -- "SymbolTest.scala")).get
           ++ (dir / "shared/src/test/require-sam" ** "*.scala").get
-          ++ (dir / "shared/src/test/require-jdk8/org/scalajs/testsuite/compiler" ** (("*.scala": FileFilter) -- "DefaultMethodsTest.scala")).get
+          ++ (dir / "shared/src/test/require-jdk8/org/scalajs/testsuite/compiler" ** "*.scala").get
           ++ (dir / "shared/src/test/require-jdk8/org/scalajs/testsuite/javalib/lang" ** "*.scala").get
           ++ (dir / "shared/src/test/require-jdk8/org/scalajs/testsuite/javalib/util" ** (("*.scala": FileFilter) -- "CollectionsOnCopyOnWriteArrayListTestOnJDK8.scala")).get
           ++ (dir / "shared/src/test/require-jdk7/org/scalajs/testsuite/javalib/io" ** "*.scala").get
diff --git a/tests/sjs-junit/test/org/scalajs/testsuite/compiler/ReflectiveCallTestScala3.scala b/tests/sjs-junit/test/org/scalajs/testsuite/compiler/ReflectiveCallTestScala3.scala
