Refactor IsFullyDefinedAccumulator

Refactoring to make it clearer what it does

Author: odersky

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

@@ -46,7 +46,7 @@ object Inferencing {
   /** Instantiate selected type variables `tvars` in type `tp` */
   def instantiateSelected(tp: Type, tvars: List[Type])(implicit ctx: Context): Unit =
     if (tvars.nonEmpty)
-      new IsFullyDefinedAccumulator(new ForceDegree.Value(tvars.contains, minimizeAll = true, allowBottom = false)).process(tp)
+      new IsFullyDefinedAccumulator(new ForceDegree.Value(tvars.contains, minimizeAll = true)).process(tp)
 
   /** Instantiate any type variables in `tp` whose bounds contain a reference to
    *  one of the parameters in `tparams` or `vparamss`.
@@ -90,7 +90,8 @@ object Inferencing {
    *  2nd Phase: If first phase was successful, instantiate all remaining type variables
    *  to their upper bound.
    */
-  private class IsFullyDefinedAccumulator(force: ForceDegree.Value)(implicit ctx: Context) extends TypeAccumulator[Boolean] {
+  private class IsFullyDefinedAccumulator(force: ForceDegree.Value, minimizeConstrained: Boolean = false)
+    (implicit ctx: Context) extends TypeAccumulator[Boolean] {
 
     private def instantiate(tvar: TypeVar, fromBelow: Boolean): Type = {
       val inst = tvar.instantiate(fromBelow)
@@ -108,14 +109,23 @@ object Inferencing {
         && ctx.typerState.constraint.contains(tvar)
         && {
           val direction = instDirection(tvar.origin)
-          def preferMin =
-            force.minimizeAll && (tvar.hasLowerBound || !tvar.hasUpperBound)
-            || variance >= 0 && (force.allowBottom || tvar.hasLowerBound)
-          if (direction != 0) instantiate(tvar, direction < 0)
-          else if (preferMin)
-            if force.minimizeAll && !tvar.hasLowerBound then () // do nothing
-            else instantiate(tvar, fromBelow = true)
-          else toMaximize = tvar :: toMaximize
+          direction match
+            case Covariant =>
+              instantiate(tvar, fromBelow = true)
+            case Contravariant =>
+              instantiate(tvar, fromBelow = false)
+            case EmptyFlags =>
+              if force.minimizeAll then
+                if tvar.hasLowerBound then instantiate(tvar, fromBelow = true)
+                else if tvar.hasUpperBound then instantiate(tvar, fromBelow = false)
+                else () // hold off instantiating unbounded unconstrained variables
+              else if variance >= 0 && (force.allowBottom || tvar.hasLowerBound)
+              then instantiate(tvar, fromBelow = true)
+              else toMaximize = tvar :: toMaximize
+            case VarianceFlags =>
+              if force.minimizeAll || variance >= 0
+              then instantiate(tvar, fromBelow = true)
+              else toMaximize = tvar :: toMaximize
           foldOver(x, tvar)
         }
       case tp =>
@@ -220,20 +230,21 @@ object Inferencing {
   }
 
   /** The instantiation direction for given poly param computed
-   *  from the constraint:
-   *  @return   1 (maximize) if constraint is uniformly from above,
-   *           -1 (minimize) if constraint is uniformly from below,
-   *            0 if unconstrained, or constraint is from below and above.
+   *  from the constraint, given as a flag subset of {Covariant, Contravariant}.
+   *  @return a subset of {Covariant, Contravariant} that contains
+   *      Covarant (minimize)        if there is a constraint from below that is not subsumed
+   *                                 by the lower bound
+   *      Contravariant (maximize)   if there is a constraint from above that is not subsumed
+   *                                 by the uppwe bound
    */
-  private def instDirection(param: TypeParamRef)(implicit ctx: Context): Int = {
+  private def instDirection(param: TypeParamRef)(implicit ctx: Context): FlagSet = {
     val constrained = ctx.typeComparer.fullBounds(param)
     val original = param.binder.paramInfos(param.paramNum)
     val cmp = ctx.typeComparer
-    val approxBelow =
-      if (!cmp.isSubTypeWhenFrozen(constrained.lo, original.lo)) 1 else 0
-    val approxAbove =
-      if (!cmp.isSubTypeWhenFrozen(original.hi, constrained.hi)) 1 else 0
-    approxAbove - approxBelow
+    var flags = EmptyFlags
+    if !cmp.isSubTypeWhenFrozen(constrained.lo, original.lo) then flags |= Covariant
+    if !cmp.isSubTypeWhenFrozen(original.hi, constrained.hi) then flags |= Contravariant
+    flags
   }
 
   /** Following type aliases and stripping refinements and annotations, if one arrives at a