Address review suggestions

Author: odersky

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

@@ -1781,34 +1781,30 @@ 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 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
+    else
+      def mergedLub(tp1: Type, tp2: Type): 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(tp1.stripLazyRef, tp2.stripLazyRef)
   }
 
   /** The least upper bound of a list of types */

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

@@ -1044,14 +1044,15 @@ object Types {
       case _ => this
     }
 
-    /** Strip PolyType prefix */
+    /** Strip PolyType prefixes */
     def stripPoly(implicit ctx: Context): Type = this match {
       case tp: PolyType => tp.resType.stripPoly
       case _ => this
     }
 
+    /** Strip LazyRef wrappers */
     def stripLazyRef(given Context): Type = this match
-      case lzy: LazyRef => lzy.ref
+      case lzy: LazyRef => lzy.ref.stripLazyRef
       case _ => this
 
     /** Widen from singleton type to its underlying non-singleton
@@ -1170,7 +1171,7 @@ object Types {
      *  these types as a set, otherwise the empty set.
      *  Overridden and cached in OrType.
      *  @param widenOK  If type proxies that are upperbounded by types with atoms
-     *                  have the same atoms. 
+     *                  have the same atoms.
      */
     def atoms(widenOK: Boolean = false)(implicit ctx: Context): Set[Type] = dealias match {
       case tp: SingletonType =>
@@ -4325,7 +4326,7 @@ object Types {
       if ((prefix eq this.prefix) && (classParents eq this.classParents) && (decls eq this.decls) && (selfInfo eq this.selfInfo)) this
       else newLikeThis(prefix, classParents, decls, selfInfo)
 
-    /** If this class has opqque type alias members, a new class info
+    /** If this class has opaque type alias members, a new class info
      *  with their aliases added as refinements to the self type of the class.
      *  Otherwise, this classInfo.
      *  If there are opaque alias members, updates `cls` to have `Opaque` flag as a side effect.