Fixing glb/lub of TypeBounds

Need to take variances into account when forming & or | of bounds. Achieved by moving code from distributeAnd/Or to TypeBounds &/|.

Author: odersky

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

@@ -720,7 +720,7 @@ class TypeComparer(initctx: Context) extends DotClass {
     else isSubType(tp1, tp2) && isSubType(tp2, tp1)
 
   /** The greatest lower bound of two types */
-  def glb(tp1: Type, tp2: Type): Type =
+  def glb(tp1: Type, tp2: Type): Type = /*>|>*/ ctx.traceIndented(s"glb(${tp1.show}, ${tp2.show})", typr, show = true) /*<|<*/ {
     if (tp1 eq tp2) tp1
     else if (!tp1.exists) tp2
     else if (!tp2.exists) tp1
@@ -743,6 +743,7 @@ class TypeComparer(initctx: Context) extends DotClass {
             }
         }
     }
+  }
 
   /** The greatest lower bound of a list types */
   final def glb(tps: List[Type]): Type =
@@ -870,17 +871,10 @@ class TypeComparer(initctx: Context) extends DotClass {
 
   /** Try to distribute `&` inside type, detect and handle conflicts */
   private def distributeAnd(tp1: Type, tp2: Type): Type = tp1 match {
-    case tp1 @ TypeBounds(lo1, hi1) =>
+    case tp1: TypeBounds =>
       tp2 match {
-        case tp2 @ TypeBounds(lo2, hi2) =>
-          if ((lo1 eq hi1) && (lo2 eq hi2)) {
-            val v = tp1 commonVariance tp2
-            if (v > 0) return TypeAlias(hi1 & hi2, v)
-            if (v < 0) return TypeAlias(lo1 | lo2, v)
-          }
-          TypeBounds(lo1 | lo2, hi1 & hi2)
-        case _ =>
-          andConflict(tp1, tp2)
+        case tp2: TypeBounds => tp1 & tp2
+        case _ => andConflict(tp1, tp2)
       }
     case tp1: ClassInfo =>
       tp2 match {
@@ -944,17 +938,10 @@ class TypeComparer(initctx: Context) extends DotClass {
 
   /** Try to distribute `|` inside type, detect and handle conflicts */
   private def distributeOr(tp1: Type, tp2: Type): Type = tp1 match {
-    case tp1 @ TypeBounds(lo1, hi1) =>
+    case tp1: TypeBounds =>
       tp2 match {
-        case tp2 @ TypeBounds(lo2, hi2) =>
-          if ((lo1 eq hi1) && (lo2 eq hi2)) {
-            val v = tp1 commonVariance tp2
-            if (v > 0) return TypeAlias(hi1 | hi2, v)
-            if (v < 0) return TypeAlias(lo1 & lo2, v)
-          }
-          TypeBounds(lo1 & lo2, hi1 | hi2)
-        case _ =>
-          orConflict(tp1, tp2)
+        case tp2: TypeBounds => tp1 | tp2
+        case _ => orConflict(tp1, tp2)
       }
     case tp1: ClassInfo =>
       tp2 match {

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

@@ -1883,11 +1883,21 @@ object Types {
 
     def contains(tp: Type)(implicit ctx: Context) = lo <:< tp && tp <:< hi
 
-    def & (that: TypeBounds)(implicit ctx: Context): TypeBounds =
-      derivedTypeBounds(this.lo | that.lo, this.hi & that.hi, this commonVariance that)
+    def & (that: TypeBounds)(implicit ctx: Context): TypeBounds = {
+      val v = this commonVariance that
+      if (v != 0 && (this.lo eq this.hi) && (that.lo eq that.hi))
+        if (v > 0) derivedTypeAlias(this.hi & that.hi, v)
+        else derivedTypeAlias(this.lo | that.lo, v)
+      else derivedTypeBounds(this.lo | that.lo, this.hi & that.hi, v)
+    }
 
-    def | (that: TypeBounds)(implicit ctx: Context): TypeBounds =
-      derivedTypeBounds(this.lo & that.lo, this.hi | that.hi, this commonVariance that)
+    def | (that: TypeBounds)(implicit ctx: Context): TypeBounds = {
+      val v = this commonVariance that
+      if (v == 0 && (this.lo eq this.hi) && (that.lo eq that.hi))
+        if (v > 0) derivedTypeAlias(this.hi | that.hi, v)
+        else derivedTypeAlias(this.lo & that.lo, v)
+      else derivedTypeBounds(this.lo & that.lo, this.hi | that.hi, v)
+    }
 
     override def & (that: Type)(implicit ctx: Context) = that match {
       case that: TypeBounds => this & that