`inline` chain corrupts type along the way

[japgolly]

Compiler version

3.0.0-RC2-bin-20210325-eeb8340-NIGHTLY

Minimized code

object CallbackTo {
  extension [A](self: CallbackTo[Option[A]]) {
    inline def asOption: Option[A] =
      self.toScalaFn()
  }
}

final class CallbackTo[A] (val x: List[A]) {

  inline def runNow(): A =
    x.head

  inline def toScalaFn: () => A =
    () => runNow()

  def map[B](f: A => B): CallbackTo[B] =
    ???

  def toOption: Option[A] = {
    val x = map[Option[A]](Some(_))
    val y = x: CallbackTo[Option[A]] // ok: type is what we expect
    y.asOption // error
  }
}

Output

22 |    y.asCallbackOption // error
   |    ^^^^^^^^^^^^^^^^^^
   |    Found:    Option[Option[A]]
   |    Required: Option[A]
   | This location contains code that was inlined from x.scala:21

Expectation

It should compile. There are 3 inlines in this snippet and removing any of them makes this compile again.

[nicolasstucki]

Minimized

class CallbackTo[A](x: A):
  inline def runNow(): A = x
  inline def toScalaFn: () => A = () => runNow()
  def toOption(): Option[A] =
    val y: CallbackTo[Option[A]] = ???
    val f: () => Option[A] = y.toScalaFn // error
    f()

[odersky]

The minimized test passes when all inlines are changed to transparent.

The original test fails in that case with

Exception in thread "main" java.lang.AssertionError: assertion failed: unresolved symbols: value CallbackTo_this (line 3) #15442 when pickling test.scala

That failure has been fixed in 8ab9133. So now everything looks OK, as long as the inlines are transparent. We need to find out what is different if they are done after typer.