Streamline TypeComparer/ConstraintHandling interface.

2 files changed, 13 insertions, 21 deletions

diff --git a/src/dotty/tools/dotc/core/ConstraintHandling.scala b/src/dotty/tools/dotc/core/ConstraintHandling.scala
index 28a0c87a2..692039b70 100644
--- a/src/dotty/tools/dotc/core/ConstraintHandling.scala
+++ b/src/dotty/tools/dotc/core/ConstraintHandling.scala
@@ -203,8 +203,7 @@ trait ConstraintHandling {
     case _ => param.binder.paramBounds(param.paramNum)
   }
   
-  def initialize(pt: PolyType): Boolean = {
-    //println(i"INIT**! $pt")
+  def initialize(pt: PolyType): Boolean =
     checkPropagated(i"initialized $pt") {
       pt.paramNames.indices.forall { i =>
         val param = PolyParam(pt, i)
@@ -217,14 +216,8 @@ trait ConstraintHandling {
           upper.forall(addOneLowerBound(_, bounds.lo))
       }
     }
-  }
-
-  protected def constraintImpliesSub(param: PolyParam, tp: Type): Boolean = 
-    isSubTypeWhenFrozen(bounds(param).hi, tp)
-
-  protected def constraintImpliesSuper(param: PolyParam, tp: Type): Boolean = 
-    isSubTypeWhenFrozen(tp, bounds(param).lo)
 
+  /** Can `param` be constrained with new bounds? */
   final def canConstrain(param: PolyParam): Boolean =
     !frozenConstraint && (constraint contains param)
 
@@ -249,6 +242,7 @@ trait ConstraintHandling {
     }
   }
    
+  /** Check that constraint is fully propagated. See comment in Config.checkConstraintsPropagated */
   def checkPropagated(msg: => String)(result: Boolean): Boolean = {
     if (Config.checkConstraintsPropagated && result && addConstraintInvocations == 0) {
       frozenConstraint = true
diff --git a/src/dotty/tools/dotc/core/TypeComparer.scala b/src/dotty/tools/dotc/core/TypeComparer.scala
index 292c83a6d..3e6f59939 100644
--- a/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -244,9 +244,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
       }
     case tp1: PolyParam =>
       def flagNothingBound = {
-        if ((!frozenConstraint) &&
-          (tp2 isRef defn.NothingClass) &&
-          state.isGlobalCommittable) {
+        if (!frozenConstraint && tp2.isRef(defn.NothingClass) && state.isGlobalCommittable) {
           def msg = s"!!! instantiated to Nothing: $tp1, constraint = ${constraint.show}"
           if (Config.flagInstantiationToNothing) assert(false, msg)
           else ctx.log(msg)
@@ -255,10 +253,10 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
       }
       def comparePolyParam =
         (ctx.mode is Mode.TypevarsMissContext) ||
-          constraintImpliesSub(tp1, tp2) || {
-            if (canConstrain(tp1)) addConstraint(tp1, tp2, fromBelow = false) && flagNothingBound
-            else thirdTry(tp1, tp2)
-          }
+        isSubTypeWhenFrozen(bounds(tp1).hi, tp2) || {
+          if (canConstrain(tp1)) addConstraint(tp1, tp2, fromBelow = false) && flagNothingBound
+          else thirdTry(tp1, tp2)
+        }
       comparePolyParam
     case tp1: ThisType =>
       tp2 match {
@@ -320,10 +318,10 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
     case tp2: PolyParam =>
       def comparePolyParam =
         (ctx.mode is Mode.TypevarsMissContext) ||
-          constraintImpliesSuper(tp2, tp1) || {
-            if (canConstrain(tp2)) addConstraint(tp2, tp1.widenExpr, fromBelow = true)
-            else fourthTry(tp1, tp2)
-          }
+        isSubTypeWhenFrozen(tp1, bounds(tp2).lo) || {
+          if (canConstrain(tp2)) addConstraint(tp2, tp1.widenExpr, fromBelow = true)
+          else fourthTry(tp1, tp2)
+        }
       comparePolyParam
     case tp2: RefinedType =>
       def compareRefined: Boolean = {
@@ -413,7 +411,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
             val gbounds1 = ctx.gadt.bounds(tp1.symbol)
             (gbounds1 != null) &&
               (isSubTypeWhenFrozen(gbounds1.hi, tp2) ||
-              narrowGADTBounds(tp1, tp2, isLowerBound = false))
+               narrowGADTBounds(tp1, tp2, isLowerBound = false))
           }
           isSubType(hi1, tp2) || compareGADT
         case _ =>