More efficient garbage collection of type variables

When narrowing a constraint, we check if its bounds are now equal to
remove it from the constraint set. This allows the corresponding type
variable to be instantiated in TyperState#gc instead of accumulating
uninstantiated type variables that we traverse again and again in
Inferencing#interpolateTypeVars.

This reduces the running time of the added testcase (copied from
scala/scala#6580) from ~6 seconds to ~4 seconds.
If we fully uncomment the testcase (and increase the JVM stack size),
the running time goes from > 300 seconds to ~24 seconds. This is not as
good as what scala/scala#6580 achieves but is
already much more reasonable that what we did before.

Author: smarter

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

@@ -63,29 +63,34 @@ trait ConstraintHandling {
       }
       if (Config.checkConstraintsSeparated)
         assert(!occursIn(bound), s"$param occurs in $bound")
-      val newBound = narrowedBound(param, bound, isUpper)
-      val c1 = constraint.updateEntry(param, newBound)
-      (c1 eq constraint) || {
-        constraint = c1
-        val TypeBounds(lo, hi) = constraint.entry(param)
-        isSubType(lo, hi)
+
+      val oldBounds @ TypeBounds(lo, hi) = constraint.nonParamBounds(param)
+      if (isUpper && (lo eq bound) || !isUpper && (bound eq hi)) {
+        // The narrowed bounds are equal, so we can remove `param` from the constraint
+        constraint = constraint.replace(param, bound)
+        true
+      }
+      else {
+        // Narrow one of the bounds of type parameter `param`
+        // If `isUpper` is true, ensure that `param <: `bound`, otherwise ensure
+        // that `param >: bound`.
+        val narrowedBounds = {
+          val saved = homogenizeArgs
+          homogenizeArgs = Config.alignArgsInAnd
+          try
+            if (isUpper) oldBounds.derivedTypeBounds(lo, hi & bound)
+            else oldBounds.derivedTypeBounds(lo | bound, hi)
+          finally homogenizeArgs = saved
+        }
+        val c1 = constraint.updateEntry(param, narrowedBounds)
+        (c1 eq constraint) || {
+          constraint = c1
+          val TypeBounds(lo, hi) = constraint.entry(param)
+          isSubType(lo, hi)
+        }
       }
     }
 
-  /** Narrow one of the bounds of type parameter `param`
-   *  If `isUpper` is true, ensure that `param <: `bound`, otherwise ensure
-   *  that `param >: bound`.
-   */
-  def narrowedBound(param: TypeParamRef, bound: Type, isUpper: Boolean)(implicit ctx: Context): TypeBounds = {
-    val oldBounds @ TypeBounds(lo, hi) = constraint.nonParamBounds(param)
-    val saved = homogenizeArgs
-    homogenizeArgs = Config.alignArgsInAnd
-    try
-      if (isUpper) oldBounds.derivedTypeBounds(lo, hi & bound)
-      else oldBounds.derivedTypeBounds(lo | bound, hi)
-    finally homogenizeArgs = saved
-  }
-
   private def location(implicit ctx: Context) = "" // i"in ${ctx.typerState.stateChainStr}" // use for debugging
 
   protected def addUpperBound(param: TypeParamRef, bound: Type): Boolean = {