Move hardenTypeVars into Constraint, so it can be reused

Author: dwijnand

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

@@ -138,6 +138,9 @@ abstract class Constraint extends Showable {
   /** The same as this constraint, but with `tv` marked as hard. */
   def withHard(tv: TypeVar)(using Context): This
 
+  /** Mark toplevel type vars in `tp` as hard. */
+  def hardenTypeVars(tp: Type)(using Context): This
+
   /** Gives for each instantiated type var that does not yet have its `inst` field
    *  set, the instance value stored in the constraint. Storing instances in constraints
    *  is done only in a temporary way for contexts that may be retracted

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

@@ -751,6 +751,12 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       current.checkWellFormed()
   end replace
 
+  def hardenTypeVars(tp: Type)(using Context): OrderingConstraint = tp.dealiasKeepRefiningAnnots match
+    case tp: TypeVar if contains(tp.origin) => withHard(tp)
+    case tp: TypeParamRef if contains(tp)   => hardenTypeVars(typeVarOfParam(tp))
+    case tp: AndOrType                      => hardenTypeVars(tp.tp1).hardenTypeVars(tp.tp2)
+    case _                                  => this
+
   def remove(pt: TypeLambda)(using Context): This = {
     def removeFromOrdering(po: ParamOrdering) = {
       def removeFromBoundss(key: TypeLambda, bndss: Array[List[TypeParamRef]]): Array[List[TypeParamRef]] = {

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

@@ -501,17 +501,6 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             false
         }
 
-        /** Mark toplevel type vars in `tp2` as hard in the current constraint */
-        def hardenTypeVars(tp2: Type): Unit = tp2.dealiasKeepRefiningAnnots match
-          case tvar: TypeVar if constraint.contains(tvar.origin) =>
-            constraint = constraint.withHard(tvar)
-          case tp2: TypeParamRef if constraint.contains(tp2) =>
-            hardenTypeVars(constraint.typeVarOfParam(tp2))
-          case tp2: AndOrType =>
-            hardenTypeVars(tp2.tp1)
-            hardenTypeVars(tp2.tp2)
-          case _ =>
-
         val res = widenOK || joinOK
           || recur(tp11, tp2) && recur(tp12, tp2)
           || containsAnd(tp1)
@@ -534,7 +523,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           // is marked so that it converts all soft unions in its lower bound to hard unions
           // before it is instantiated. The reason is that the variable's instance type will
           // be a supertype of (decomposed and reconstituted) `tp1`.
-          hardenTypeVars(tp2)
+          constraint = constraint.hardenTypeVars(tp2)
 
         res