Restore adaptType, with expanded docs & tests

Author: dwijnand

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -1731,6 +1731,20 @@ class Definitions {
     else sys.error(s"Not a primitive value type: $tp")
   }.typeRef
 
+  def unboxedType(tp: Type)(using Context): TypeRef = {
+    val cls = tp.classSymbol
+    if (cls eq BoxedByteClass)         ByteType
+    else if (cls eq BoxedShortClass)   ShortType
+    else if (cls eq BoxedCharClass)    CharType
+    else if (cls eq BoxedIntClass)     IntType
+    else if (cls eq BoxedLongClass)    LongType
+    else if (cls eq BoxedFloatClass)   FloatType
+    else if (cls eq BoxedDoubleClass)  DoubleType
+    else if (cls eq BoxedUnitClass)    UnitType
+    else if (cls eq BoxedBooleanClass) BooleanType
+    else sys.error(s"Not a boxed primitive value type: $tp")
+  }
+
   /** The JVM tag for `tp` if it's a primitive, `java.lang.Object` otherwise. */
   def typeTag(tp: Type)(using Context): Name = typeTags(scalaClassName(tp))
 

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

@@ -515,12 +515,25 @@ class SpaceEngine(using Context) extends SpaceLogic {
   def isPrimToBox(tp: Type, pt: Type) =
     tp.classSymbol.isPrimitiveValueClass && (defn.boxedType(tp).classSymbol eq pt.classSymbol)
 
+  /** Adapt types by performing primitive value unboxing or boxing, or numeric constant conversion.  #12805
+   *
+   *  This makes these isSubType cases work like this:
+   *  {{{
+   *   1      <:< Integer  => (<skolem> : Integer) <:< Integer  = true
+   *  ONE     <:< Int      => (<skolem> : Int)     <:< Int      = true
+   *  Integer <:< (1: Int) => (<skolem> : Int)     <:< (1: Int) = false
+   *  }}}
+   */
+  def adaptType(tp1: Type, tp2: Type): Type = trace(i"adaptType($tp1, $tp2)", show = true) {
+    if      isPrimToBox(tp1, tp2) then defn.boxedType(tp1).narrow
+    else if isPrimToBox(tp2, tp1) then defn.unboxedType(tp1).narrow
+    else convertConstantType(tp1, tp2)
+  }
+
   /** Is `tp1` a subtype of `tp2`?  */
   def isSubType(tp1: Type, tp2: Type): Boolean = trace(i"$tp1 <:< $tp2", debug, show = true) {
     if tp1 == constantNullType && !ctx.explicitNulls then tp2 == constantNullType
-    else
-      isPrimToBox(tp1, tp2) || isPrimToBox(tp2, tp1) ||
-      convertConstantType(tp1, tp2) <:< tp2
+    else adaptType(tp1, tp2) <:< tp2
   }
 
   def isSameUnapply(tp1: TermRef, tp2: TermRef): Boolean =

compiler/test/dotty/tools/dotc/transform/SpaceEngineTest.scala

@@ -4,7 +4,7 @@ package transform
 
 import org.junit.*, Assert.*
 
-import core.*, Contexts.*, Decorators.*, Symbols.*, Types.*
+import core.*, Constants.*, Contexts.*, Decorators.*, Symbols.*, Types.*
 
 class SpaceEngineTest extends DottyTest:
   @Test def testAdaptTest(): Unit =
@@ -14,6 +14,12 @@ class SpaceEngineTest extends DottyTest:
     val e = patmat.SpaceEngine()
 
     val BoxedIntType = BoxedIntClass.typeRef
+    val ConstOneType = ConstantType(Constant(1))
 
     assertTrue(e.isPrimToBox(IntType, BoxedIntType))
     assertFalse(e.isPrimToBox(BoxedIntType, IntType))
+    assertTrue(e.isPrimToBox(ConstOneType, BoxedIntType))
+
+    assertEquals(BoxedIntType, e.adaptType(IntType, BoxedIntType).widenSingleton)
+    assertEquals(IntType,      e.adaptType(BoxedIntType, IntType).widenSingleton)
+    assertEquals(IntType,      e.adaptType(BoxedIntType, ConstOneType).widenSingleton)