Mention cycleSym instead of tree.name in errors

At this point, I can stop using tree.name altogether.

Author: Blaisorblade

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

@@ -101,6 +101,10 @@ object handleRecursive {
 class CyclicReference private (val denot: SymDenotation, var inImplicitSearch: Boolean = false) extends TypeError {
   override def toMessage(implicit ctx: Context): Message = {
     val cycleSym = denot.symbol
+    val unsafeFlags = cycleSym.flagsUNSAFE
+    val isMethod = unsafeFlags.is(Method)
+    val isVal = !isMethod && cycleSym.isTerm
+    val isImplicit = unsafeFlags.is(Implicit)
 
     /* This CyclicReference might have arisen from asking for `m`'s type while trying to infer it.
      * To try to diagnose this, walk the context chain searching for context in
@@ -110,13 +114,15 @@ class CyclicReference private (val denot: SymDenotation, var inImplicitSearch: B
     def errorMsg(cx: Context): Message = {
       if (cx.mode is Mode.InferringReturnType) {
         cx.tree match {
-          case tree: untpd.ValOrDefDef if inImplicitSearch && !tree.tpt.typeOpt.exists =>
-            // Can happen in implicit defs (#4709) or outside (#3253).
-            TermMemberNeedsNeedsResultTypeForImplicitSearch(tree.name, cycleSym)
-          case tree: untpd.DefDef if !tree.tpt.typeOpt.exists =>
-            OverloadedOrRecursiveMethodNeedsResultType(tree.name, cycleSym)
-          case tree: untpd.ValDef if !tree.tpt.typeOpt.exists =>
-            RecursiveValueNeedsResultType(tree.name, cycleSym)
+          case tree: untpd.ValOrDefDef if !tree.tpt.typeOpt.exists =>
+            if (inImplicitSearch)
+              TermMemberNeedsNeedsResultTypeForImplicitSearch(tree.name, cycleSym)
+            else if (isMethod)
+              OverloadedOrRecursiveMethodNeedsResultType(tree.name, cycleSym)
+            else if (isVal)
+              RecursiveValueNeedsResultType(tree.name, cycleSym)
+            else
+              errorMsg(cx.outer)
           case _ =>
             errorMsg(cx.outer)
         }

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

@@ -1263,24 +1263,24 @@ object messages {
   case class OverloadedOrRecursiveMethodNeedsResultType(methodName: Names.TermName, cycleSym: Symbol)(implicit ctx: Context)
   extends Message(OverloadedOrRecursiveMethodNeedsResultTypeID) {
     val kind = "Syntax"
-    val msg = hl"""overloaded or recursive method ${methodName} needs return type"""
+    val msg = hl"""overloaded or recursive ${cycleSym} needs return type"""
     val explanation =
-      hl"""Case 1: ${methodName} is overloaded
-          |If there are multiple methods named `${methodName}` and at least one definition of
+      hl"""Case 1: ${cycleSym} is overloaded
+          |If there are multiple methods named `${cycleSym}` and at least one definition of
           |it calls another, you need to specify the calling method's return type.
           |
-          |Case 2: ${methodName} is recursive
-          |If `${methodName}` calls itself on any path (even through mutual recursion), you need to specify the return type
-          |of `${methodName}` or of a definition it's mutually recursive with.
+          |Case 2: ${cycleSym} is recursive
+          |If `${cycleSym}` calls itself on any path (even through mutual recursion), you need to specify the return type
+          |of `${cycleSym}` or of a definition it's mutually recursive with.
           |""".stripMargin
   }
 
   case class RecursiveValueNeedsResultType(valName: Names.TermName, cycleSym: Symbol)(implicit ctx: Context)
   extends Message(RecursiveValueNeedsResultTypeID) {
     val kind = "Syntax"
-    val msg = hl"""recursive value ${valName} needs type"""
+    val msg = hl"""recursive ${cycleSym} needs type"""
     val explanation =
-      hl"""The definition of `${valName}` is recursive and you need to specify its type.
+      hl"""The definition of `${cycleSym}` is recursive and you need to specify its type.
           |""".stripMargin
   }
 
@@ -2117,7 +2117,7 @@ object messages {
     val msg = hl"""$cycleSym needs result type because its right-hand side attempts implicit search"""
     val explanation =
       hl"""|The right hand-side of $cycleSym's definition requires an implicit search at the highlighted position.
-           |To avoid this error, give `${cycleSym.name}` an explicit type.
+           |To avoid this error, give `$cycleSym` an explicit type.
            |""".stripMargin
   }
 }

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

@@ -246,6 +246,24 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       assertEquals("i", cycleSym.name.show)
     }
 
+  @Test def recursiveValueNeedsReturnType2 =
+    checkMessagesAfter(FrontEnd.name) {
+      """
+        |class Scope() {
+        |  lazy val i = j + 5
+        |  lazy val j = i
+        |}
+      """.stripMargin
+    }
+      .expect { (ictx, messages) =>
+        implicit val ctx: Context = ictx
+
+        assertMessageCount(1, messages)
+        val RecursiveValueNeedsResultType(valName, cycleSym) :: Nil = messages
+        assertEquals("j", valName.show)
+        assertEquals("i", cycleSym.name.show)
+      }
+
   @Test def cyclicReferenceInvolving =
     checkMessagesAfter(FrontEnd.name) {
       """
@@ -322,6 +340,29 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         assertEquals("odd", cycleSym.name.show)
       }
 
+  @Test def mutualRecursion_i2001b =
+    checkMessagesAfter(FrontEnd.name) {
+      """
+        |class A {
+        |  def odd(x: Int) = if (x == 0) false else !even(x-1)
+        |  def even(x: Int) = {
+        |    val foo = {
+        |      if (x == 0) true else !odd(x-1) // error: overloaded or recursive method needs result type
+        |    }
+        |    false
+        |  }
+        |}
+      """.stripMargin
+    }
+      .expect { (ictx, messages) =>
+        implicit val ctx: Context = ictx
+
+        assertMessageCount(1, messages)
+        val OverloadedOrRecursiveMethodNeedsResultType(methodName, cycleSym) :: Nil = messages
+        // Not ideal behavior
+        assertEquals("foo", methodName.show)
+        assertEquals("odd", cycleSym.name.show)
+      }
 
   @Test def termMemberNeedsNeedsResultTypeForImplicitSearch =
     checkMessagesAfter(FrontEnd.name) {

tests/neg/i2001b.scala

@@ -0,0 +1,9 @@
+class A {
+  def odd(x: Int) = if (x == 0) false else !even(x-1)
+  def even(x: Int) = {
+    val foo = {
+      if (x == 0) true else !odd(x-1) // error: overloaded or recursive method needs result type
+    }
+    false
+  }
+}