Handle structural types with curried methods

We desugar `x.foo(a1)(a2)` (where the type of `x` is a structural type)
to:

```scala
(x:selectable).applyDynamic("a", CTa1, CTa2)(a1, a2)
```

Author: allanrenucci

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -737,22 +737,11 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     case _ => This(ctx.owner.enclosingClass.asClass)
   }
 
-  /** Is this an application on a structural selection?
-   *
-   *  @see isStructuralTermSelect
-   */
-  def isStructuralTermApply(tree: Tree)(implicit ctx: Context): Boolean = tree match {
-    case Apply(fun, _) =>
-      isStructuralTermSelect(fun)
-    case _ =>
-      false
-  }
-
-  /** Is this a selection of a member of a structural type that is not a member
-   *  of an underlying class or trait?
+  /** Is this an application of a selection of a member of a structural type
+   *  that is not a member of an underlying class or trait?
    */
-  def isStructuralTermSelect(tree: Tree)(implicit ctx: Context): Boolean = tree match {
-    case tree: Select =>
+  def isStructuralTermSelectOrApply(tree: Tree)(implicit ctx: Context): Boolean = {
+    def isStructuralTermSelect(tree: Select) = {
       def hasRefinement(qualtpe: Type): Boolean = qualtpe.dealias match {
         case RefinedType(parent, rname, rinfo) =>
           rname == tree.name || hasRefinement(parent)
@@ -766,8 +755,16 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
           false
       }
       !tree.symbol.exists && tree.isTerm && hasRefinement(tree.qualifier.tpe)
-    case _ =>
-      false
+    }
+    def loop(tree: Tree): Boolean = tree match {
+      case Apply(fun, _) =>
+        loop(fun)
+      case tree: Select =>
+        isStructuralTermSelect(tree)
+      case _ =>
+        false
+    }
+    loop(tree)
   }
 
   /** Is this call a call to a method that is marked as Inline */

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

@@ -117,61 +117,64 @@ trait Dynamic { self: Typer with Applications =>
    *  Given `x.a`, where `x` is of (widened) type `T` (a value type or a nullary method type),
    *  and `x.a` is of type `U`, map `x.a` to the equivalent of:
    *
-   *    (x: Selectable).selectDynamic("a").asInstanceOf[U]
+   *  ```scala
+   *  (x: Selectable).selectDynamic("a").asInstanceOf[U]
+   *  ```
    *
-   *  Given `x.a(arg1, ..., argn)`, where `x.a` is of (widened) type (T1, ..., Tn)R,
-   *  map `x.a(arg1, ..., argn)` to the equivalent of:
+   *  Given `x.a(a11, ..., a1n)...(aN1, ..., aNn)`, where `x.a` is of (widened) type
+   *  `(T11, ..., T1n)...(TN1, ..., TNn) => R`, it is desugared to:
    *
-   *    (x:selectable).applyDynamic("a", CT1, ..., CTn)(arg1, ..., argn).asInstanceOf[R]
+   *  ```scala
+   *  (x:selectable).applyDynamic("a", CT11, ..., CT1n, ..., CTN1, ... CTNn)
+   *                             (a11, ..., a1n, ..., aN1, ..., aNn)
+   *                .asInstanceOf[R]
+   *  ```
    *
-   *  where CT1, ..., CTn are the class tags representing the erasure of T1, ..., Tn.
+   *  where CT11, ..., CTNn are the class tags representing the erasure of T11, ..., TNn.
    *
    *  It's an error if U is neither a value nor a method type, or a dependent method
    *  type.
    */
   def handleStructural(tree: Tree)(implicit ctx: Context): Tree = {
+    val (fun @ Select(qual, name), targs, vargss) = decomposeCall(tree)
 
-    def structuralCall(qual: Tree, name: Name, selectorName: TermName, ctags: List[Tree], args: Option[List[Tree]]) = {
+    def structuralCall(selectorName: TermName, ctags: List[Tree]) = {
       val selectable = adapt(qual, defn.SelectableType)
 
       // ($qual: Selectable).$selectorName("$name", ..$ctags)
       val base =
         untpd.Apply(
-          untpd.TypedSplice(selectable.select(selectorName)).withPos(tree.pos),
+          untpd.TypedSplice(selectable.select(selectorName)).withPos(fun.pos),
           (Literal(Constant(name.toString)) :: ctags).map(untpd.TypedSplice(_)))
 
-      val scall = args match {
-        case None => base
-        case Some(args) => untpd.Apply(base, args)
-      }
+      val scall =
+        if (vargss.isEmpty) base
+        else untpd.Apply(base, vargss.flatten)
 
       typed(scall)
     }
 
     def fail(name: Name, reason: String) =
       errorTree(tree, em"Structural access not allowed on method $name because it $reason")
 
-    val tpe = tree.tpe.widen
-    tree match {
-      case Apply(fun @ Select(qual, name), args) =>
-        val funTpe = fun.tpe.widen.asInstanceOf[MethodType]
-        if (funTpe.isParamDependent)
+    fun.tpe.widen match {
+      case tpe: ValueType =>
+        structuralCall(nme.selectDynamic, Nil).asInstance(tpe)
+
+      case tpe: MethodType =>
+        if (tpe.isParamDependent)
           fail(name, i"has a method type with inter-parameter dependencies")
         else {
-          val ctags = funTpe.paramInfos.map(pt =>
-            implicitArgTree(defn.ClassTagType.appliedTo(pt :: Nil), tree.pos.endPos))
-          structuralCall(qual, name, nme.applyDynamic, ctags, Some(args)).asInstance(tpe.resultType)
+          val ctags = tpe.paramInfoss.flatten.map(pt =>
+            implicitArgTree(defn.ClassTagType.appliedTo(pt :: Nil), fun.pos.endPos))
+          structuralCall(nme.applyDynamic, ctags).asInstance(tpe.finalResultType)
         }
-      case Select(qual, name) if tpe.isValueType =>
-        structuralCall(qual, name, nme.selectDynamic, Nil, None).asInstance(tpe)
-      case Select(_, _) if !tpe.isParameterless =>
-        // We return the tree unchanged; The structural call will be handled when we take care of the
-        // enclosing application.
-        tree
-      case Select(_, name) if tpe.isInstanceOf[PolyType] =>
+
+      // (@allanrenucci) I think everything below is dead code
+      case _: PolyType =>
         fail(name, "is polymorphic")
-      case Select(_, name) =>
-        fail(name, i"has an unsupported type: ${tree.tpe.widen}")
+      case tpe =>
+        fail(name, i"has an unsupported type: $tpe")
     }
   }
 }

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

@@ -2640,9 +2640,8 @@ class Typer extends Namer
             convertNewGenericArray(readapt(tree.appliedToTypeTrees(typeArgs)))
           }
         case wtp =>
-          if (isStructuralTermApply(tree))
-            readaptSimplified(handleStructural(tree))
-          else if (isStructuralTermSelect(tree) && tree.tpe.widen.isValueType)
+          val isStructuralCall = wtp.isValueType && isStructuralTermSelectOrApply(tree)
+          if (isStructuralCall)
             readaptSimplified(handleStructural(tree))
           else pt match {
             case pt: FunProto =>

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

@@ -47,17 +47,19 @@ consider three distinct cases:
   (v: Selectable).selectDynamic("a").asInstanceOf[U]
   ```
 
-- If `U` is a method type `(T1, ..., Tn) => R` with at most 7
-  parameters and it is not a dependent method type, we map `v.a` to
+- 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
   the  equivalent of:
   ```scala
   v.a(arg1, ..., argn)
      --->
-  (v: Selectable).applyDynamic("a", CT1, ..., CTn)(arg1, ..., argn).asInstanceOf[R]
+  (v: Selectable).applyDynamic("a", CT11, ..., CTn, ..., CTN1, ... CTNn)
+                              (a11, ..., a1n, ..., aN1, ..., aNn)
+                 .asInstanceOf[R]
   ```
 
 - If `U` is neither a value nor a method type, or a dependent method
-  type, or has more than 7 parameters, an error is emitted.
+  type, an error is emitted.
 
 We make sure that `r` conforms to type `Selectable`, potentially by
 introducing an implicit conversion, and then call either

library/src/scala/reflect/Selectable.scala

@@ -19,7 +19,7 @@ class Selectable(val receiver: Any) extends AnyVal with scala.Selectable {
     val paramClasses = paramTypes.map(_.runtimeClass)
     val mth = rcls.getMethod(name, paramClasses: _*)
     ensureAccessible(mth)
-    mth.invoke(receiver, args.map(_.asInstanceOf[AnyRef]): _*)
+    mth.invoke(receiver, args.asInstanceOf[Seq[AnyRef]]: _*)
   }
 }
 

tests/run/structural.scala

@@ -0,0 +1,46 @@
+import scala.reflect.Selectable.reflectiveSelectable
+
+object Test {
+  type Foo = {
+    def foo(x: Int)(y: Int): Int
+    def bar(x: Int): Int => Int
+    def bat(a1: Int, a2: Int, a3: Int)
+           (a4: Int, a5: Int, a6: Int)
+           (a7: Int, a8: Int, a9: Int): Int
+   def baz(x: Int): Int
+  }
+
+  class FooI {
+    def foo(x: Int)(y: Int): Int = x + y
+    def bar(x: Int): Int => Int = y => x * y
+    def bat(a1: Int, a2: Int, a3: Int)
+           (a4: Int, a5: Int, a6: Int)
+           (a7: Int, a8: Int, a9: Int): Int = -1
+    def baz(x: Int): Int = x
+  }
+
+  def test(x: Foo): Unit = {
+    assert(x.foo(1)(2) == 3)
+    assert(x.bar(1)(2) == 2)
+    assert(x.bat(1, 2, 3)(4, 5, 6)(7, 8, 9) == -1)
+
+    val f1 = x.foo(1)(_)
+    assert(f1(2) == 3)
+
+    val f2 = x.foo(1) _
+    assert(f2(2) == 3)
+
+    val f3 = x.foo(1)
+    assert(f3(2) == 3)
+
+    val f4 = x.baz
+    assert(f4(1) == 1)
+
+    val f5 = x.baz _
+    assert(f5(2) == 2)
+  }
+
+  def main(args: Array[String]): Unit = {
+    test(new FooI)
+  }
+}