Further tweaks to isFullyDefinedAccumulator

Author: odersky

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

@@ -555,17 +555,17 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
 
     val childTp = if (child.isTerm) child.termRef else child.typeRef
 
-    instantiate(childTp, parent)(ctx.fresh.setNewTyperState()).dealias
+    instantiateToSubType(childTp, parent)(ctx.fresh.setNewTyperState()).dealias
   }
 
   /** Instantiate type `tp1` to be a subtype of `tp2`
    *
-   *  Return the instantiated type if type parameters and this type
+   *  Return the instantiated type if type parameters in this type
    *  in `tp1` can be instantiated such that `tp1 <:< tp2`.
    *
    *  Otherwise, return NoType.
    */
-  private def instantiate(tp1: NamedType, tp2: Type)(implicit ctx: Context): Type = {
+  private def instantiateToSubType(tp1: NamedType, tp2: Type)(implicit ctx: Context): Type = {
     /** expose abstract type references to their bounds or tvars according to variance */
     class AbstractTypeMap(maximize: Boolean)(implicit ctx: Context) extends TypeMap {
       def expose(lo: Type, hi: Type): Type =
@@ -637,7 +637,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       tvar =>
         !(ctx.typerState.constraint.entry(tvar.origin) `eq` tvar.origin.underlying) ||
         (tvar `eq` removeThisType.prefixTVar),
-      minimizeAll = false,
       allowBottom = false
     )
 

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

@@ -46,7 +46,9 @@ 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)).process(tp)
+      IsFullyDefinedAccumulator(
+        ForceDegree.Value(tvars.contains, allowBottom = false), minimizeSelected = true
+      ).process(tp)
 
   /** Instantiate any type variables in `tp` whose bounds contain a reference to
    *  one of the parameters in `tparams` or `vparamss`.
@@ -78,19 +80,26 @@ object Inferencing {
    *   2. T is maximized if the constraint over T is only from above (i.e.
    *      constrained upper bound != given upper bound and
    *      constrained lower bound == given lower bound).
-   *  If (1) and (2) do not apply:
-   *   3. T is minimized if forceDegree is minimizeAll.
-   *   4. Otherwise, T is maximized if it appears only contravariantly in the given type,
-   *      or if forceDegree is `noBottom` and T's minimized value is a bottom type.
-   *   5. Otherwise, T is minimized.
    *
-   *  The instantiation is done in two phases:
+   *  If (1) and (2) do not apply, and minimizeSelected is set:
+   *   3. T is minimized if it has a lower bound (different from Nothing) in the
+   *      current constraint (the bound might come from T's declaration).
+   *   4. Otherwise, T is maximized if it has an upper bound (different from Any)
+   *      in the currented constraint (the bound might come from T's declaration).
+   *   5. Otherwise, T is not instantiated at all.
+
+   *  If (1) and (2) do not apply, and minimizeSelected is not set:
+   *   6: T is maximized if it appears only contravariantly in the given type,
+   *      or if forceDegree is `noBottom` and T has no lower bound different from Nothing.
+   *   7. Otherwise, T is minimized.
+   *
+   *  The instantiation for (6) and (7) is done in two phases:
    *  1st Phase: Try to instantiate minimizable type variables to
    *  their lower bound. Record whether successful.
    *  2nd Phase: If first phase was successful, instantiate all remaining type variables
    *  to their upper bound.
    */
-  private class IsFullyDefinedAccumulator(force: ForceDegree.Value, minimizeConstrained: Boolean = false)
+  private class IsFullyDefinedAccumulator(force: ForceDegree.Value, minimizeSelected: Boolean = false)
     (implicit ctx: Context) extends TypeAccumulator[Boolean] {
 
     private def instantiate(tvar: TypeVar, fromBelow: Boolean): Type = {
@@ -115,15 +124,15 @@ object Inferencing {
             case Contravariant =>
               instantiate(tvar, fromBelow = false)
             case EmptyFlags =>
-              if force.minimizeAll then
+              if minimizeSelected 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
+              if minimizeSelected || variance >= 0
               then instantiate(tvar, fromBelow = true)
               else toMaximize = tvar :: toMaximize
           foldOver(x, tvar)
@@ -500,9 +509,9 @@ trait Inferencing { this: Typer =>
 
 /** An enumeration controlling the degree of forcing in "is-dully-defined" checks. */
 @sharable object ForceDegree {
-  class Value(val appliesTo: TypeVar => Boolean, val minimizeAll: Boolean, val allowBottom: Boolean = true)
-  val none: Value = new Value(_ => false, minimizeAll = false)
-  val all: Value = new Value(_ => true, minimizeAll = false)
-  val noBottom: Value = new Value(_ => true, minimizeAll = false, allowBottom = false)
+  class Value(val appliesTo: TypeVar => Boolean, val allowBottom: Boolean)
+  val none: Value = new Value(_ => false, allowBottom = true)
+  val all: Value = new Value(_ => true, allowBottom = true)
+  val noBottom: Value = new Value(_ => true, allowBottom = false)
 }