Cyclic reference involving implicit value

[allanrenucci]

class Context
class ContextBase { def settings = 1 }

class Test {
  implicit def toBase(ctx: Context): ContextBase = ???

  def test(ctx0: Context) = {
    implicit val ctx = { ctx0.settings; ??? }
  }
}

This code snippet above fails to compile:

-- [E047] Syntax Error: tests/allan/Test.scala:8:25 ----------------------------
8 |    implicit val ctx = { ctx0.settings; ??? }
  |                         ^
  |                         cyclic reference involving implicit value ctx

Adding an explicit type annotation to val ctx solves the issue

[allanrenucci]

Maybe related to #3253

[odersky]

The cyclic reference is real. The only possible improvement I see is to change the error message to say that an explicit return type should be added.

[allanrenucci]

Can you explain what the cyclic reference is

[odersky]

settings is not a member of ctx, so we need to look for an implicit reference that makes it one. ctx is implicit, so we need its type to determine whether it is a suitable candidate -> cycle.

[Blaisorblade]

@allanrenucci pointed out that here you can't actually use ctx in itself because it's not a field (and uses will get flagged earlier), so it's not clear why it should be considered by implicit search.

It's weird, in fact, that some vals (including implicits) are in scope when they can't be used. You need to shadow earlier references to keep compatibility with the current semantics, but why have them in scope?

More surprising puzzlers we found include the following (uncategorized):

pgiarrusso@SilenceOfTheLambdas:~/git/scala$ /usr/local/bin/dotr
Starting dotty REPL...
scala> def f: Unit = { implicitly[Int]; implicit val i: Int = 1 }
1 |def f: Unit = { implicitly[Int]; implicit val i: Int = 1 }
  |                ^^^^^^^^^^^^^^^
  |                a pure expression does nothing in statement position
1 |def f: Unit = { implicitly[Int]; implicit val i: Int = 1 }
  |                ^^^^^^^^^^^^^^^
  |           `i` is a forward reference extending over the definition of `i` // this error mentions generated code
scala> def f: Unit = { implicitly[Int]; implicit lazy val i: Int = 1 }
def f: Unit
scala> def f: Unit = { implicitly[Int]; implicit val i = 1 }
1 |def f: Unit = { implicitly[Int]; implicit val i = 1 }
  |                ^^^^^^^^^^^^^^^
  |                a pure expression does nothing in statement position
1 |def f: Unit = { implicitly[Int]; implicit val i = 1 }
  |                ^^^^^^^^^^^^^^^
  |           `i` is a forward reference extending over the definition of `i`
scala> def f: Unit = { implicitly[Int]; implicit val i = implicitly[Int] } // OK, it's fine to have an error here
1 |def f: Unit = { implicitly[Int]; implicit val i = implicitly[Int] }
  |                                                  ^^^^^^^^^^^^^^^
  |                               cyclic reference involving implicit value i

pgiarrusso@SilenceOfTheLambdas:~/git/dotty-master$ scala
Welcome to Scala 2.12.6 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_172).
Type in expressions for evaluation. Or try :help.

scala> def f: Unit = { implicitly[Int]; implicit val i: Int = 1 }
<console>:11: error: forward reference extends over definition of value i
       def f: Unit = { implicitly[Int]; implicit val i: Int = 1 }
                                 ^

scala> def f: Unit = { implicitly[Int]; implicit lazy val i: Int = 1 }
f: Unit

scala> def f: Unit = { implicitly[Int]; implicit val i = implicitly[Int] }
<console>:11: error: could not find implicit value for parameter e: Int
       def f: Unit = { implicitly[Int]; implicit val i = implicitly[Int] }
                                 ^
<console>:11: error: could not find implicit value for parameter e: Int
       def f: Unit = { implicitly[Int]; implicit val i = implicitly[Int] }
                                                                   ^

scala> def f: Unit = { implicit val i = implicitly[Int] }
<console>:11: error: could not find implicit value for parameter e: Int
       def f: Unit = { implicit val i = implicitly[Int] }
                                                  ^

scala> def f: Unit = { implicit val i: Int = implicitly[Int] }
<console>:11: error: forward reference extends over definition of value i
       def f: Unit = { implicit val i: Int = implicitly[Int] }
                                                       ^

[Blaisorblade]

Discussion revealed that the fix Martin proposed could probably be localized to https://github.com/lampepfl/dotty/blob/1dce6772d0a4128e87e7038ac5da5d9e91c1c458/compiler/src/dotty/tools/dotc/core/TypeErrors.scala#L101-L124 — if we're producing CyclicReferenceInvolvingImplicit but we have cx.mode is Mode.InferringReturnType, it seems we could produce as error a mixture of RecursiveValueNeedsResultType and CyclicReferenceInvolvingImplicit with the desired error.