typed patterns get more precise types in scalac than dotty

[allanrenucci]

The following code snippet fails to compile

class Test {
  trait E
  trait Marker

  def test(es: List[E]): List[E] = es.collect { case e: Marker => e }
}

-- Error: tests/allan/Test.scala:5:69 ------------------------------------------
5 |  def test(es: List[E]): List[E] = es.collect { case e: Marker => e }
  |                                                                     ^
  |Cannot construct a collection of type That
  |
  |where:    That is a type variable with constraint <: scala.collection.immutable.List[Test.this.E]
  | with elements of type Test.this.Marker based on a collection of type scala.collection.immutable.List[Test.this.E].

[smarter]

It works if you replace case e: Marker by case e: E with Marker. In scalac, e gets the type E with Marker in the original code, but in dotty it only gets the type Marker, I don't know what the intended/specified behavior is, but it seems that the scalac behavior is not completely consistent: https://users.scala-lang.org/t/type-inference-in-pattern-matching/1708

[smarter]

Had a quick look at the spec and I couldn't find anything substantiating the current scalac behavior, in particular http://www.scala-lang.org/files/archive/spec/2.13/08-pattern-matching.html#typed-patterns says:

A typed pattern x:T consists of a pattern variable x and a type pattern T. The type of x is the type pattern T, [...]

@odersky Are you OK with replicating the behavior of scalac here? Here's a simple example illustrating the difference:

trait X
trait Y

object Test {
  def foo(x: X) = x match {
    case y: Y =>
      val b: X = y // compiles with scalac, type mismatch with dotty
  }
}

[odersky]

Pattern matching desperately needs a spec. It would be good if someone could start working on the issue. I think the scalac behavior on the test cases makes sense, though.

[allanrenucci]

Here is another example that does not compile with Dotty, I found in the community build:

trait MyError { this: Throwable =>
  ...
}


try ...
catch {
  case e: MyError =>
    throw e
}

The self-type is not required to compile with scalac but it was in the example