Change 'overloaded/recursive method/value needs type' to Message (see scala#2026)

Author: ennru

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

@@ -51,6 +51,9 @@ public enum ErrorMessageID {
     ExpectedTokenButFoundID,
     MixedLeftAndRightAssociativeOpsID,
     CantInstantiateAbstractClassOrTraitID,
+    OverloadedOrRecursiveMethodNeedsResultTypeID,
+    RecursiveValueNeedsResultTypeID,
+    CyclicReferenceInvolvingImplicitID,
     ;
 
     public int errorNumber() {

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

@@ -1146,4 +1146,32 @@ object messages {
            |""".stripMargin
   }
 
+  case class OverloadedOrRecursiveMethodNeedsResultType(tree: Names.TermName)(implicit ctx: Context)
+  extends Message(OverloadedOrRecursiveMethodNeedsResultTypeID) {
+    val kind = "Syntax"
+    val msg = hl"""overloaded or recursive method ${tree} needs result type"""
+    val explanation =
+      hl"""""".stripMargin
+  }
+
+  case class RecursiveValueNeedsResultType(tree: Names.TermName)(implicit ctx: Context)
+    extends Message(RecursiveValueNeedsResultTypeID) {
+    val kind = "Syntax"
+    val msg = hl"""recursive value ${tree.name} needs type"""
+    val explanation =
+      hl"""""".stripMargin
+  }
+
+  case class CyclicReferenceInvolvingImplicit(cycleSym: Symbol)(implicit ctx: Context)
+    extends Message(CyclicReferenceInvolvingImplicitID) {
+    val kind = "Syntax"
+    val msg = hl"""cyclic reference involving implicit $cycleSym"""
+    val explanation =
+      hl"""|This happens when the right hand-side of $cycleSym's definition involves an implicit search.
+           |To avoid the error, give $cycleSym an explicit type.
+           |""".stripMargin
+  }
+
+
+
 }

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

@@ -28,22 +28,20 @@ object ErrorReporting {
 
   def cyclicErrorMsg(ex: CyclicReference)(implicit ctx: Context) = {
     val cycleSym = ex.denot.symbol
-    def errorMsg(msg: String, cx: Context): String =
+    def errorMsg(msg: String, cx: Context): Message =
       if (cx.mode is Mode.InferringReturnType) {
         cx.tree match {
           case tree: untpd.DefDef if !tree.tpt.typeOpt.exists =>
-            em"overloaded or recursive method ${tree.name} needs result type"
+            OverloadedOrRecursiveMethodNeedsResultType(tree.name)
           case tree: untpd.ValDef if !tree.tpt.typeOpt.exists =>
-            em"recursive value ${tree.name} needs type"
+            RecursiveValueNeedsResultType(tree.name)
           case _ =>
             errorMsg(msg, cx.outer)
         }
       } else msg
 
     if (cycleSym.is(Implicit, butNot = Method) && cycleSym.owner.isTerm)
-      em"""cyclic reference involving implicit $cycleSym
-            |This happens when the right hand-side of $cycleSym's definition involves an implicit search.
-            |To avoid the error, give $cycleSym an explicit type."""
+      CyclicReferenceInvolvingImplicit(cycleSym)
     else
       errorMsg(ex.show, ctx)
   }

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

@@ -198,4 +198,23 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       assertTrue("expected trait", isTrait)
     }
 
+  @Test def cantInstantiateTrait =
+    checkMessagesAfter("refchecks") {
+      """
+        |object Scope {
+        |  trait Concept
+        |  new Concept()
+        |}
+      """.stripMargin
+    }
+    .expect { (ictx, messages) =>
+      implicit val ctx: Context = ictx
+      val defn = ictx.definitions
+
+      assertMessageCount(1, messages)
+      val CantInstantiateAbstractClassOrTrait(cls, isTrait) :: Nil = messages
+      assertEquals("Concept", cls.name.show)
+      assertTrue("expected trait", isTrait)
+    }
+
 }