Use existing helper functions to deconstruct closures and function calls

Author: allanrenucci

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

@@ -9,6 +9,8 @@ import util.HashSet
 import typer.ConstFold
 import reporting.trace
 
+import scala.annotation.tailrec
+
 trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   import TreeInfo._
 
@@ -512,17 +514,22 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   }
 
   /** Decompose a call fn[targs](vargs_1)...(vargs_n)
-   *  into its constituents (where targs, vargss may be empty)
+   *  into its constituents (fn, targs, vargss).
+   *
+   *  Note: targ and vargss may be empty
    */
-  def decomposeCall(tree: Tree): (Tree, List[Tree], List[List[Tree]]) = tree match {
-    case Apply(fn, args) =>
-      val (meth, targs, argss) = decomposeCall(fn)
-      (meth, targs, argss :+ args)
-    case TypeApply(fn, targs) =>
-      val (meth, targss, args) = decomposeCall(fn)
-      (meth, targs ++ targss, args)
-    case _ =>
-      (tree, Nil, Nil)
+  def decomposeCall(tree: Tree): (Tree, List[Tree], List[List[Tree]]) = {
+    @tailrec
+    def loop(tree: Tree, targss: List[Tree], argss: List[List[Tree]]): (Tree, List[Tree], List[List[Tree]]) =
+      tree match {
+        case Apply(fn, args) =>
+          loop(fn, targss, args :: argss)
+        case TypeApply(fn, targs) =>
+          loop(fn, targs ::: targss, argss)
+        case _ =>
+          (tree, targss, argss)
+      }
+    loop(tree, Nil, Nil)
   }
 
   /** An extractor for closures, either contained in a block or standalone.

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

@@ -707,14 +707,14 @@ trait Implicits { self: Typer =>
           }
           def resolveTypes(targs: List[Tree])(implicit ctx: Context) =
             targs.map(a => fullyDefinedType(a.tpe, "type argument", a.pos))
-          val args = alt.tree match {
-            case TypeApply(_, targs) =>
-              resolveTypes(targs)(ctx.fresh.setTyperState(alt.tstate))
-            case Block(List(DefDef(_, _, _, _, Apply(TypeApply(_, targs), _))), _) =>
-              resolveTypes(targs.asInstanceOf[List[Tree]])(ctx.fresh.setTyperState(alt.tstate))
-            case _ =>
-              Nil
-          }
+
+          // We can extract type arguments from an eta-expanded function:
+          //   @implicitAmbiguous("msg A=${A}")
+          //   implicit def f[A](x: Int): String = ...
+          //   implicitly[Int => String] // found: x => f[Any](x)
+          val call = closureBody(alt.tree) // the tree itself if not a closure
+          val (_, targs, _) = decomposeCall(call)
+          val args = resolveTypes(targs)(ctx.fresh.setTyperState(alt.tstate))
           err.userDefinedErrorString(raw, params, args)
         }
 

compiler/test/dotty/tools/dotc/reporting/UserDefinedErrorMessages.scala

@@ -22,7 +22,6 @@ class UserDefinedErrorMessages extends ErrorMessagesTest {
         |
         |  implicitly[Int =!= Int]
         |}
-
       """.stripMargin
     }.expect { (itcx, messages) =>
       import diagnostic.NoExplanation
@@ -48,7 +47,6 @@ class UserDefinedErrorMessages extends ErrorMessagesTest {
         |
         |  implicitly[Int =!= Int]
         |}
-
       """.stripMargin
     }.expect { (itcx, messages) =>
       import diagnostic.NoExplanation
@@ -75,7 +73,6 @@ class UserDefinedErrorMessages extends ErrorMessagesTest {
         |
         |  implicitly[Int =!= Int]
         |}
-
       """.stripMargin
     }.expect { (itcx, messages) =>
       import diagnostic.NoExplanation
@@ -98,7 +95,29 @@ class UserDefinedErrorMessages extends ErrorMessagesTest {
         |    implicitly[Int => String]
         |  }
         |}
+      """.stripMargin
+    }.expect { (itcx, messages) =>
+      import diagnostic.NoExplanation
+      implicit val ctx: Context = itcx
+
+      assertMessageCount(1, messages)
+      val (m: NoExplanation) :: Nil = messages
 
+      assertEquals(m.msg, "msg A=Any")
+    }
+
+  @Test def userDefinedImplicitAmbiguous5 =
+    checkMessagesAfter("frontend") {
+      """
+        |class C {
+        |  @annotation.implicitAmbiguous("msg A=${A}")
+        |  implicit def f[A](implicit x: String): Int = 1
+        |  implicit def g: Int = 2
+        |  def test: Unit = {
+        |    implicit val s: String = "Hello"
+        |    implicitly[Int]
+        |  }
+        |}
       """.stripMargin
     }.expect { (itcx, messages) =>
       import diagnostic.NoExplanation