Pattern matching with type annotations allows impossible cases

[Jacoby6000]

This should not compile:

  sealed trait Foo[T]
  case class Bar[T](s: String)
  
  def shouldError[T](foo: Foo[T]): String = 
    foo match {
      case bar: Bar[T] => bar.s
    }

Not even a warning is produced, as is.

[allanrenucci]

Note that the warning produced by scalac is not an exhaustivity warning:

warning: abstract type T in type pattern Bar[T] is unchecked since it is eliminated by erasure

scalac (and dotc) will not complain for:

sealed trait Foo
class Bar
  
class Test {
  def shouldError(foo: Foo) = foo match {
    case _: Bar => 1
  }
}

If Foo is a class, both scalac and dotc reject the program.

[Jacoby6000]

@allanrenucci will your changes cause the sample you and I provided produce an error? I haven't poked around in dotty at all, but in general compilers should error whenever you have a situation where the type being matched on is not a super type of the case.

[Jacoby6000]

@liufengyun I'd like this to be re-opened, since what was resolved was actually unrelated to what I was concerned about. My example was perhaps bad. @allanrenucci touched on what I was talking about.

The below example compiles, but should error:

  sealed trait Foo
  case class Bar(s: String)
  
  def shouldError(foo: Foo): String = 
    foo match {
      case bar: Bar => bar.s
    }

I'm so used to generalizing that I did an un-necessary generalization in my earlier example which confused the issue.

[liufengyun]

Scalac accepts the code above, as Dotty does. @Jacoby6000 can you specify why you think it should error?

[allanrenucci]

Since Foo is sealed, is it safe to say that case bar: Bar is unreachable?