Improve efficiency of subtype tests involving unions of singletons

Since we do not widen singletons in unions, it is now easy to get
large union types consisting of singletons. We need to specialize
the code dealing with them in order not to get deep subtype recursions
and drastic compilation speed slowdowns.

Author: odersky

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

@@ -418,7 +418,15 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
           case _ =>
             false
         }
-        joinOK || recur(tp11, tp2) && recur(tp12, tp2)
+        def widenOK =
+          (tp2.widenSingletons eq tp2) &&
+          (tp1.widenSingletons ne tp1) &&
+          recur(tp1.widenSingletons, tp2)
+
+        if (tp2.atoms.nonEmpty)
+          tp1.atoms.nonEmpty && tp1.atoms.subsetOf(tp2.atoms)
+        else
+          widenOK || joinOK || recur(tp11, tp2) && recur(tp12, tp2)
       case tp1: MatchType =>
         val reduced = tp1.reduced
         if (reduced.exists) recur(reduced, tp2) else thirdTry
@@ -573,6 +581,10 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
         }
         compareTypeLambda
       case OrType(tp21, tp22) =>
+        if (tp2.atoms.nonEmpty)
+          return tp1.atoms.nonEmpty && tp1.atoms.subsetOf(tp2.atoms) ||
+            tp1.isRef(NothingClass)
+
         // The next clause handles a situation like the one encountered in i2745.scala.
         // We have:
         //

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

@@ -1062,6 +1062,40 @@ object Types {
         tp
     }
 
+    /** Widen all top-level singletons reachable by dealising
+     *  and going to the operands of & and |.
+     *  Overridden and cached in OrType.
+     */
+    def widenSingletons(implicit ctx: Context): Type = dealias match {
+      case tp: SingletonType =>
+        tp.widen
+      case tp: OrType =>
+        val tp1w = tp.widenSingletons
+        if (tp1w eq tp) this else tp1w
+      case tp: AndType =>
+        val tp1w = tp.tp1.widenSingletons
+        val tp2w = tp.tp2.widenSingletons
+        if ((tp.tp1 eq tp1w) && (tp.tp2 eq tp2w)) this else tp1w & tp2w
+      case _ =>
+        this
+    }
+
+    /** If this type is an alias of a disjunction of stable singleton types,
+     *  these types as a set, otherwise the empty set.
+     *  Overridden and cached in OrType.
+     */
+    def atoms(implicit ctx: Context): Set[Type] = dealias match {
+      case tp: SingletonType if tp.isStable =>
+        def normalize(tp: SingletonType): SingletonType = tp.underlying match {
+          case tp1: SingletonType => normalize(tp1)
+          case _ => tp
+        }
+        Set.empty + normalize(tp)
+      case tp: OrType => tp.atoms
+      case tp: AndType => tp.tp1.atoms & tp.tp2.atoms
+      case _ => Set.empty
+    }
+
     private def dealias1(keep: AnnotatedType => Context => Boolean)(implicit ctx: Context): Type = this match {
       case tp: TypeRef =>
         if (tp.symbol.isClass) tp
@@ -2777,6 +2811,31 @@ object Types {
       myJoin
     }
 
+    private[this] var atomsRunId: RunId = NoRunId
+    private[this] var myAtoms: Set[Type] = _
+    private[this] var myWidened: Type = _
+
+    private def ensureAtomsComputed()(implicit ctx: Context): Unit =
+      if (atomsRunId != ctx.runId) {
+        val atoms1 = tp1.atoms
+        val atoms2 = tp2.atoms
+        myAtoms = if (atoms1.nonEmpty && atoms2.nonEmpty) atoms1 | atoms2 else Set.empty
+        val tp1w = tp1.widenSingletons
+        val tp2w = tp2.widenSingletons
+        myWidened = if ((tp1 eq tp1w) && (tp2 eq tp2w)) this else tp1w | tp2w
+        atomsRunId = ctx.runId
+      }
+
+    override def atoms(implicit ctx: Context): Set[Type] = {
+      ensureAtomsComputed()
+      myAtoms
+    }
+
+    override def widenSingletons(implicit ctx: Context): Type = {
+      ensureAtomsComputed()
+      myWidened
+    }
+
     def derivedOrType(tp1: Type, tp2: Type)(implicit ctx: Context): Type =
       if ((tp1 eq this.tp1) && (tp2 eq this.tp2)) this
       else OrType.make(tp1, tp2)

tests/neg/singletonOrs.scala

@@ -1,6 +1,6 @@
 object Test {
-   def a: 1 | 2 = 1 // error // error
-   def b: 3 | 4 = a // error // error
-   def c: 1 | 2 = 1 // error // error
-   def d: 1 = a
+   def a: 1 | 2 = 1
+   def b: 3 | 4 = a // error
+   def c: 1 | 2 = 1
+   def d: 1 = a // error
 }