Change structural types scheme

Make Selectable a marker trait without any members.

Author: odersky

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

@@ -151,20 +151,37 @@ trait Dynamic {
   def handleStructural(tree: Tree)(using Context): Tree = {
     val (fun @ Select(qual, name), targs, vargss) = decomposeCall(tree)
 
-    def structuralCall(selectorName: TermName, ctags: List[Tree]) = {
+    def structuralCall(selectorName: TermName, ctags: => List[Tree]) = {
       val selectable = adapt(qual, defn.SelectableClass.typeRef)
 
-      // ($qual: Selectable).$selectorName("$name", ..$ctags)
+      // ($qual: Selectable).$selectorName("$name")
       val base =
         untpd.Apply(
           untpd.TypedSplice(selectable.select(selectorName)).withSpan(fun.span),
-          (Literal(Constant(name.toString)) :: ctags).map(untpd.TypedSplice(_)))
+          (Literal(Constant(name.toString)) :: Nil).map(untpd.TypedSplice(_)))
 
       val scall =
         if (vargss.isEmpty) base
         else untpd.Apply(base, vargss.flatten)
 
-      typed(scall)
+      // If function is an `applyDynamic` that takes a ClassTag* parameter,
+      // add `ctags`.
+      def addClassTags(tree: Tree): Tree = tree match
+        case Apply(fn: Apply, args) =>
+          cpy.Apply(tree)(addClassTags(fn), args)
+        case Apply(fn @ Select(_, nme.applyDynamic), nameArg :: _ :: Nil) =>
+          fn.tpe.widen match
+            case mt: MethodType => mt.paramInfos match
+              case _ :: ctagsParam :: Nil
+              if ctagsParam.isRepeatedParam
+                 && ctagsParam.argInfos.head.isRef(defn.ClassTagClass) =>
+                  val ctagType = defn.ClassTagClass.typeRef.appliedTo(TypeBounds.empty)
+                  cpy.Apply(tree)(fn,
+                    nameArg :: seqToRepeated(SeqLiteral(ctags, TypeTree(ctagType))) :: Nil)
+              case _ => tree
+            case other => tree
+        case _ => tree
+      addClassTags(typed(scall))
     }
 
     def fail(name: Name, reason: String) =
@@ -187,7 +204,7 @@ trait Dynamic {
         if (isDependentMethod(tpe))
           fail(name, i"has a method type with inter-parameter dependencies")
         else {
-          val ctags = tpe.paramInfoss.flatten.map(pt =>
+          def ctags = tpe.paramInfoss.flatten.map(pt =>
             implicitArgTree(defn.ClassTagClass.typeRef.appliedTo(pt.widenDealias :: Nil), fun.span.endPos))
           structuralCall(nme.applyDynamic, ctags).cast(tpe.finalResultType)
         }

docs/docs/reference/changed-features/structural-types-spec.md

@@ -48,7 +48,7 @@ consider three distinct cases:
   ```
 
 - If `U` is a method type `(T11, ..., T1n)...(TN1, ..., TNn) => R` and it is not
-a dependent method type, we map `v.a(a11, ..., a1n)...(aN1, aNn)` to
+a dependent method type, we map `v.a(a11, ..., a1n)...(aN1, ..., aNn)` to
   the  equivalent of:
   ```scala
   v.a(arg1, ..., argn)
@@ -57,6 +57,7 @@ a dependent method type, we map `v.a(a11, ..., a1n)...(aN1, aNn)` to
                               (a11, ..., a1n, ..., aN1, ..., aNn)
                  .asInstanceOf[R]
   ```
+where each `CT_ij` is the class tag of the type of the argument `a_ij`.
 
 - If `U` is neither a value nor a method type, or a dependent method
   type, an error is emitted.

library/src/scala/Selectable.scala

@@ -1,8 +1,24 @@
 package scala
 import scala.reflect.ClassTag
 
-trait Selectable extends Any {
-  def selectDynamic(name: String): Any
-  def applyDynamic(name: String, paramClasses: ClassTag[_]*)(args: Any*): Any =
-    new UnsupportedOperationException("applyDynamic")
-}
+/** A marker trait for objects that support structural selection via
+ *  `selectDynamic` and `applyDynamic`
+ *
+ *  Implementation classes should define, or make available as extension
+ *  methods, the following two method signatures:
+ *
+ *    def selectDynamic(name: String): Any
+ *    def applyDynamic(name: String)(args: Any*): Any =
+ *
+ *  `selectDynamic` is invoked for simple selections `v.m`, whereas
+ *  `applyDynamic` is invoked for selections with arguments `v.m(...)`.
+ *  If there's only one kind of selection, the method supporting the
+ *  other may be omitted. The `applyDynamic` can also have a second parameter
+ *  list of class tag arguments, i.e. it may alternatively have the signature
+ *
+ *    def applyDynamic(name: String, paramClasses: ClassTag[_]*)(args: Any*): Any
+ *
+ *  In this case the call will synthesize `ClassTag` arguments for all formal parameter
+ *  types of the method in the structural type.
+ */
+trait Selectable extends Any

library/src/scala/reflect/Selectable.scala

@@ -14,7 +14,7 @@ class Selectable(val receiver: Any) extends AnyVal with scala.Selectable {
     }
   }
 
-  override def applyDynamic(name: String, paramTypes: ClassTag[_]*)(args: Any*): Any = {
+  def applyDynamic(name: String, paramTypes: ClassTag[_]*)(args: Any*): Any = {
     val rcls = receiver.getClass
     val paramClasses = paramTypes.map(_.runtimeClass)
     val mth = rcls.getMethod(name, paramClasses: _*)
@@ -24,8 +24,6 @@ class Selectable(val receiver: Any) extends AnyVal with scala.Selectable {
 }
 
 object Selectable {
-  implicit def reflectiveSelectable(receiver: Any): scala.Selectable = receiver match {
-    case receiver: scala.Selectable => receiver
-    case _                          => new Selectable(receiver)
-  }
+  implicit def reflectiveSelectable(receiver: Any): Selectable =
+    new Selectable(receiver)
 }

tests/run-macros/refined-selectable-macro/Macro_1.scala

@@ -2,6 +2,9 @@ import scala.quoted._
 
 object Macro {
 
+  trait Selectable extends scala.Selectable:
+    def selectDynamic(name: String): Any
+
   trait SelectableRecord extends Selectable {
     transparent inline def toTuple: Tuple = ${ toTupleImpl('this)}
   }

tests/run/structural.scala

@@ -24,7 +24,27 @@ object Test {
     def fun9(y: C): y.I
   }
 
-  class FooI {
+  class Foo1 {
+    def sel0: Int = 1
+    def sel1: Int => Int = x => x
+    def fun0(x: Int): Int = x
+
+    def fun1(x: Int)(y: Int): Int = x + y
+    def fun2(x: Int): Int => Int = y => x * y
+    def fun3(a1: Int, a2: Int, a3: Int)
+            (a4: Int, a5: Int, a6: Int)
+            (a7: Int, a8: Int, a9: Int): Int = -1
+
+    def fun4(implicit x: Int): Int = x
+    def fun5(x: Int)(implicit y: Int): Int = x + y
+
+    def fun6(x: C, y: x.S): Int = 1
+    def fun7(x: C, y: x.I): Int = 2
+    def fun8(y: C): y.S = "Hello"
+    def fun9(y: C): y.I = 1.asInstanceOf[y.I]
+  }
+
+  class Foo2 extends scala.Selectable {
     def sel0: Int = 1
     def sel1: Int => Int = x => x
     def fun0(x: Int): Int = x
@@ -83,7 +103,7 @@ object Test {
   }
 
   // Limited support for dependant methods
-  def dependant(x: Foo) = {
+  def dependent(x: Foo) = {
     val y = new D
 
     assert(x.fun6(y, "Hello") == 1)
@@ -97,10 +117,15 @@ object Test {
   }
 
   def main(args: Array[String]): Unit = {
-    basic(new FooI)
-    currying(new FooI)
-    etaExpansion(new FooI)
-    implicits(new FooI)
-    dependant(new FooI)
+    basic(new Foo1)
+    currying(new Foo1)
+    etaExpansion(new Foo1)
+    implicits(new Foo1)
+    dependent(new Foo1)
+    basic(new Foo2)
+    currying(new Foo2)
+    etaExpansion(new Foo2)
+    implicits(new Foo2)
+    dependent(new Foo2)
   }
 }

tests/semanticdb/metac.expect

@@ -144,23 +144,23 @@ Occurrences:
 [24:12..24:12): -> scala/reflect/Selectable.reflectiveSelectable().
 [24:12..24:13): s -> advanced/Test.s.
 [24:14..24:16): s1 -> advanced/Structural#s1().
-[24:16..24:16): -> scala/Selectable#selectDynamic().
+[24:16..24:16): -> scala/reflect/Selectable#selectDynamic().
 [25:6..25:8): s2 <- advanced/Test.s2.
 [25:11..25:12): s -> advanced/Test.s.
 [25:13..25:15): s2 -> advanced/Structural#s2().
 [26:6..26:9): s2x <- advanced/Test.s2x.
 [26:12..26:12): -> scala/reflect/Selectable.reflectiveSelectable().
 [26:12..26:13): s -> advanced/Test.s.
 [26:14..26:16): s2 -> advanced/Structural#s2().
-[26:16..26:16): -> scala/Selectable#selectDynamic().
+[26:16..26:16): -> scala/reflect/Selectable#selectDynamic().
 [27:6..27:8): s3 <- advanced/Test.s3.
 [27:11..27:12): s -> advanced/Test.s.
 [27:13..27:15): s3 -> advanced/Structural#s3().
 [28:6..28:9): s3x <- advanced/Test.s3x.
 [28:12..28:12): -> scala/reflect/Selectable.reflectiveSelectable().
 [28:12..28:13): s -> advanced/Test.s.
 [28:14..28:16): s3 -> advanced/Structural#s3().
-[28:16..28:16): -> scala/Selectable#applyDynamic().
+[28:16..28:16): -> scala/reflect/Selectable#applyDynamic().
 [28:18..28:18): -> scala/reflect/ClassTag.apply().
 [28:19..28:22): ??? -> scala/Predef.`???`().
 [30:6..30:7): e <- advanced/Test.e.