fix #3797 Add support for @implicitAmbiguous

Author: Jasper-M

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

@@ -679,6 +679,8 @@ class Definitions {
   def ContravariantBetweenAnnot(implicit ctx: Context) = ContravariantBetweenAnnotType.symbol.asClass
   lazy val DeprecatedAnnotType = ctx.requiredClassRef("scala.deprecated")
   def DeprecatedAnnot(implicit ctx: Context) = DeprecatedAnnotType.symbol.asClass
+  lazy val ImplicitAmbiguousAnnotType = ctx.requiredClassRef("scala.annotation.implicitAmbiguous")
+  def ImplicitAmbiguousAnnot(implicit ctx: Context) = ImplicitAmbiguousAnnotType.symbol.asClass
   lazy val ImplicitNotFoundAnnotType = ctx.requiredClassRef("scala.annotation.implicitNotFound")
   def ImplicitNotFoundAnnot(implicit ctx: Context) = ImplicitNotFoundAnnotType.symbol.asClass
   lazy val InlineAnnotType = ctx.requiredClassRef("scala.inline")

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

@@ -160,11 +160,11 @@ object ErrorReporting {
       TypeMismatch(found2, expected2, whyNoMatchStr(found, expected), postScript)
     }
 
-    /** Format `raw` implicitNotFound argument, replacing all
-     *  occurrences of `${X}` where `X` is in `paramNames` with the
+    /** Format `raw` implicitNotFound or implicitAmbiguous argument, replacing
+     *  all occurrences of `${X}` where `X` is in `paramNames` with the
      *  corresponding shown type in `args`.
      */
-    def implicitNotFoundString(raw: String, paramNames: List[String], args: List[Type]): String = {
+    def userDefinedErrorString(raw: String, paramNames: List[String], args: List[Type]): String = {
       def translate(name: String): Option[String] = {
         val idx = paramNames.indexOf(name)
         if (idx >= 0) Some(quoteReplacement(ex"${args(idx)}")) else None

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

@@ -26,6 +26,7 @@ import Constants._
 import Applications._
 import ProtoTypes._
 import ErrorReporting._
+import Annotations.Annotation
 import reporting.diagnostic.{Message, MessageContainer}
 import Inferencing.fullyDefinedType
 import Trees._
@@ -685,22 +686,47 @@ trait Implicits { self: Typer =>
         }
     }
     def location(preposition: String) = if (where.isEmpty) "" else s" $preposition $where"
+    def userDefinedMessage(annot: Annotation, params: List[String], args: List[Type]): Option[String] =
+      for (Trees.Literal(Constant(raw: String)) <- annot.argument(0)) yield {
+        err.userDefinedErrorString(
+          raw,
+          params,
+          args)
+      }
     arg.tpe match {
       case ambi: AmbiguousImplicits =>
-        msg(s"ambiguous implicit arguments: ${ambi.explanation}${location("of")}")(
-            s"ambiguous implicit arguments of type ${pt.show} found${location("for")}")
-      case _ =>
-        val userDefined =
-          for {
-            notFound <- pt.typeSymbol.getAnnotation(defn.ImplicitNotFoundAnnot)
-            Trees.Literal(Constant(raw: String)) <- notFound.argument(0)
+        val maybeAnnot = ambi.alt1.ref.symbol.getAnnotation(defn.ImplicitAmbiguousAnnot).map(
+          (_, ambi.alt1)
+        ).orElse(
+          ambi.alt2.ref.symbol.getAnnotation(defn.ImplicitAmbiguousAnnot).map(
+            (_, ambi.alt2)
+          )
+        )
+        val userDefined = maybeAnnot.flatMap { case (annot, alt) =>
+          val params = alt.ref.underlying match {
+            case p: PolyType => p.paramNames.map(_.toString)
+            case _           => Nil
           }
-          yield {
-            err.implicitNotFoundString(
-              raw,
-              pt.typeSymbol.typeParams.map(_.name.unexpandedName.toString),
-              pt.argInfos)
+          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
           }
+          userDefinedMessage(annot, params, args)
+        }
+        userDefined.map(msg(_)()).getOrElse(
+          msg(s"ambiguous implicit arguments: ${ambi.explanation}${location("of")}")(
+              s"ambiguous implicit arguments of type ${pt.show} found${location("for")}")
+        )
+      case _ =>
+        val userDefined = pt.typeSymbol.getAnnotation(defn.ImplicitNotFoundAnnot).flatMap(
+          userDefinedMessage(_, pt.typeSymbol.typeParams.map(_.name.unexpandedName.toString), pt.argInfos)
+        )
         msg(userDefined.getOrElse(em"no implicit argument of type $pt was found${location("for")}"))()
     }
   }

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

@@ -1306,4 +1306,106 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       val DoubleDeclaration(symbol, previousSymbol) :: Nil = messages
       assertEquals(symbol.name.mangledString, "a")
   }
+
+  @Test def userDefinedImplicitAmbiguous1 =
+    checkMessagesAfter("frontend") {
+      """
+        |object Test {
+        |  trait =!=[C, D]
+        |
+        |  implicit def neq[E, F] : E =!= F = null
+        |
+        |  @annotation.implicitAmbiguous("Could not prove ${J} =!= ${J}")
+        |  implicit def neqAmbig1[G, H, J] : J =!= J = null
+        |  implicit def neqAmbig2[I] : I =!= I = null
+        |
+        |  implicitly[Int =!= Int]
+        |}
+
+      """.stripMargin
+    }.expect { (itcx, messages) =>
+      import diagnostic.NoExplanation
+      implicit val ctx: Context = itcx
+
+      assertMessageCount(1, messages)
+      val (m: NoExplanation) :: Nil = messages
+
+      assertEquals(m.msg, "Could not prove Int =!= Int")
+    }
+
+  @Test def userDefinedImplicitAmbiguous2 =
+    checkMessagesAfter("frontend") {
+      """
+        |object Test {
+        |  trait =!=[C, D]
+        |
+        |  implicit def neq[E, F] : E =!= F = null
+        |
+        |  implicit def neqAmbig1[G, H, J] : J =!= J = null
+        |  @annotation.implicitAmbiguous("Could not prove ${I} =!= ${I}")
+        |  implicit def neqAmbig2[I] : I =!= I = null
+        |
+        |  implicitly[Int =!= Int]
+        |}
+
+      """.stripMargin
+    }.expect { (itcx, messages) =>
+      import diagnostic.NoExplanation
+      implicit val ctx: Context = itcx
+
+      assertMessageCount(1, messages)
+      val (m: NoExplanation) :: Nil = messages
+
+      assertEquals(m.msg, "Could not prove Int =!= Int")
+    }
+
+  @Test def userDefinedImplicitAmbiguous3 =
+    checkMessagesAfter("frontend") {
+      """
+        |object Test {
+        |  trait =!=[C, D]
+        |
+        |  implicit def neq[E, F] : E =!= F = null
+        |
+        |  @annotation.implicitAmbiguous("Could not prove ${J} =!= ${J}")
+        |  implicit def neqAmbig1[G, H, J] : J =!= J = null
+        |  @annotation.implicitAmbiguous("Could not prove ${I} =!= ${I}")
+        |  implicit def neqAmbig2[I] : I =!= I = null
+        |
+        |  implicitly[Int =!= Int]
+        |}
+
+      """.stripMargin
+    }.expect { (itcx, messages) =>
+      import diagnostic.NoExplanation
+      implicit val ctx: Context = itcx
+
+      assertMessageCount(1, messages)
+      val (m: NoExplanation) :: Nil = messages
+
+      assertEquals(m.msg, "Could not prove Int =!= Int")
+    }
+
+  @Test def userDefinedImplicitAmbiguous4 =
+    checkMessagesAfter("frontend") {
+      """
+        |class C {
+        |  @annotation.implicitAmbiguous("msg A=${A}")
+        |  implicit def f[A](x: Int): String = "f was here"
+        |  implicit def g(x: Int): String = "f was here"
+        |  def test: Unit = {
+        |    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")
+    }
 }