Redo & organise adaptType in SpaceEngine

Emitting deferred reachability warnings (the previous commit) caused
tests/patmat/boxing.scala to start failing, because my logic on boxing
and unboxing wasn't actually right.

So this fixes how the case type (tp1) gets adapted for the scrutinee
type (tp2), with two examples in the comments from that boxing test
case.  Also organise that constant types are converted if boxing isn't
involved.

Author: dwijnand

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -512,23 +512,46 @@ class SpaceEngine(using Context) extends SpaceLogic {
       if converted == null then tp else ConstantType(converted)
     case _ => tp
 
-  /** Adapt types by performing primitive value boxing.  #12805 */
-  def maybeBox(tp1: Type, tp2: Type): Type =
-    if tp1.classSymbol.isPrimitiveValueClass && !tp2.classSymbol.isPrimitiveValueClass then
-      defn.boxedType(tp1).narrow
-    else tp1
+  private lazy val defn         = ctx.definitions
+  private lazy val ByteClass    = defn.ByteClass
+  private lazy val ShortClass   = defn.ShortClass
+  private lazy val CharClass    = defn.CharClass
+  private lazy val IntClass     = defn.IntClass
+  private lazy val LongClass    = defn.LongClass
+  private lazy val FloatClass   = defn.FloatClass
+  private lazy val DoubleClass  = defn.DoubleClass
+  private lazy val UnitClass    = defn.UnitClass
+  private lazy val BooleanClass = defn.BooleanClass
+
+  /** Adapt types by performing primitive value unboxing or boxing, or numeric constant conversion.  #12805 */
+  def adaptType(tp1: Type, tp2: Type): Type = trace(i"adaptType($tp1, $tp2)", show = true)((tp1.classSymbol, tp2.classSymbol) match {
+    case (   ByteClass,    defn.BoxedByteClass) =>    defn.BoxedByteClass.typeRef.narrow
+    case (  ShortClass,   defn.BoxedShortClass) =>   defn.BoxedShortClass.typeRef.narrow
+    case (   CharClass,    defn.BoxedCharClass) =>    defn.BoxedCharClass.typeRef.narrow
+    case (    IntClass,     defn.BoxedIntClass) =>     defn.BoxedIntClass.typeRef.narrow // 1 <:< Integer => (<skolem> : Integer) <:< Integer = true
+    case (   LongClass,    defn.BoxedLongClass) =>    defn.BoxedLongClass.typeRef.narrow
+    case (  FloatClass,   defn.BoxedFloatClass) =>   defn.BoxedFloatClass.typeRef.narrow
+    case ( DoubleClass,  defn.BoxedDoubleClass) =>  defn.BoxedDoubleClass.typeRef.narrow
+    case (   UnitClass,    defn.BoxedUnitClass) =>    defn.BoxedUnitClass.typeRef.narrow
+    case (BooleanClass, defn.BoxedBooleanClass) => defn.BoxedBooleanClass.typeRef.narrow
+
+    case (   defn.BoxedByteClass,    ByteClass) =>    defn.ByteType.narrow
+    case (  defn.BoxedShortClass,   ShortClass) =>   defn.ShortType.narrow
+    case (   defn.BoxedCharClass,    CharClass) =>    defn.CharType.narrow
+    case (    defn.BoxedIntClass,     IntClass) =>     defn.IntType.narrow // ONE <:< Int => (<skolem> : Int) <:< Int = true
+    case (   defn.BoxedLongClass,    LongClass) =>    defn.LongType.narrow
+    case (  defn.BoxedFloatClass,   FloatClass) =>   defn.FloatType.narrow
+    case ( defn.BoxedDoubleClass,  DoubleClass) =>  defn.DoubleType.narrow
+    case (   defn.BoxedUnitClass,    UnitClass) =>    defn.UnitType.narrow
+    case (defn.BoxedBooleanClass, BooleanClass) => defn.BooleanType.narrow
+
+    case _ => convertConstantType(tp1, tp2)
+  })
 
   /** Is `tp1` a subtype of `tp2`?  */
-  def isSubType(_tp1: Type, tp2: Type): Boolean = {
-    val tp1 = maybeBox(convertConstantType(_tp1, tp2), tp2)
-    //debug.println(TypeComparer.explained(_.isSubType(tp1, tp2)))
-    val res = if (ctx.explicitNulls) {
-      tp1 <:< tp2
-    } else {
-      (tp1 != constantNullType || tp2 == constantNullType) && tp1 <:< tp2
-    }
-    debug.println(i"$tp1 <:< $tp2 = $res")
-    res
+  def isSubType(tp1: Type, tp2: Type): Boolean = trace(i"$tp1 <:< $tp2", debug, show = true) {
+    if tp1 == constantNullType && !ctx.explicitNulls then tp2 == constantNullType
+    else adaptType(tp1, tp2) <:< tp2
   }
 
   def isSameUnapply(tp1: TermRef, tp2: TermRef): Boolean =

tests/neg-custom-args/fatal-warnings/i8711.check

@@ -1,8 +1,8 @@
--- Error: tests/neg-custom-args/fatal-warnings/i8711.scala:7:9 ---------------------------------------------------------
+-- [E030] Match case Unreachable Error: tests/neg-custom-args/fatal-warnings/i8711.scala:7:9 ---------------------------
 7 |    case x: B => x // error: this case is unreachable since class A is not a subclass of class B
-  |         ^
-  |         this case is unreachable since type A and class B are unrelated
--- Error: tests/neg-custom-args/fatal-warnings/i8711.scala:12:9 --------------------------------------------------------
+  |         ^^^^
+  |         Unreachable case
+-- [E030] Match case Unreachable Error: tests/neg-custom-args/fatal-warnings/i8711.scala:12:9 --------------------------
 12 |    case x: C => x // error
-   |         ^
-   |         this case is unreachable since type A | B and class C are unrelated
+   |         ^^^^
+   |         Unreachable case