Moved Ambiguous Overload error in Typer to case class

Author: ennru

compiler/src/dotty/tools/dotc/reporting/diagnostic/ErrorMessageID.java

@@ -56,6 +56,7 @@ public enum ErrorMessageID {
     CyclicReferenceInvolvingID,
     CyclicReferenceInvolvingImplicitID,
     SuperQualMustBeParentID,
+    AmbiguousOverloadID,
     ;
 
     public int errorNumber() {

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -18,6 +18,7 @@ import dotc.parsing.Tokens
 import printing.Highlighting._
 import printing.Formatting
 import ErrorMessageID._
+import Denotations.SingleDenotation
 import dotty.tools.dotc.core.SymDenotations.SymDenotation
 
 object messages {
@@ -1223,4 +1224,26 @@ object messages {
            |Attempting to define a field in a method signature after a varargs field is an error.
            |""".stripMargin
   }
+
+  case class AmbiguousOverload(tree: tpd.Tree, alts: List[SingleDenotation], pt: Type)(
+    err: typer.ErrorReporting.Errors)(
+    implicit ctx: Context)
+  extends Message(AmbiguousOverloadID) {
+
+    private def all = if (alts.length == 2) "both" else "all"
+
+    override def msg: String =
+      s"""|Ambiguous overload. The ${err.overloadedAltsStr(alts)}
+          |$all match ${err.expectedTypeStr(pt)}""".stripMargin
+
+    override def kind: String = "Reference"
+
+    override def explanation: String =
+       s"""|There are ${alts.length} methods that could be referenced as the compiler knows too little about the expected type.
+           |You may specify the expected type e.g. by
+           |- assigning it to a value with a specified type, or
+           |- adding a type ascription as in (MyClass.myMethod: String => Int)
+           |""".stripMargin
+  }
+
 }

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

@@ -1799,15 +1799,14 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       typr.println(i"adapt overloaded $ref with alternatives ${altDenots map (_.info)}%, %")
       val alts = altDenots map (alt =>
         TermRef.withSigAndDenot(ref.prefix, ref.name, alt.info.signature, alt))
-      def expectedStr = err.expectedTypeStr(pt)
       resolveOverloaded(alts, pt) match {
         case alt :: Nil =>
           adapt(tree.withType(alt), pt, original)
         case Nil =>
           def noMatches =
             errorTree(tree,
               em"""none of the ${err.overloadedAltsStr(altDenots)}
-                  |match $expectedStr""")
+                  |match ${err.expectedTypeStr(pt)}""")
           def hasEmptyParams(denot: SingleDenotation) = denot.info.paramInfoss == ListOfNil
           pt match {
             case pt: FunProto =>
@@ -1820,10 +1819,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
           }
         case alts =>
           val remainingDenots = alts map (_.denot.asInstanceOf[SingleDenotation])
-          def all = if (remainingDenots.length == 2) "both" else "all"
-          errorTree(tree,
-            em"""Ambiguous overload. The ${err.overloadedAltsStr(remainingDenots)}
-                |$all match $expectedStr""")
+          errorTree(tree, AmbiguousOverload(tree, remainingDenots, pt)(err))
       }
     }
 

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

@@ -4,6 +4,7 @@ package reporting
 
 import core.Contexts.Context
 import diagnostic.messages._
+import dotty.tools.dotc.core.Types.WildcardType
 import dotty.tools.dotc.parsing.Tokens
 import org.junit.Assert._
 import org.junit.{Ignore, Test}
@@ -329,4 +330,31 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         assertEquals("B", qual.show)
         assertEquals("class C", cls.show)
       }
+
+  @Test def ambiugousOverloadWithWildcard =
+    checkMessagesAfter("frontend") {
+      """object Context {
+        |  trait A {
+        |    def foo(s: String): String
+        |    def foo: String = foo("foo")
+        |  }
+        |  object B extends A {
+        |    def foo(s: String): String = s
+        |  }
+        |  B.foo
+        |}
+      """.stripMargin
+    }
+    .expect { (ictx, messages) =>
+      implicit val ctx: Context = ictx
+      val defn = ictx.definitions
+
+      assertMessageCount(1, messages)
+      val AmbiguousOverload(tree, List(alt1, alt2), pt: WildcardType) :: Nil = messages
+      assertEquals("method foo", alt1.show)
+      assertEquals("(s: String)String", alt1.info.show)
+      assertEquals("method foo", alt2.show)
+    }
+
+
 }