Move instType to Constraint

Move instType from ConstraintHandling to Constraint. It does not rely on any
state in ConstraintHandling, but is a pure function of the current constraint.

Todo: Do the same for other TypeComparer functions with the same property.

Author: odersky

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

@@ -121,6 +121,13 @@ abstract class Constraint extends Showable {
   /** A new constraint with entry `tl` renamed to a fresh type lambda */
   def rename(tl: TypeLambda)(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
+   *  without also retracting the type var as a whole.
+   */
+  def instType(tvar: TypeVar): Type
+
   /** The given `tl` in case it is not contained in this constraint,
    *  a fresh copy of `tl` otherwise.
    */

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

@@ -61,19 +61,6 @@ trait ConstraintHandling {
     assert(homogenizeArgs == false)
     assert(comparedTypeLambdas == Set.empty)
 
-  /** 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
-   *  without also retracting the type var as a whole.
-   */
-  def instType(tvar: TypeVar): Type = constraint.entry(tvar.origin) match {
-    case _: TypeBounds => NoType
-    case tp: TypeParamRef =>
-      var tvar1 = constraint.typeVarOfParam(tp)
-      if (tvar1.exists) tvar1 else tp
-    case tp => tp
-  }
-
   def nonParamBounds(param: TypeParamRef)(using Context): TypeBounds = constraint.nonParamBounds(param)
 
   def fullLowerBound(param: TypeParamRef)(using Context): Type =

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

@@ -131,7 +131,7 @@ final class ProperGadtConstraint private(
   override def addBound(sym: Symbol, bound: Type, isUpper: Boolean)(using Context): Boolean = {
     @annotation.tailrec def stripInternalTypeVar(tp: Type): Type = tp match {
       case tv: TypeVar =>
-        val inst = instType(tv)
+        val inst = constraint.instType(tv)
         if (inst.exists) stripInternalTypeVar(inst) else tv
       case _ => tp
     }

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

@@ -530,6 +530,11 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     current.checkNonCyclic()
   }
 
+  def instType(tvar: TypeVar): Type = entry(tvar.origin) match
+    case _: TypeBounds => NoType
+    case tp: TypeParamRef => typeVarOfParam(tp).orElse(tp)
+    case tp => tp
+
   def ensureFresh(tl: TypeLambda)(using Context): TypeLambda =
     if (contains(tl)) {
       var paramInfos = tl.paramInfos

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

@@ -2605,9 +2605,6 @@ object TypeComparer {
   def subtypeCheckInProgress(using Context): Boolean =
     comparing(_.subtypeCheckInProgress)
 
-  def instType(tvar: TypeVar)(using Context): Type =
-    comparing(_.instType(tvar))
-
   def instanceType(param: TypeParamRef, fromBelow: Boolean)(using Context): Type =
     comparing(_.instanceType(param, fromBelow))
 

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

@@ -138,10 +138,11 @@ class TyperState() {
    *  no-longer needed constraint entries.
    */
   def gc()(using Context): Unit = {
+    Stats.record("typerState.gc")
     val toCollect = new mutable.ListBuffer[TypeLambda]
     constraint foreachTypeVar { tvar =>
       if (!tvar.inst.exists) {
-        val inst = TypeComparer.instType(tvar)
+        val inst = constraint.instType(tvar)
         if (inst.exists && (tvar.owningState.get eq this)) {
           tvar.inst = inst
           val lam = tvar.origin.binder

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

@@ -4192,7 +4192,7 @@ object Types {
      *  uninstantiated
      */
     def instanceOpt(using Context): Type =
-      if (inst.exists) inst else TypeComparer.instType(this)
+      if (inst.exists) inst else ctx.typerState.constraint.instType(this)
 
     /** Is the variable already instantiated? */
     def isInstantiated(using Context): Boolean = instanceOpt.exists