False “match may not be exhaustive warning”

Minimized code

def f(xs: List[Int]) =
  xs match
    case init :+ last => ()
    case Nil => ()

@main def run = f(List(1, 2))

https://scastie.scala-lang.org/NVdH00JGS36HLzTs7F8vhw

Output

[warn] 60 |    case init :+ last =>
[warn]    |    ^
[warn]    |    match may not be exhaustive.
[warn]    |
[warn]    |    It would fail on pattern case: List(_, _: _*)
[warn] one warning found

Expectation

There is no warning.

[liufengyun]

@dwijnand Dotty currently has some support for irrefutable unapplySeq:

object SeqExtractor {
  def unapplySeq(x: Int): Some[List[Int]] = Some(List(1))
}

@main
def Test = (1: String | Int)  match {
 case _: String              => "hello"
 case SeqExtractor()         => "zero"
 case SeqExtractor(_)        => "one"
 case SeqExtractor(_, _, _*) => "two or more"
}

https://scastie.scala-lang.org/H6VaTJyeSVuvZ7Y8kz4Qag

[liufengyun]

But in this case we have two extractors which are both refutable but together cover the scrutinee type completely. How can we express that?

It can be specified like the following (with the hypothetical @irrefutableFor[T]):

type ParamClause = List[ValDef] | List[TypeDef]

object ValDefs:
  @irrefutableFor[::[ValDef] | Nil.type]
  def unapply(pc: ParamClause): Option[List[ValDef]] = ... // matches empty list and all lists of ValDefs

object TypeDefs:
  @irrefutableFor[::[TypeDef]]
  def unapply(pc: ParamClause): Option[List[TypeDef]] = ... // matches non-empty lists of TypeDefs

Or, lie a little bit:

type ParamClause = List[ValDef] | List[TypeDef]

object ValDefs:
  @irrefutableFor[List[ValDef]]
  def unapply(pc: ParamClause): Option[List[ValDef]] = ... // matches empty list and all lists of ValDefs

object TypeDefs:
  @irrefutableFor[List[TypeDef]]
  def unapply(pc: ParamClause): Option[List[TypeDef]] = ... // matches non-empty lists of TypeDefs