Match type forgets kindness of variable extending wildcarded trait

[s5bug]

Compiler version

3.4.0, 3.4.1-RC1

Minimized code

sealed trait Wrap[A <: AnyKind]

trait Foo[T <: AnyKind, X[_ <: T]]

trait Bar[T <: AnyKind, X[_ <: T]] {

  def foo: Foo[
    Wrap[? <: T],
    [x <: Wrap[? <: T]] =>> x match { case Wrap[a] => X[a] }
  ]

}

object Qux extends Bar[Any, [_] =>> Unit] {

  override def foo: Foo[
    Wrap[? <: Any],
    [x <: Wrap[? <: Any]] =>> x match { case Wrap[a] => Unit }
  ] = ???

}

Output

error overriding method foo in trait Bar of type =>
  Foo[Wrap[?],
    [x <: Wrap[?]] =>>
      x match {
        case Wrap[a] => Unit
      }
  ];
  method foo of type =>
  Foo[Wrap[?],
    [x <: Wrap[?]] =>>
      x match {
        case Wrap[a] => Unit
      }
  ] has incompatible type

Explanation
===========
I tried to show that
  =>
  Foo[Wrap[?],
    [x <: Wrap[?]] =>>
      x match {
        case Wrap[a] => Unit
      }
  ]
conforms to
  =>
  Foo[Wrap[?],
    [x <: Wrap[?]] =>>
      x match {
        case Wrap[a] => Unit
      }
  ]
but none of the attempts shown below succeeded:

  ==> =>   Foo[Wrap[?],     [x <: Wrap[?]] =>>       x match {         case Wrap[a] => Unit       }   ]  <:  =>   Foo[Wrap[?],     [x <: Wrap[?]] =>>       x match {         case Wrap[a] => Unit       }   ]
    ==> Foo[Wrap[?],   [x <: Wrap[?]] =>>     x match {       case Wrap[a] => Unit     } ]  <:  Foo[Wrap[?],   [x <: Wrap[?]] =>>     x match {       case Wrap[a] => Unit     } ]
      ==> [x <: Wrap[?]] =>>   x match {     case Wrap[a] => Unit   }  <:  [x <: Wrap[?]] =>>   x match {     case Wrap[a] => Unit   }
        ==> x match {   case Wrap[a] => Unit }  <:  x match {   case Wrap[a] => Unit }
          ==> Any  <:  x match {   case Wrap[a] => Unit }  = false
          ==> [a] =>> scala.runtime.MatchCase[Wrap[a], Unit]  <:  [a <: AnyKind] =>> scala.runtime.MatchCase[Wrap[a], Unit]
            ==> type bounds [ <: AnyKind]  <:  type bounds []
              ==> AnyKind  <:  Any  = false

The tests were made under the empty constraint

Expectation

This should compile. Notably, the 3rd and 4th lines in the trace show equivalent types (==> T <: T).

Replacing the the bound x <: Wrap[? <: T] with x <: (Wrap[? <: T] & Any) causes the code to compile, even though Wrap[? <: T] is always a subtype of Any (and so Wrap[? <: T] & Any should be equivalent to Wrap[? <: T]).

[dwijnand]

Notably, the 3rd and 4th lines in the trace show equivalent types (==> T <: T).

They show equivalent types because you wrote them equivalently, while being in different classes. If we write the program as:

sealed trait Bx[AK1 <: AnyKind]
trait C1[AK2 <: AnyKind, X[_ <: AK2]]
trait C2[AK3 <: AnyKind, Y[_ <: AK3]]:
           def mm: C1[Bx[? <: AK3], [x <: Bx[? <: AK3]] =>> x match { case Bx[a] => Y[a] }]
class C3 extends C2[Any, [_] =>> Unit]:
  override def mm: C1[Bx[? <: Any], [y <: Bx[? <: Any]] =>> y match { case Bx[b] => Unit }] = ???

Then the trace ends as such:

==> x match { case Bx[a] => Unit } <: Unit  <:  x match { case Bx[b] => Unit } <: Unit
  ==> Unit  <:  x match { case Bx[b] => Unit } <: Unit  = false
  ==> [a] =>> case Bx[a] => Unit  <:  [b <: AnyKind] =>> case Bx[b] => Unit
    ==> [ <: AnyKind]  <:  []
      ==> AnyKind  <:  Any  = false

There's a combination of things that go wrong, and they go all the way back to recording constraints and fixing binding infos. Both a and b (in my renamed version) are bindings. When we get to indexPattern we change a's info frmo <: AnyKind to <: AK3. Later that AK3 is correctly substituted, by ASF, by the Any type argument in C3's parent definition. However, when indexPattern gets to b, it hasn't recorded that b has been narrowed from <: AnyKind to <: Any, because it (still) thinks that Any is the top kind. So it leaves it as <: AnyKind and that's where the subtype check fails.