Store cycleSym in all relevant errors

Tests pass, and have the correct expectations both for `tree.name` and
`cycleSym.name`, tho right now `tree.name` (what is shown) is less accurate.

Author: Blaisorblade

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

@@ -112,11 +112,11 @@ class CyclicReference private (val denot: SymDenotation, var inImplicitSearch: B
         cx.tree match {
           case tree: untpd.ValOrDefDef if inImplicitSearch && !tree.tpt.typeOpt.exists =>
             // Can happen in implicit defs (#4709) or outside (#3253).
-            TermMemberNeedsNeedsResultTypeForImplicitSearch(cycleSym)
+            TermMemberNeedsNeedsResultTypeForImplicitSearch(tree.name, cycleSym)
           case tree: untpd.DefDef if !tree.tpt.typeOpt.exists =>
-            OverloadedOrRecursiveMethodNeedsResultType(tree.name)
+            OverloadedOrRecursiveMethodNeedsResultType(tree.name, cycleSym)
           case tree: untpd.ValDef if !tree.tpt.typeOpt.exists =>
-            RecursiveValueNeedsResultType(tree.name)
+            RecursiveValueNeedsResultType(tree.name, cycleSym)
           case _ =>
             errorMsg(cx.outer)
         }

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

@@ -1260,27 +1260,27 @@ object messages {
            |""".stripMargin
   }
 
-  case class OverloadedOrRecursiveMethodNeedsResultType(method: Names.Name)(implicit ctx: Context)
+  case class OverloadedOrRecursiveMethodNeedsResultType(methodName: Names.TermName, cycleSym: Symbol)(implicit ctx: Context)
   extends Message(OverloadedOrRecursiveMethodNeedsResultTypeID) {
     val kind = "Syntax"
-    val msg = hl"""overloaded or recursive method ${method} needs return type"""
+    val msg = hl"""overloaded or recursive method ${methodName} needs return type"""
     val explanation =
-      hl"""Case 1: ${method} is overloaded
-          |If there are multiple methods named `${method}` and at least one definition of
+      hl"""Case 1: ${methodName} is overloaded
+          |If there are multiple methods named `${methodName}` and at least one definition of
           |it calls another, you need to specify the calling method's return type.
           |
-          |Case 2: ${method} is recursive
-          |If `${method}` calls itself on any path (even through mutual recursion), you need to specify the return type
-          |of `${method}` or of a definition it's mutually recursive with.
+          |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.
           |""".stripMargin
   }
 
-  case class RecursiveValueNeedsResultType(value: Names.TermName)(implicit ctx: Context)
+  case class RecursiveValueNeedsResultType(valName: Names.TermName, cycleSym: Symbol)(implicit ctx: Context)
   extends Message(RecursiveValueNeedsResultTypeID) {
     val kind = "Syntax"
-    val msg = hl"""recursive value ${value} needs type"""
+    val msg = hl"""recursive value ${valName} needs type"""
     val explanation =
-      hl"""The definition of `${value}` is recursive and you need to specify its type.
+      hl"""The definition of `${valName}` is recursive and you need to specify its type.
           |""".stripMargin
   }
 
@@ -2111,7 +2111,7 @@ object messages {
   }
 
   // Relative of CyclicReferenceInvolvingImplicit and RecursiveValueNeedsResultType
-  case class TermMemberNeedsNeedsResultTypeForImplicitSearch(cycleSym: Symbol)(implicit ctx: Context)
+  case class TermMemberNeedsNeedsResultTypeForImplicitSearch(memberName: Names.TermName, cycleSym: Symbol)(implicit ctx: Context)
     extends Message(TermMemberNeedsNeedsResultTypeForImplicitSearchID) {
     val kind = "Syntax"
     val msg = hl"""$cycleSym needs result type because its right-hand side attempts implicit search"""

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

@@ -207,8 +207,9 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       implicit val ctx: Context = ictx
 
       assertMessageCount(1, messages)
-      val OverloadedOrRecursiveMethodNeedsResultType(tree) :: Nil = messages
-      assertEquals("foo", tree.show)
+      val OverloadedOrRecursiveMethodNeedsResultType(methodName, cycleSym) :: Nil = messages
+      assertEquals("foo", methodName.show)
+      assertEquals("foo", cycleSym.name.show)
     }
 
   @Test def recursiveMethodNeedsReturnType =
@@ -223,8 +224,9 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       implicit val ctx: Context = ictx
 
       assertMessageCount(1, messages)
-      val OverloadedOrRecursiveMethodNeedsResultType(tree) :: Nil = messages
-      assertEquals("i", tree.show)
+      val OverloadedOrRecursiveMethodNeedsResultType(methodName, cycleSym) :: Nil = messages
+      assertEquals("i", methodName.show)
+      assertEquals("i", cycleSym.name.show)
     }
 
   @Test def recursiveValueNeedsReturnType =
@@ -239,8 +241,9 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       implicit val ctx: Context = ictx
 
       assertMessageCount(1, messages)
-      val RecursiveValueNeedsResultType(tree) :: Nil = messages
-      assertEquals("i", tree.show)
+      val RecursiveValueNeedsResultType(valName, cycleSym) :: Nil = messages
+      assertEquals("i", valName.show)
+      assertEquals("i", cycleSym.name.show)
     }
 
   @Test def cyclicReferenceInvolving =
@@ -290,8 +293,9 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         implicit val ctx: Context = ictx
 
         assertMessageCount(1, messages)
-        val OverloadedOrRecursiveMethodNeedsResultType(name) :: Nil = messages
-        assertEquals("even", name.show)
+        val OverloadedOrRecursiveMethodNeedsResultType(methodName, cycleSym) :: Nil = messages
+        assertEquals("even", methodName.show)
+        assertEquals("odd", cycleSym.name.show)
       }
 
   @Test def mutualRecursion_i2001a =
@@ -312,9 +316,10 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         implicit val ctx: Context = ictx
 
         assertMessageCount(1, messages)
-        val OverloadedOrRecursiveMethodNeedsResultType(denot) :: Nil = messages
+        val OverloadedOrRecursiveMethodNeedsResultType(methodName, cycleSym) :: Nil = messages
         // Not ideal behavior
-        assertEquals("foo", denot.show)
+        assertEquals("foo", methodName.show)
+        assertEquals("odd", cycleSym.name.show)
       }
 
 
@@ -334,8 +339,9 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       implicit val ctx: Context = ictx
 
       assertMessageCount(1, messages)
-      val TermMemberNeedsNeedsResultTypeForImplicitSearch(tree) :: Nil = messages
-      assertEquals("x", tree.name.show)
+      val TermMemberNeedsNeedsResultTypeForImplicitSearch(memberName, cycleSym) :: Nil = messages
+      assertEquals("x", cycleSym.name.show)
+      assertEquals("x", memberName.show)
     }
 
   @Test def implicitSearchForcesImplicitRetType_i4709 =
@@ -359,8 +365,9 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       implicit val ctx: Context = ictx
 
       assertMessageCount(1, messages)
-      val TermMemberNeedsNeedsResultTypeForImplicitSearch(tree) :: Nil = messages
-      assertEquals("ctx", tree.name.show)
+      val TermMemberNeedsNeedsResultTypeForImplicitSearch(memberName, cycleSym) :: Nil = messages
+      assertEquals("ctx", memberName.show)
+      assertEquals("ctx", cycleSym.name.show)
     }
 
   @Test def implicitSearchForcesNonImplicitRetTypeOnExplicitImport_i3253 =
@@ -377,8 +384,9 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         implicit val ctx: Context = ictx
 
         assertMessageCount(1, messages)
-        val TermMemberNeedsNeedsResultTypeForImplicitSearch(tree) :: Nil = messages
-        assertEquals("test", tree.name.show)
+        val TermMemberNeedsNeedsResultTypeForImplicitSearch(memberName, cycleSym) :: Nil = messages
+        assertEquals("test", memberName.show)
+        assertEquals("test", cycleSym.name.show)
       }
 
   @Test def superQualMustBeParent =