Pattern match on GADT not recognizing case as impossible (regression from Scala 2)

I tried searching around to see if this was a duplicate issue. I found a lot of issues around GADTs and pattern matching but didn’t think the code in any of them were as simple as in this one. I hope this is not a duplicate.

Compiler version

3.0.0

Minimized code

Written with Scala 2 syntax for easy 🍎 to 🍏 comparison:

sealed trait Foo[A]
final case class Bar(value: String) extends Foo[String]

object Example {
  def whatthe[A, B]: Foo[A => B] => Unit = {
    case Bar(_) => ()
  }
}

Result

The compilation succeeds in Scala 3.

Expectation

A compilation error similar to the one that I get if I try to compile the same code in Scala 2.13.6:

error: constructor cannot be instantiated to expected type; found : Bar required: Foo[A => B]

[SethTisue]

SLS 8.5 states unambiguously that the pattern matching anonymous function desugars as follows:

def whatthe[A, B]: Foo[A=>B] => Unit = new (Foo[A => B] => Unit) {
  def apply(x: Foo[A => B]): Unit = x match { case Bar(_) => () }
}

Scala 2 and Scala 3 are both consistent about handling the sugary and desugared versions the same (Scala 2 same error in both cases, Scala 3 no error in both cases). So we can disregard the pattern-matching-anonymous-function aspect of this and deal directly with the raw pattern match.

We can also minimize it further to just:

def whatthe[A, B](x: Foo[A => B]): Unit =
  x match { case Bar(_) => () }

again, Scala 2 gives a type error, Scala 3 accepts it.

And note that Scala 2 isn’t only rejecting the code because there’s a single case. It still rejects it even if you put a catchall case in:

def whatthe[A, B](x: Foo[A => B]): Unit =
  x match { case Bar(_) => (); case _ => () }

[dwijnand]

That Scala 2 error isn’t an exhaustivity error, it’s a typer error, because the match doesn’t type. And I think it’s right (or, rather, I can’t think why Scala 3 thinks that’s wrong), so I think the fix is in typing the case.