WIP widen Space

Author: odersky

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

@@ -503,7 +503,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
     else
       (pats, Typ(scalaNilType, false))
 
-    val unapplyTp = scalaConsType.classSymbol.companionModule.termRef.select(nme.unapply)
+    val unapplyTp = scalaConsType.widen.classSymbol.companionModule.termRef.select(nme.unapply)
     items.foldRight[Space](zero) { (pat, acc) =>
       val consTp = scalaConsType.appliedTo(pats.head.tpe.widen)
       Prod(consTp, unapplyTp, project(pat) :: acc :: Nil, true)
@@ -613,10 +613,12 @@ class SpaceEngine(using Context) extends SpaceLogic {
         )
       case tp if tp.isRef(defn.UnitClass) =>
         Typ(ConstantType(Constant(())), true) :: Nil
-      case tp if tp.classSymbol.isAllOf(JavaEnumTrait) =>
-        tp.classSymbol.children.map(sym => Typ(sym.termRef, true))
+      case tp: SingletonType =>
+        Nil
+      case tp if tp.widen.classSymbol.isAllOf(JavaEnumTrait) =>
+        tp.widen.classSymbol.children.map(sym => Typ(sym.termRef, true))
       case tp =>
-        val children = tp.classSymbol.children
+        val children = tp.widen.classSymbol.children
         debug.println(s"candidates for ${tp.show} : [${children.map(_.show).mkString(", ")}]")
 
         val parts = children.map { sym =>
@@ -645,26 +647,22 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
 
   /** Abstract sealed types, or-types, Boolean and Java enums can be decomposed */
-  def canDecompose(tp: Type): Boolean = {
-    val dealiasedTp = tp.dealias
-    val res =
-      (tp.classSymbol.is(Sealed) &&
-        tp.classSymbol.isOneOf(AbstractOrTrait) &&
-        !tp.classSymbol.hasAnonymousChild &&
-        tp.classSymbol.children.nonEmpty ) ||
-      dealiasedTp.isInstanceOf[OrType] ||
-      (dealiasedTp.isInstanceOf[AndType] && {
-        val and = dealiasedTp.asInstanceOf[AndType]
-        canDecompose(and.tp1) || canDecompose(and.tp2)
-      }) ||
-      tp.isRef(defn.BooleanClass) ||
-      tp.isRef(defn.UnitClass) ||
-      tp.classSymbol.isAllOf(JavaEnumTrait)
-
+  def canDecompose(tp: Type): Boolean =
+    val res = tp.dealias match
+      case _: SingletonType => false
+      case _: OrType => true
+      case and: AndType => canDecompose(and.tp1) || canDecompose(and.tp2)
+      case _ =>
+        val cls = tp.classSymbol
+        cls.is(Sealed)
+        && cls.isOneOf(AbstractOrTrait)
+        && !cls.hasAnonymousChild
+        && cls.children.nonEmpty
+        || cls.isAllOf(JavaEnumTrait)
+        || tp.isRef(defn.BooleanClass)
+        || tp.isRef(defn.UnitClass)
     debug.println(s"decomposable: ${tp.show} = $res")
-
     res
-  }
 
   /** Show friendly type name with current scope in mind
    *