Preserve correct behaviour of structural selection for reflective and non-reflective access

Author: prolativ

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -808,6 +808,8 @@ class Definitions {
   @tu lazy val ClassTagModule: Symbol = ClassTagClass.companionModule
     @tu lazy val ClassTagModule_apply: Symbol = ClassTagModule.requiredMethod(nme.apply)
 
+  @tu lazy val ReflectSelectableTypeRef: TypeRef = requiredClassRef("scala.reflect.Selectable")
+
   @tu lazy val TypeTestClass: ClassSymbol = requiredClass("scala.reflect.TypeTest")
     @tu lazy val TypeTest_unapply: Symbol = TypeTestClass.requiredMethod(nme.unapply)
   @tu lazy val TypeTestModule_identity: Symbol = TypeTestClass.companionModule.requiredMethod(nme.identity)

compiler/src/dotty/tools/dotc/typer/Dynamic.scala

@@ -216,15 +216,23 @@ trait Dynamic {
     def fail(reason: String): Tree =
       errorTree(tree, em"Structural access not allowed on method $name because it $reason")
 
-    fun.tpe.widen match {
-      case tpe: ValueType if ValueClasses.isDerivedValueClass(tpe.classSymbol) =>
-        val underlying = ValueClasses.valueClassUnbox(tpe.classSymbol.asClass).info.resultType.asSeenFrom(tpe, tpe.classSymbol)
-        val wrapped = structuralCall(nme.selectDynamic, Nil)
-        val resultTree = if wrapped.tpe.isExactlyAny then New(tpe, wrapped.cast(underlying) :: Nil) else wrapped
-        resultTree.cast(tpe)
+    extension (tree: Tree)
+      /** The implementations of `selectDynamic` and `applyDynamic` in `scala.reflect.SelectDynamic` have no information about the type of a value obtained via reflection before erasure
+       *  so the can't know if the value should be wrapped in a value class constructor call or not.
+       *  Hence the logic of wrapping is performed here, relying on the fact that the method implementations mentioned above are final.
+       */
+      def maybeBoxingCast(tpe: Type) =
+        val maybeBoxed = 
+          if ValueClasses.isDerivedValueClass(tpe.classSymbol) && qual.tpe <:< defn.ReflectSelectableTypeRef then
+            val underlying = ValueClasses.valueClassUnbox(tpe.classSymbol.asClass).info.resultType.asSeenFrom(tpe, tpe.classSymbol)
+            New(tpe, tree.cast(underlying) :: Nil)
+          else
+            tree
+        maybeBoxed.cast(tpe)
 
+    fun.tpe.widen match {
       case tpe: ValueType =>
-        structuralCall(nme.selectDynamic, Nil).cast(tpe)
+        structuralCall(nme.selectDynamic, Nil).maybeBoxingCast(tpe)
 
       case tpe: MethodType =>
         def isDependentMethod(tpe: Type): Boolean = tpe match {
@@ -244,11 +252,7 @@ trait Dynamic {
               fail(i"has a parameter type with an unstable erasure") :: Nil
             else
               TypeErasure.erasure(tpe).asInstanceOf[MethodType].paramInfos.map(clsOf(_))
-          val finalTpe = tpe.finalResultType
-          if ValueClasses.isDerivedValueClass(finalTpe.classSymbol) then
-            New(finalTpe, structuralCall(nme.applyDynamic, classOfs).cast(finalTpe)
-              .cast(ValueClasses.valueClassUnbox(finalTpe.classSymbol.asClass).info.resultType.asSeenFrom(finalTpe, finalTpe.classSymbol)) :: Nil)
-          else structuralCall(nme.applyDynamic, classOfs).cast(finalTpe)
+          structuralCall(nme.applyDynamic, classOfs).maybeBoxingCast(tpe.finalResultType)
         }
 
       // (@allanrenucci) I think everything below is dead code

tests/run/i14340.check

@@ -1,4 +1,10 @@
 1
+1
+2
 2
-3
-qux
+10
+10
+20
+20
+100
+100

tests/run/i14340.scala

@@ -1,20 +1,57 @@
+class Container1 extends reflect.Selectable
+
+class Container2(values: Map[String, Any], methods: Map[String, Int => Any]) extends Selectable:
+  def selectDynamic(name: String) = values(name)
+  def applyDynamic(name: String)(arg: Int) = methods(name)(arg)
+
 class Foo(val value: Int) extends AnyVal
 class Bar[A](val value: A) extends AnyVal
 
-class Container1 extends reflect.Selectable
+object Helpers:
+  def foo = Foo(1)
+  def bar = Bar(Foo(2))
+  def qux1 = Bar(new Container1 { def foo = Foo(10) })
+  def qux2 = Bar(new Container2(Map("foo" -> Foo(20)), Map.empty).asInstanceOf[Container2 { def foo: Foo }])
+
+@main def Test: Unit =
+  val cont1 = new Container1:
+    def foo = Helpers.foo
+    val bar = Helpers.bar
+    def qux1 = Helpers.qux1
+    def qux2 = Helpers.qux2
+    def fooFromInt(i: Int) = Foo(i)
 
-class Container2 extends Selectable:
-  def selectDynamic(name: String) = Bar(name)
+  val cont2values = Map(
+    "foo" -> Helpers.foo,
+    "bar" -> Helpers.bar,
+    "qux1" -> Helpers.qux1,
+    "qux2" -> Helpers.qux2
+  )
 
-val cont1 = new Container1:
-  def foo = new Foo(1)
-  val bar = new Bar(Foo(2))
-  def fooFromInt(i: Int) = new Foo(i)
+  val cont2methods = Map(
+    "fooFromInt" -> { (i: Int) => Foo(i) }
+  )
 
-val cont2 = (new Container2).asInstanceOf[Container2 { def qux: Bar[String] }]
+  val cont2 = Container2(cont2values, cont2methods).asInstanceOf[Container2 {
+    def foo: Foo
+    def bar: Bar[Foo]
+    def qux1: Bar[Container1 { def foo: Foo }]
+    def qux2: Bar[Container2 { def foo: Foo }]
+    def fooFromInt(i: Int): Foo
+  }]
+  
 
-@main def Test: Unit =
   println(cont1.foo.value)
+  println(cont2.foo.value)
+
   println(cont1.bar.value.value)
-  println(cont1.fooFromInt(3).value)
-  println(cont2.qux.value)
+  println(cont2.bar.value.value)
+
+  println(cont1.qux1.value.foo.value)
+  println(cont2.qux1.value.foo.value)
+  
+  println(cont1.qux2.value.foo.value)
+  println(cont2.qux2.value.foo.value)
+
+  println(cont1.fooFromInt(100).value)
+  println(cont2.fooFromInt(100).value)