Less eager removal of type parameters from constraint

Previously, a unified or otherwise instantiated type parameter
would be removed from the constraint, i.e. if it was the
last parameter of its polytype to be instantiated, the polytype
would be dropped. This is a potential problem since it means
that the alias `param = instance` is forgetten whereas we might
still need it in the same subtype test sequence.

The solution is to wait with cleaning up polytypes until
an enclosing subtype test has been completely unwound.

Also: Generalize constraint solving to GenericTypes (will be
needed later for handling existentials).

Author: odersky

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

@@ -107,9 +107,12 @@ abstract class Constraint extends Showable {
    *  the type parameter `param` from the domain and replacing all top-level occurrences
    *  of the parameter elsewhere in the constraint by type `tp`, or a conservative
    *  approximation of it if that is needed to avoid cycles.
-   *  Occurrences nested inside a refinement or prefix are not affected.
+   *  Occurrences nested inside a refinement or prefix simply substituted instead
+   *  of being approximated.
+   *  If `canRemove` is true, `param` is removed from the domain of the resulting constraint.
+   *  If `canRemove` is false, `param = tp` is remembered as an alias.
    */
-  def replace(param: PolyParam, tp: Type)(implicit ctx: Context): This
+  def replace(param: PolyParam, tp: Type, canRemove: Boolean)(implicit ctx: Context): This
 
   /** Narrow one of the bounds of type parameter `param`
    *  If `isUpper` is true, ensure that `param <: `bound`, otherwise ensure

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

@@ -32,6 +32,8 @@ trait ConstraintHandling {
 
   private var addConstraintInvocations = 0
 
+  private var needsCleanup = false
+
   /** If the constraint is frozen we cannot add new bounds to the constraint. */
   protected var frozenConstraint = false
 
@@ -110,6 +112,7 @@ trait ConstraintHandling {
     assert(constraint.isLess(p1, p2))
     val down = constraint.exclusiveLower(p2, p1)
     val up = constraint.exclusiveUpper(p1, p2)
+    needsCleanup = true
     constraint = constraint.unify(p1, p2)
     val bounds = constraint.nonParamBounds(p1)
     val lo = bounds.lo
@@ -203,7 +206,7 @@ trait ConstraintHandling {
    *  and propagate all bounds.
    *  @param tvars   See Constraint#add
    */
-  def addToConstraint(pt: PolyType, tvars: List[TypeVar]): Unit =
+  def addToConstraint(pt: GenericType, tvars: List[TypeVar]): Unit =
     assert {
       checkPropagated(i"initialized $pt") {
         constraint = constraint.add(pt, tvars)
@@ -313,7 +316,10 @@ trait ConstraintHandling {
     val saved = constraint
     constraint =
       if (addConstraint(param, tp, fromBelow = true) &&
-          addConstraint(param, tp, fromBelow = false)) constraint.replace(param, tp)
+          addConstraint(param, tp, fromBelow = false)) {
+        needsCleanup = true
+        constraint.replace(param, tp, canRemove = false)
+      }
       else saved
     constraint ne saved
   }
@@ -337,4 +343,12 @@ trait ConstraintHandling {
     }
     result
   }
+
+  /** A new constraint with all polytypes that only have instantiated parameters removed */
+  protected def cleanup(): Unit =
+    if (needsCleanup) {
+      constraint =
+        (constraint /: constraint.domainPolys.filter(constraint.isRemovable(_)))(_.remove(_))
+      needsCleanup = false
+    }
 }

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

@@ -349,7 +349,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
   def unify(p1: PolyParam, p2: PolyParam)(implicit ctx: Context): This = {
     val p1Bounds = (nonParamBounds(p1) & nonParamBounds(p2)).substParam(p2, p1)
-    updateEntry(p1, p1Bounds).replace(p2, p1)
+    updateEntry(p1, p1Bounds).replace(p2, p1, canRemove = false)
   }
 
   def narrowBound(param: PolyParam, bound: Type, isUpper: Boolean)(implicit ctx: Context): This = {
@@ -387,7 +387,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
    *  would not find out where we need to approximate. Occurrences of parameters
    *  that are not top-level are not affected.
    */
-  def replace(param: PolyParam, tp: Type)(implicit ctx: Context): OrderingConstraint = {
+  def replace(param: PolyParam, tp: Type, canRemove: Boolean)(implicit ctx: Context): OrderingConstraint = {
     val replacement = tp.dealias.stripTypeVar
     if (param == replacement) this
     else {
@@ -428,7 +428,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       }
 
       var current =
-        if (isRemovable(poly, idx)) remove(poly) else updateEntry(param, replacement)
+        if (canRemove && isRemovable(poly, idx)) remove(poly) else updateEntry(param, replacement)
       current.foreachParam {(p, i) =>
         current = boundsLens.map(this, current, p, i, replaceParam(_, p, i))
         current = lowerLens.map(this, current, p, i, removeParam)

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

@@ -101,10 +101,12 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
           else monitoredIsSubType(tp1, tp2)
         recCount = recCount - 1
         if (!result) constraint = saved
-        else if (recCount == 0 && needsGc) {
-          state.gc()
-          needsGc = false
-        }
+        else if (recCount == 0)
+          cleanup()
+          if (needsGc) {
+            state.gc()
+            needsGc = false
+          }
         if (Stats.monitored) recordStatistics(result, savedSuccessCount)
         result
       } catch {

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

@@ -2866,7 +2866,7 @@ object Types {
       assert(ctx.typerState.constraint contains this) // !!! DEBUG
       if ((ctx.typerState eq owningState) && !ctx.typeComparer.subtypeCheckInProgress)
         inst = tp
-      ctx.typerState.constraint = ctx.typerState.constraint.replace(origin, tp)
+      ctx.typerState.constraint = ctx.typerState.constraint.replace(origin, tp, canRemove = true)
       tp
     }
 

src/dotty/tools/dotc/typer/ProtoTypes.scala

@@ -321,12 +321,12 @@ object ProtoTypes {
    *  Also, if `owningTree` is non-empty, add a type variable for each parameter.
    *  @return  The added polytype, and the list of created type variables.
    */
-  def constrained(pt: PolyType, owningTree: untpd.Tree)(implicit ctx: Context): (PolyType, List[TypeVar]) = {
+  def constrained(pt: GenericType, owningTree: untpd.Tree)(implicit ctx: Context): (GenericType, List[TypeVar]) = {
     val state = ctx.typerState
-    assert(!(ctx.typerState.isCommittable && owningTree.isEmpty),
+    assert(!(ctx.typerState.isCommittable && owningTree.isEmpty && pt.isInstanceOf[PolyType]),
       s"inconsistent: no typevars were added to committable constraint ${state.constraint}")
 
-    def newTypeVars(pt: PolyType): List[TypeVar] =
+    def newTypeVars(pt: GenericType): List[TypeVar] =
       for (n <- (0 until pt.paramNames.length).toList)
       yield new TypeVar(PolyParam(pt, n), state, owningTree, ctx.owner)
 
@@ -339,7 +339,7 @@ object ProtoTypes {
   }
 
   /**  Same as `constrained(pt, EmptyTree)`, but returns just the created polytype */
-  def constrained(pt: PolyType)(implicit ctx: Context): PolyType = constrained(pt, EmptyTree)._1
+  def constrained(pt: GenericType)(implicit ctx: Context): GenericType = constrained(pt, EmptyTree)._1
 
   /** The normalized form of a type
    *   - unwraps polymorphic types, tracking their parameters in the current constraint