Missed match on Array(1L) in Scala 3.1.1

Observation

Consider the following code:

object MatchTest { 
  val a: Array[Long] = Array(1L)

  def test(x: Any) = x match { 
    case Array(i: Long) => println("Success!")
    case _              => println("Failure!") }

  def main(args: Array[String]): Unit = test(a) }

When run under Scala 2.13.8 this produces Success whereas under Scala 3.1.1 it produces Failure. For the latter it does not matter if the compiler option -source:3.0-migration is used.

Expectation

Same behaviour under both versions or (at least) a warning that the match will fail. Current situation significantly changes runtime behaviour after migrating projects from Scala 2 to Scala 3.

[som-snytt]

Welcome to Scala 3.1.3-RC1-bin-SNAPSHOT-git-5fcfeec (17.0.2, Java OpenJDK 64-Bit Server VM).
Type in expressions for evaluation. Or try :help.

scala> (Array(42L): Any) match { case Array(x: Long) => x }
scala.MatchError: [J@75add13c (of class [J)
  ... 33 elided

scala> Array(42L) match { case Array(x: Long) => x }
val res1: Long = 42

[smarter]

I think the problem is with the definition of Array.unapplySeq, if I tweak it like this:

diff --git src/library/scala/Array.scala src/library/scala/Array.scala
index 14cdabd385..a64ae3cb8c 100644
--- src/library/scala/Array.scala
+++ src/library/scala/Array.scala
@@ -574,9 +574,9 @@ object Array {
    *  @param x the selector value
    *  @return  sequence wrapped in a [[scala.Some]], if `x` is an Array, otherwise `None`
    */
-  def unapplySeq[T](x: Array[T]): UnapplySeqWrapper[T] = new UnapplySeqWrapper(x)
+  def unapplySeq[T](x: Array[? <: T]): UnapplySeqWrapper[T] = new UnapplySeqWrapper(x)

-  final class UnapplySeqWrapper[T](private val a: Array[T]) extends AnyVal {
+  final class UnapplySeqWrapper[T](private val a: Array[? <: T]) extends AnyVal {
     def isEmpty: false = false
     def get: UnapplySeqWrapper[T] = this
     def lengthCompare(len: Int): Int = a.lengthCompare(len)

Then the pattern match succeeds. Otherwise, depending on how unapplySeq is instantiated, we’ll end up matching either all arrays or only arrays of objects, because Array[Any] erases to Object[]. Note that the behavior of Scala 2 here seems to be a straight-up bug: if I look at the generated tree it tries to do an isInstanceOf check on Array[T] but there is no T in scope (as pointed out by -Ycheck:pat), but luckily for Scala 2, it happens to erase this malformed type to Object so the check succeeds.

I believe this would be a binary-compatible change, so there’s a chance we could just apply this diff in the Scala 2 standard library.