Pattern Match Loses Type Information

[adamgfraser]

Compiler version

3.2.2

Minimized code

sealed trait Foo[+A] {
  def baz: A
}

sealed trait Bar[+A] extends Foo[A]

object Bar {
  def unapply[A](bar: Bar[A]): Some[A] =
    Some(bar.baz)
}

def someMethod[A](foo: Bar[A]): A =
  ???

def test[A](foo: Foo[A]): A =
  foo match {
    case bar @ Bar(_) => someMethod(bar)
  }

Output

Found:    (bar : Playground.Foo[A] & Playground.Bar[Any])
Required: Playground.Bar[A]

Expectation

I would expect that the inferred type of bar here would be Bar[A] instead of Bar[Any]. This is the behavior in Scala 2 so this seems to be a regression in type inference

[smarter]

This is the behavior in Scala 2 so this seems to be a regression in type inference

Unfortunately, Scala 2's behavior is unsound here:

sealed trait Foo[+A] {
  def foo: A
}

sealed trait Bar[+A] extends Foo[A] {
  def bar: A
}

class FB extends Bar[Any] with Foo[Int] {
  def bar: Any = ""
  def foo: Int = 1
}

object Bar {
  def unapply[A](bar: Bar[A]): Some[A] =
    Some(bar.foo)
}

object Test {
  def test[A](foo: Foo[A]): A =
    foo match {
      case bar @ Bar(_) => bar.bar
    }
  def main(args: Array[String]): Unit = {
    val x: Int = test(new FB) // ClassCastException: String cannot be cast to Integer
    println(x)
  }
}

So I don't think there's anything we can do. See also #11834 where the concept of "invariant refinement" is discussed.

[dwijnand]

Duplicate of #4790