Unnecessary exhaustivity warning when combining refinement types w/ params

The following code:

object O {
  sealed trait Trait[+A] { type T }
  case class CaseClass[+A](a: A) extends Trait[A] { type T = Nothing }

  def id[TT, A](v: Trait[A] { type T = TT }): Trait[A] { type T = TT } =
    v match {
      case CaseClass(a) => CaseClass(a)
    }
}

causes the following warning:

-- [E028] Pattern Match Exhaustivity Warning: sample/1:6:4 ---------------------
6 |    v match {
  |    ^
  |    match may not be exhaustive.
  |
  |    It would fail on: CaseClass(_)

@liufengyun - this happens because the refinement type forces usage of typeParamMap in instantiate. This in turn initializes the param in the pattern space to Any, so instead of CaseClass[A] we get CaseClass[Any]. This was found when rebasing #3454 - one test had to be ignored. I should also mention that with the POC typechecker integration I’ve described in #3454, this code is handled correctly.

[abgruszecki]

Ah, I think I was misunderstanding wildcard semantics! After some experimentation, it appears that for instance Dog[_] is precisely what I would denote as Dog[K] forSome K. I understand now why using wildcards is correct here.

However, I’m not sure if I properly explained how or why I want to use TVars: once a TVar was used in a space’s type anywhere, its constraints kept in that space’s Context are not adjusted. TVars are only there so that additional constraints can be added to new Contexts created when decomposing spaces. I wanted to highlight that if we go through with typechecker-integrated #3454, this issue would automagically be solved as well.

[liufengyun]

Fixed in https://github.com/lampepfl/dotty/pull/3475.