Polishings

 - `ctx.harmonizeUnion(tp)` now becomes `tp.widenUnion`.
 - Same order of operations in local type inference of Namer
and type variable instantiation. First, simplify, then widen,
then widenUnion.

Author: odersky

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

@@ -258,21 +258,19 @@ trait ConstraintHandling {
     }
 
     // First, solve the constraint.
-    var inst = approximation(param, fromBelow)
+    var inst = approximation(param, fromBelow).simplified
 
     // Then, approximate by (1.) - (3.) and simplify as follows.
     // 1. If instance is from below and is a singleton type, yet
     // upper bound is not a singleton type, widen the instance.
     if (fromBelow && isSingleton(inst) && !isSingleton(upperBound))
       inst = inst.widen
 
-    inst = inst.simplified
-
     // 2. If instance is from below and is a fully-defined union type, yet upper bound
     // is not a union type, approximate the union type from above by an intersection
     // of all common base types.
-    if (fromBelow && isOrType(inst) && /*isFullyDefined(inst) &&*/ !isOrType(upperBound))
-      inst = ctx.harmonizeUnion(inst)
+    if (fromBelow && isOrType(inst) && !isOrType(upperBound))
+      inst = inst.widenUnion
 
     inst
   }

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

@@ -331,7 +331,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       else thirdTry(tp1, tp2)
     case tp1 @ OrType(tp11, tp12) =>
       def joinOK = tp2.dealias match {
-        case tp12: HKApply =>
+        case _: HKApply =>
           // If we apply the default algorithm for `A[X] | B[Y] <: C[Z]` where `C` is a
           // type parameter, we will instantiate `C` to `A` and then fail when comparing
           // with `B[Y]`. To do the right thing, we need to instantiate `C` to the

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

@@ -273,37 +273,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     }
   }
 
-  /** Given a disjunction T1 | ... | Tn of types with potentially embedded
-   *  type variables, constrain type variables further if this eliminates
-   *  some of the branches of the disjunction. Do this also for disjunctions
-   *  embedded in intersections, as parents in refinements, and in recursive types.
-   *
-   *  For instance, if `A` is an unconstrained type variable, then
-   *
-   *      ArrayBuffer[Int] | ArrayBuffer[A]
-   *
-   *  is approximated by constraining `A` to be =:= to `Int` and returning `ArrayBuffer[Int]`
-   *  instead of `ArrayBuffer[_ >: Int | A <: Int & A]`
-   */
-  def harmonizeUnion(tp: Type): Type = tp match {
-    case tp: OrType =>
-      joinIfScala2(ctx.typeComparer.lub(harmonizeUnion(tp.tp1), harmonizeUnion(tp.tp2), canConstrain = true))
-    case tp @ AndType(tp1, tp2) =>
-      tp derived_& (harmonizeUnion(tp1), harmonizeUnion(tp2))
-    case tp: RefinedType =>
-      tp.derivedRefinedType(harmonizeUnion(tp.parent), tp.refinedName, tp.refinedInfo)
-    case tp: RecType =>
-      tp.rebind(harmonizeUnion(tp.parent))
-    case _ =>
-      tp
-  }
-
-  /** Under -language:Scala2: Replace or-types with their joins */
-  private def joinIfScala2(tp: Type) = tp match {
-    case tp: OrType => tp.join
-    case _ => tp
-  }
-
   /** Not currently needed:
    *
   def liftToRec(f: (Type, Type) => Type)(tp1: Type, tp2: Type)(implicit ctx: Context) = {

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

@@ -872,6 +872,35 @@ object Types {
       case _ => this
     }
 
+    /** If this type contains embedded union types, replace them by their joins.
+     *  "Embedded" means: inside intersectons or recursive types, or in prefixes of refined types.
+     *  If an embedded union is found, we first try to simplify or eliminate it by
+     *  re-lubbing it while allowing type parameters to be constrained further.
+     *  Any remaining union types are replaced by their joins.
+     *
+	   *  For instance, if `A` is an unconstrained type variable, then
+  	 *
+  	 * 	      ArrayBuffer[Int] | ArrayBuffer[A]
+  	 *
+     *  is approximated by constraining `A` to be =:= to `Int` and returning `ArrayBuffer[Int]`
+     *  instead of `ArrayBuffer[_ >: Int | A <: Int & A]`
+     */
+    def widenUnion(implicit ctx: Context): Type = this match {
+      case OrType(tp1, tp2) =>
+        ctx.typeComparer.lub(tp1.widenUnion, tp2.widenUnion, canConstrain = true) match {
+          case union: OrType => union.join
+          case res => res
+        }
+      case tp @ AndType(tp1, tp2) =>
+        tp derived_& (tp1.widenUnion, tp2.widenUnion)
+      case tp: RefinedType =>
+        tp.derivedRefinedType(tp.parent.widenUnion, tp.refinedName, tp.refinedInfo)
+      case tp: RecType =>
+        tp.rebind(tp.parent.widenUnion)
+      case _ =>
+        this
+    }
+
     /** Eliminate anonymous classes */
     final def deAnonymize(implicit ctx: Context): Type = this match {
       case tp:TypeRef if tp.symbol.isAnonymousClass =>

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -1034,13 +1034,13 @@ class Namer { typer: Typer =>
       // println(s"owner = ${sym.owner}, decls = ${sym.owner.info.decls.show}")
       def isInline = sym.is(FinalOrInline, butNot = Method | Mutable)
 
-      // Widen rhs type and approximate `|' but keep ConstantTypes if
+      // Widen rhs type and eliminate `|' but keep ConstantTypes if
       // definition is inline (i.e. final in Scala2) and keep module singleton types
       // instead of widening to the underlying module class types.
       def widenRhs(tp: Type): Type = tp.widenTermRefExpr match {
         case ctp: ConstantType if isInline => ctp
         case ref: TypeRef if ref.symbol.is(ModuleClass) => tp
-        case _ => ctx.harmonizeUnion(tp.widen)
+        case _ => tp.widen.widenUnion
       }
 
       // Replace aliases to Unit by Unit itself. If we leave the alias in