Missed match on Array(1L) in Scala 3.1.1

[devlaam]

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.

[SethTisue]

Dale (@dwijnand) has been working in this area recently. is the problem reproducible in 3.1.2-RC2 and/or in the latest nightly (3.2.0-RC1-bin-20220308-29073f1-NIGHTLY-git-29073f1)?

[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

[devlaam]

Thank you for taking this on. Maybe you can, while you are at it, also have a look at the situation were IArray is used instead of Array.

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

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

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

This already produces the desired result Success under Scala 3.1.1, but there are some warnings:

[warn] -- [E165] Type Warning: src/main/scala/Main.scala:5:19 
[warn] 5 |    case IArray(i: Long) => println("Success!")
[warn]   |                   ^^^^
[warn]   |        pattern selector should be an instance of Matchable,,
[warn]   |        but it has unmatchable type Array.UnapplySeqWrapper[?]#T instead

[warn] -- [E165] Type Warning: src/main/scala/Main.scala:30:45 
[warn] 8 |  def main(args: Array[String]): Unit = test(a) }
[warn]   |                                             ^
[warn]   |                        value should be an instance of Matchable,,
[warn]   |                        but it has unmatchable type IArray[Long] instead

These warnings may be understandable, given The Matchable Trait definition, but the question is, is this what we expect? The match seems safe enough to me, and certainly does not suffer from the loophole discussed therein. Or put differently, if this is not possible when "warnings are errors", what should you do?

[warn] -- Unchecked Warning: /Volumes/DATA/Sense2Act/Software/ws-scala/scala3/src/main/scala/Main.scala:27:9 
[warn] 5 |    case IArray(i: Long) => println("Success!")
[warn]   |         ^
[warn]   |         the type test for IArray[Any] cannot be checked at runtime

This warning puzzels me. Is this not exactly what just happend?

[smarter]

The IArray thing seems unrelated to me and it's best not to conflate issues to avoid confusion, especially here when one of these issues is a clear regression and the other is related to a new feature, so please consider opening a separate issue to discuss this.

[devlaam]

Understandable, shall we delete the posts then, just to keep this clean?

[smarter]

I'll hide as "Off-Topic" :).

[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.

[smarter]

scala/scala#9977