Interaction of boxing and pattern matching; 2 and 3 behave differently

[SethTisue]

Scala 2:

scala 2.13.6> (1: Integer) match { case 1 => true }
                                        ^
              error: type mismatch;
               found   : Int(1)
               required: Integer

Scala 3 (3.1.0-RC1-bin-20210825-ce0e25c-NIGHTLY-git-ce0e25c):

scala> (1: Integer) match { case 1 => true }
val res0: Boolean = true

The argument for the Scala 3 behavior is that (1: Integer) == 1, so the same thing ought to work in pattern match form.

But it seems to me that the spec specifically forbids this. SLS 8.1.4 says:

A literal pattern L matches any value that is equal (in terms of ==) to the literal L. The type of L must conform to the expected type of the pattern.

Note the second sentence. Int and Integer are unrelated types, so the type of 1 does not conform to the pattern type (Integer), so it seems that Scala 2 is adhering to the spec in rejecting the code.

Should the Scala 3 pattern matcher be made to follow the spec, or would it be better to change the spec to allow its present behavior...?

Note that the Scala 3 compiler does sometimes enforce that sentence of the spec:

scala> class A { override def equals(a: Any) = a.isInstanceOf[B] } ; sealed class B; object B1 extends B; object B2 extends B
// defined class A
// defined class B
// defined object B1
// defined object B2
                                                                                                                        
scala> (new A) == B1
val res2: Boolean = true
                                                                                                                        
scala> (new A) match { case B1 => true }
-- Error:
1 |(new A) match { case B1 => true }
  |                     ^^
  |                     Found:    B1.type
  |                     Required: A
  |                     pattern type is incompatible with expected type

it rejects the match even though the same thing written with == directly works.

You can also do a test where implicit conversions exist between otherwise unrelated types and the Scala 3 compiler will still reject the match.

So whatever the Scala 3 compiler is doing to handle Int vs Integer must be specific to boxing-of-primitives, rather than applying to implicitly convertible types in general.

(This came up in the context of #13290, where we found an example of (x: Integer) match { case 1 => ... in a test case.)

[SethTisue]

to further muddy the waters, whatever in the Scala 3 implementation that is allowing Int and Integer to be considered matchable to each other doesn't extend to boxed vs unboxed booleans. in 3.1.0-RC1-bin-20210825-ce0e25c-NIGHTLY-git-ce0e25c again,

scala> (true: java.lang.Boolean) match { case true => 1; case false => 0 }
-- Error:
1 |(true: java.lang.Boolean) match { case true => 1; case false => 0 }
  |                                       ^^^^
  |                        Found:    (true : Boolean)
  |                        Required: Boolean²
  |
  |                        where:    Boolean  is a class in package scala
  |                                  Boolean² is a class in package java.lang
  |
  |                        pattern type is incompatible with expected type
-- Error:
1 |(true: java.lang.Boolean) match { case true => 1; case false => 0 }
  |                                                       ^^^^^
  |                        Found:    (false : Boolean)
  |                        Required: Boolean²
  |
  |                        where:    Boolean  is a class in package scala
  |                                  Boolean² is a class in package java.lang
  |
  |                        pattern type is incompatible with expected type

[som-snytt]

Maybe related https://github.com/lampepfl/dotty/pull/11327/files where conformance was enforced for stable idents. "Would it make sense to check this also for other values that are not modules?" such as literals.

Or, https://github.com/lampepfl/dotty/blob/3.0.2-RC2/compiler/src/dotty/tools/dotc/typer/Typer.scala#L3871

// approximation for numeric conversion and boxing