Better support for LazyRefs in & and |

Author: odersky

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

@@ -1727,10 +1727,14 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
     else if tp1.isAny && !tp2.isLambdaSub || tp1.isAnyKind || tp2.isRef(NothingClass) then tp2
     else if tp2.isAny && !tp1.isLambdaSub || tp2.isAnyKind || tp1.isRef(NothingClass) then tp1
     else tp2 match {  // normalize to disjunctive normal form if possible.
+      case tp2: LazyRef =>
+        glb(tp1, tp2.ref)
       case OrType(tp21, tp22) =>
         tp1 & tp21 | tp1 & tp22
       case _ =>
         tp1 match {
+          case tp1: LazyRef =>
+            glb(tp1.ref, tp2)
           case OrType(tp11, tp12) =>
             tp11 & tp2 | tp12 & tp2
           case _ =>
@@ -1777,31 +1781,34 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
     else if (!tp2.exists) tp2
     else if tp1.isAny && !tp2.isLambdaSub || tp1.isAnyKind || tp2.isRef(NothingClass) then tp1
     else if tp2.isAny && !tp1.isLambdaSub || tp2.isAnyKind || tp1.isRef(NothingClass) then tp2
-    else {
-      def mergedLub: Type = {
-        val atoms1 = tp1.atoms(widenOK = true)
-        if (atoms1.nonEmpty && !widenInUnions) {
-          val atoms2 = tp2.atoms(widenOK = true)
-          if (atoms2.nonEmpty) {
-            if (atoms1.subsetOf(atoms2)) return tp2
-            if (atoms2.subsetOf(atoms1)) return tp1
-            if ((atoms1 & atoms2).isEmpty) return orType(tp1, tp2)
-          }
-        }
-        val t1 = mergeIfSuper(tp1, tp2, canConstrain)
-        if (t1.exists) return t1
+    else tp1 match
+      case tp1: LazyRef => lub(tp1.ref, tp2)
+      case _ => tp2 match
+        case tp2: LazyRef => lub(tp1, tp2.ref)
+        case _ =>
+          def mergedLub: Type = {
+            val atoms1 = tp1.atoms(widenOK = true)
+            if (atoms1.nonEmpty && !widenInUnions) {
+              val atoms2 = tp2.atoms(widenOK = true)
+              if (atoms2.nonEmpty) {
+                if (atoms1.subsetOf(atoms2)) return tp2
+                if (atoms2.subsetOf(atoms1)) return tp1
+                if ((atoms1 & atoms2).isEmpty) return orType(tp1, tp2)
+              }
+            }
+            val t1 = mergeIfSuper(tp1, tp2, canConstrain)
+            if (t1.exists) return t1
 
-        val t2 = mergeIfSuper(tp2, tp1, canConstrain)
-        if (t2.exists) return t2
+            val t2 = mergeIfSuper(tp2, tp1, canConstrain)
+            if (t2.exists) return t2
 
-        def widen(tp: Type) = if (widenInUnions) tp.widen else tp.widenIfUnstable
-        val tp1w = widen(tp1)
-        val tp2w = widen(tp2)
-        if ((tp1 ne tp1w) || (tp2 ne tp2w)) lub(tp1w, tp2w)
-        else orType(tp1w, tp2w) // no need to check subtypes again
-      }
-      mergedLub
-    }
+            def widen(tp: Type) = if (widenInUnions) tp.widen else tp.widenIfUnstable
+            val tp1w = widen(tp1)
+            val tp2w = widen(tp2)
+            if ((tp1 ne tp1w) || (tp2 ne tp2w)) lub(tp1w, tp2w)
+            else orType(tp1w, tp2w) // no need to check subtypes again
+          }
+          mergedLub
   }
 
   /** The least upper bound of a list of types */

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

@@ -1007,7 +1007,8 @@ object Types {
      *  pos/i536 demonstrates that the infinite loop can also involve lower bounds.
      */
     def safe_& (that: Type)(implicit ctx: Context): Type = (this, that) match {
-      case (TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) => TypeBounds(OrType(lo1, lo2), AndType(hi1, hi2))
+      case (TypeBounds(lo1, hi1), TypeBounds(lo2, hi2)) =>
+        TypeBounds(OrType(lo1.stripLazyRef, lo2.stripLazyRef), AndType(hi1.stripLazyRef, hi2.stripLazyRef))
       case _ => this & that
     }
 
@@ -1049,6 +1050,10 @@ object Types {
       case _ => this
     }
 
+    def stripLazyRef(given Context): Type = this match
+      case lzy: LazyRef => lzy.ref
+      case _ => this
+
     /** Widen from singleton type to its underlying non-singleton
      *  base type by applying one or more `underlying` dereferences,
      *  Also go from => T to T.
@@ -2566,15 +2571,15 @@ object Types {
     }
   }
 
-  case class LazyRef(private var refFn: Context => Type) extends UncachedProxyType with ValueType {
+  case class LazyRef(private var refFn: Context => Type, reportCycles: Boolean = false) extends UncachedProxyType with ValueType {
     private var myRef: Type = null
     private var computed = false
     def ref(implicit ctx: Context): Type = {
       if (computed) {
         if (myRef == null) {
           // if errors were reported previously handle this by throwing a CyclicReference
           // instead of crashing immediately. A test case is neg/i6057.scala.
-          assert(ctx.reporter.errorsReported)
+          assert(reportCycles || ctx.reporter.errorsReported)
           throw CyclicReference(NoDenotation)
         }
       }