fix #3797 Add support for @implicitAmbiguous

Author: Jasper-M

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

@@ -670,6 +670,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

@@ -159,11 +159,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._
@@ -696,22 +697,44 @@ 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 lambda: TypeLambda => lambda.typeParams.map(_.paramName.unexpandedName.toString)
+            case _                  => Nil
           }
-          yield {
-            err.implicitNotFoundString(
-              raw,
-              pt.typeSymbol.typeParams.map(_.name.unexpandedName.toString),
-              pt.argInfos)
+          alt.tstate.commit()
+          val args = alt.tree match {
+            case TypeApply(_, targs) if params.nonEmpty =>
+              targs.map(a => fullyDefinedType(a.typeOpt, "type parameter", a.pos))
+            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")}"))()
     }
   }