Fix scala#4709: report if local implicits need type annotation

This improves the error message, and also puts more effort into diagnosing the
cycle.

Now we use the same logic as for recursive values to check we're indeed dealing
with a (potentially) recursive implicit.

Remaining `CyclicReferenceInvolvingImplicit` are unexpected and might involve
bugs, so make the error message and explanation more tentative, following
`CyclicReferenceInvolving`.

Author: Blaisorblade

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

@@ -102,24 +102,31 @@ class CyclicReference private (val denot: SymDenotation) extends TypeError {
 
   override def toMessage(implicit ctx: Context) = {
 
-    def errorMsg(cx: Context): Message =
+    def errorMsg(cycleSym: Symbol, isCycleSymImplicit: Boolean, cx: Context): Message = {
       if (cx.mode is Mode.InferringReturnType) {
         cx.tree match {
           case tree: untpd.DefDef if !tree.tpt.typeOpt.exists =>
             OverloadedOrRecursiveMethodNeedsResultType(tree.name)
           case tree: untpd.ValDef if !tree.tpt.typeOpt.exists =>
-            RecursiveValueNeedsResultType(tree.name)
+            if (isCycleSymImplicit) {
+              assert(cycleSym.name == tree.name)
+              ImplicitValNeedsResultType(cycleSym)
+            } else {
+              RecursiveValueNeedsResultType(tree.name)
+            }
           case _ =>
-            errorMsg(cx.outer)
+            errorMsg(cycleSym, isCycleSymImplicit, cx.outer)
         }
       }
-      else CyclicReferenceInvolving(denot)
+      else if (isCycleSymImplicit)
+        CyclicReferenceInvolvingImplicit(cycleSym)
+      else
+        CyclicReferenceInvolving(denot)
+    }
 
     val cycleSym = denot.symbol
-    if (cycleSym.is(Implicit, butNot = Method) && cycleSym.owner.isTerm)
-      CyclicReferenceInvolvingImplicit(cycleSym)
-    else
-      errorMsg(ctx)
+    val isCycleSymImplicit = cycleSym.is(Implicit, butNot = Method) && cycleSym.owner.isTerm
+    errorMsg(denot.symbol, isCycleSymImplicit, ctx)
   }
 }
 

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

@@ -131,6 +131,7 @@ public enum ErrorMessageID {
     MatchCaseOnlyNullWarningID,
     ImportRenamedTwiceID,
     TypeTestAlwaysSucceedsID,
+    ImplicitValNeedsResultTypeID
     ;
 
     public int errorNumber() {

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

@@ -1298,8 +1298,10 @@ object messages {
     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 this error, give `${cycleSym.name}` an explicit type.
+      hl"""|$cycleSym is declared as part of a cycle which makes it impossible for the
+           |compiler to decide upon ${cycleSym.name}'s type.
+           |This might happen when the right hand-side of $cycleSym's definition involves an implicit search.
+           |To avoid this error, try giving `${cycleSym.name}` an explicit type.
            |""".stripMargin
   }
 
@@ -2105,4 +2107,15 @@ object messages {
     }
     val explanation = ""
   }
+
+  // Relative of CyclicReferenceInvolvingImplicit and RecursiveValueNeedsResultType
+  case class ImplicitValNeedsResultType(cycleSym: Symbol)(implicit ctx: Context)
+    extends Message(ImplicitValNeedsResultTypeID) {
+    val kind = "Syntax"
+    val msg = hl"""implicit $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.
+           |""".stripMargin
+  }
 }

tests/neg/i4709.scala

@@ -0,0 +1,10 @@
+class Context
+class ContextBase { def settings = 1 }
+
+class Test {
+  implicit def toBase(ctx: Context): ContextBase = ???
+
+  def test(ctx0: Context) = {
+    implicit val ctx = { ctx0.settings; ??? } // error
+  }
+}