Add unapply methods that return an Option for compatibility?

Here’s an interesting problem minmized from https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/repl/ammonite/Protocol.scala that causes dotty-compiler-bootstrapped/repl to go into an infinite loop:

class Foo
case class Bar(x: Int) extends Foo

object Bar {
  def unapply(foo: Foo): Option[Int] = foo match {
    case foo: Bar =>
      unapply(foo)
  }
}

With scalac, the unapply call goes to the generated def unapply(x$1: Bar): Option[Int] , but with dotty no such method exist, instead we only generate a def unapply(x$1: Bar): Bar, so the previously perfectly correct code becomes an infinite loop!

I think we can fix this by always generating an unapply method that returns an Option, even if we don’t use it.

[OlivierBlanvillain]

I would expect the unapply usage to be very high. What we are interested in are direct calls to compiler generated unapply, which won’t be so easy to differentiate from user defined ones…

In the common case the dotty/scalac difference would result in a compilation error (the return type of unapply changed from Option[TupleN] to A), this is a very sneaky example where it doesn’t break compilation (because of overloading)…

@smarter I really don’t see an alternative to your suggestion (maybe under -language:Scala2?), or snippets like the following won’t cross compile:

case class A(i: Int, s: String)
val a: Option[(Int, String)] = A.unapply(A(1, "s"))

[ornicar]

In case someone else comes here looking for the generated case class unapply function, here’s how I replaced it:

  def unapply[P <: Product](p: P)(using m: scala.deriving.Mirror.ProductOf[P]): Option[m.MirroredElemTypes] =
    Some(Tuple.fromProductTyped(p))

Now you can just use unapply where you would previously use Foo.unapply