Unreachable case when matching with a match type subpattern

[Katrix]

Compiler version

3.0.1
Did not happen on 3.0.0

Minimized code

trait MyTrait[A] {
  def pack[Z](u: Either[Int, A]): Int
}

def make[ElemTypes <: scala.NonEmptyTuple] = new MyTrait[scala.Tuple.Tail[ElemTypes]] {
  override def pack[Z](u: Either[Int, scala.Tuple.Tail[ElemTypes]]): Int = u match {
    case Left(hz) => ???
    case Right(tz) => ???
  }
}

Output

[error] 214 |      case Right(tz) => ???
[error]     |           ^^^^^^^^^
[error]     |           Unreachable case

Expectation

It compiles

[nicolasstucki]

Minimized

def foo(opt: Option[Tuple.Tail[NonEmptyTuple]]): Unit =
  opt match
    case None => ???
    case Some(a) => ???

5 |    case Some(a) => ???
  |         ^^^^^^^
  |         Unreachable case

[dwijnand]

Looks like this is due to:

instantiateToSubType: !(EmptyTuple.type <:< Tuple.Tail[NonEmptyTuple])
object EmptyTuple refined from Tuple.Tail[NonEmptyTuple] to <notype>
...
Tuple.Tail[NonEmptyTuple] decomposes to []

!(EmptyTuple.type <:< Tuple.Tail[NonEmptyTuple]) looks wrong to me, right?

---

(edit: more trace logging)

decomposable: Tuple.Tail[NonEmptyTuple] = true
candidates for Tuple.Tail[NonEmptyTuple] : [object EmptyTuple, trait NonEmptyTuple]

Subtype trace:
  ==> EmptyTuple.type  <:  Tuple.Tail[NonEmptyTuple]
    ==> EmptyTuple.type  <:  Tuple.Tail[NonEmptyTuple] (recurring)
      ==> EmptyTuple  <:  Tuple.Tail[NonEmptyTuple] (left is approximated)
        ==> EmptyTuple  <:  Tuple.Tail[NonEmptyTuple] (recurring)
          ==> EmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (left is approximated) (right is approximated)
            ==> EmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (recurring)
            <== EmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (recurring) = false
          <== EmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (left is approximated) (right is approximated) = false
        <== EmptyTuple  <:  Tuple.Tail[NonEmptyTuple] (recurring) = false
      <== EmptyTuple  <:  Tuple.Tail[NonEmptyTuple] (left is approximated) = false
      ==> EmptyTuple.type  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (right is approximated)
        ==> EmptyTuple.type  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (recurring)
          ==> EmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (left is approximated) (right is approximated)
            ==> EmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (recurring)
            <== EmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (recurring) = false
          <== EmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (left is approximated) (right is approximated) = false
        <== EmptyTuple.type  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (recurring) = false
      <== EmptyTuple.type  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (right is approximated) = false
    <== EmptyTuple.type  <:  Tuple.Tail[NonEmptyTuple] (recurring) = false
  <== EmptyTuple.type  <:  Tuple.Tail[NonEmptyTuple] = false
object EmptyTuple refined to <notype>

Subtype trace:
  ==> NonEmptyTuple  <:  Tuple.Tail[NonEmptyTuple]
    ==> NonEmptyTuple  <:  Tuple.Tail[NonEmptyTuple] (recurring)
      ==> NonEmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (right is approximated)
        ==> NonEmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (recurring)
        <== NonEmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (recurring) = false
      <== NonEmptyTuple  <:  NonEmptyTuple match { case _ *: xs => xs } <: Tuple (right is approximated) = false
    <== NonEmptyTuple  <:  Tuple.Tail[NonEmptyTuple] (recurring) = false
  <== NonEmptyTuple  <:  Tuple.Tail[NonEmptyTuple] = false
trait NonEmptyTuple refined to <notype>

Tuple.Tail[NonEmptyTuple] decomposes to []