Parameterize Constraint with constrained VarRef

Author: Aleksander Boruch-Gruszecki

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

@@ -5,11 +5,6 @@ package core
 import Types._, Contexts._
 import printing.Showable
 
-object Constraint {
-  type VarRef = TypeVarRef
-  type Binder = TypeVarRefBinder
-}
-
 /** Constraint over undetermined type parameters. Constraints are built
  *  over values of the following types:
  *
@@ -18,19 +13,17 @@ object Constraint {
  *   - TypeVar       Every constrained parameter might be associated with a TypeVar
  *                   that has the TypeParamRef as origin.
  */
-abstract class Constraint extends Showable {
-  import Constraint._
-
-  type This <: Constraint
+abstract class Constraint[VarRef <: TypeVarRef, RefBinder <: TypeVarRefBinder] extends Showable {
+  type This <: Constraint[VarRef, RefBinder]
 
   /** Does the constraint's domain contain the type parameters of `pt`? */
-  def contains(pt: Binder): Boolean
+  def contains(pt: RefBinder): Boolean
 
   /** Does the constraint's domain contain the type parameter `param`? */
   def contains(param: VarRef): Boolean
 
   /** Does this constraint contain the type variable `tvar` and is it uninstantiated? */
-  def contains(tvar: TypeVar): Boolean
+  def contains(tvar: TypeVarHandle[VarRef]): Boolean
 
   /** The constraint entry for given type parameter `param`, or NoType if `param` is not part of
    *  the constraint domain. Note: Low level, implementation dependent.
@@ -80,7 +73,7 @@ abstract class Constraint extends Showable {
    *                 satisfiability but will solved to give instances of
    *                 type variables.
    */
-  def add(poly: Binder, tvars: List[TypeVar])(implicit ctx: Context): This
+  def add(poly: RefBinder, tvars: List[TypeVarHandle[VarRef]])(implicit ctx: Context): This
 
   /** A new constraint which is derived from this constraint by updating
    *  the entry for parameter `param` to `tp`.
@@ -116,13 +109,13 @@ abstract class Constraint extends Showable {
    *  all type parameters of the entry are associated with type variables
    *  which have their `inst` fields set.
    */
-  def isRemovable(pt: Binder): Boolean
+  def isRemovable(pt: RefBinder): Boolean
 
   /** A new constraint with all entries coming from `pt` removed. */
-  def remove(pt: Binder)(implicit ctx: Context): This
+  def remove(pt: RefBinder)(implicit ctx: Context): This
 
   /** The type lambdas constrained by this constraint */
-  def domainLambdas: List[Binder]
+  def domainLambdas: List[RefBinder]
 
   /** The type lambda parameters constrained by this constraint */
   def domainParams: List[VarRef]
@@ -143,7 +136,7 @@ abstract class Constraint extends Showable {
    *                           returning an approximate constraint, instead of
    *                           failing with an exception
    */
-  def & (other: Constraint, otherHasErrors: Boolean)(implicit ctx: Context): Constraint
+  def & (other: Constraint[VarRef, RefBinder], otherHasErrors: Boolean)(implicit ctx: Context): Constraint[VarRef, RefBinder]
 
   /** Check that no constrained parameter contains itself as a bound */
   def checkNonCyclic()(implicit ctx: Context): Unit

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

@@ -18,19 +18,22 @@ import config.Printers.{constr, typr}
  * By comparison: Constraint handlers are parts of type comparers and can use their functionality.
  * Constraint handlers update the current constraint as a side effect.
  */
-trait ConstraintHandling {
-  import Constraint._
+trait ConstraintHandling[VarRef <: TypeVarRef.Of[VarRef, RefBinder], RefBinder <: TypeVarRefBinder.Of[VarRef, RefBinder]] {
+  protected final type OwnConstraint = Constraint[VarRef, RefBinder]
 
-  def constr_println(msg: => String): Unit = constr.println(msg)
-  def typr_println(msg: => String): Unit = typr.println(msg)
+  protected def isVarRef(r: Type): Boolean = r.isInstanceOf[TypeVarRef]
+  protected def isRefBinder(r: Type): Boolean = r.isInstanceOf[TypeVarRefBinder]
+
+  protected def constr_println(msg: => String): Unit = constr.println(msg)
+  protected def typr_println(msg: => String): Unit = typr.println(msg)
 
   implicit def ctx: Context
 
   protected def isSubType(tp1: Type, tp2: Type): Boolean
   protected def isSameType(tp1: Type, tp2: Type): Boolean
 
-  protected def constraint: Constraint
-  protected def constraint_=(c: Constraint): Unit
+  protected def constraint: OwnConstraint
+  protected def constraint_=(c: OwnConstraint): Unit
 
   private[this] var addConstraintInvocations = 0
 
@@ -59,9 +62,10 @@ trait ConstraintHandling {
     *  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 {
+  def instType(tvar: TypeVarHandle[VarRef]): Type = constraint.entry(tvar.origin) match {
     case _: TypeBounds => NoType
-    case tp: VarRef =>
+    case tp_ if isVarRef(tp_) =>
+      val tp = tp_.asInstanceOf[VarRef]
       var tvar1 = constraint.typeVarOfParam(tp)
       if (tvar1.exists) tvar1 else tp
     case tp => tp
@@ -284,9 +288,9 @@ trait ConstraintHandling {
       case tp: SingletonType => true
       case AndType(tp1, tp2) => isMultiSingleton(tp1) | isMultiSingleton(tp2)
       case OrType(tp1, tp2) => isMultiSingleton(tp1) & isMultiSingleton(tp2)
-      case tp: TypeRef if !constraint.contains(tp : VarRef) => isMultiSingleton(tp.info.hiBound)
+      case tp_ if isVarRef(tp_) => isMultiSingleton(bounds(tp_.asInstanceOf[VarRef]).hi)
+      case tp: TypeRef => isMultiSingleton(tp.info.hiBound)
       case tp: TypeVar => isMultiSingleton(tp.underlying)
-      case tp: VarRef => isMultiSingleton(bounds(tp).hi)
       case _ => false
     }
     def isOrType(tp: Type): Boolean = tp.dealias match {
@@ -327,7 +331,7 @@ trait ConstraintHandling {
    *  Both `c1` and `c2` are required to derive from constraint `pre`, possibly
    *  narrowing it with further bounds.
    */
-  protected final def subsumes(c1: Constraint, c2: Constraint, pre: Constraint): Boolean =
+  protected final def subsumes(c1: OwnConstraint, c2: OwnConstraint, pre: OwnConstraint): Boolean =
     if (c2 eq pre) true
     else if (c1 eq pre) false
     else {
@@ -355,7 +359,7 @@ trait ConstraintHandling {
    *  and propagate all bounds.
    *  @param tvars   See Constraint#add
    */
-  def addToConstraint(tl: Binder, tvars: List[TypeVar]): Boolean =
+  def addToConstraint(tl: RefBinder, tvars: List[TypeVarHandle[VarRef]]): Boolean =
     checkPropagated(i"initialized $tl") {
       constraint = constraint.add(tl, tvars)
       tl.boundRefs.forall { param =>
@@ -427,7 +431,7 @@ trait ConstraintHandling {
         }
         else tp
 
-      def addParamBound(bound: TypeParamRef) =
+      def addParamBound(bound: VarRef) =
         constraint.entry(param) match {
           case _: TypeBounds =>
             if (fromBelow) addLess(bound, param) else addLess(param, bound)
@@ -480,9 +484,10 @@ trait ConstraintHandling {
           val p2 = prune(bound.tp2)
           if (p1.exists && p2.exists) bound.derivedOrType(p1, p2)
           else NoType
-        case bound: TypeVar if constraint contains bound.origin =>
+        case bound: TypeVar if constraint contains bound.origin.asInstanceOf[VarRef] =>
           prune(bound.underlying)
-        case bound: TypeParamRef =>
+        case bound_ : TypeParamRef =>
+          val bound = bound_.asInstanceOf[VarRef]
           constraint.entry(bound) match {
             case NoType => pruneLambdaParams(bound)
             case _: TypeBounds =>
@@ -497,7 +502,8 @@ trait ConstraintHandling {
       }
 
       try bound match {
-        case bound: TypeParamRef if constraint contains bound =>
+        case bound_ : TypeParamRef if constraint contains bound_.asInstanceOf[VarRef] =>
+          val bound = bound_.asInstanceOf[VarRef]
           addParamBound(bound)
         case _ =>
           val pbound = prune(bound)
@@ -509,7 +515,7 @@ trait ConstraintHandling {
   }
 
   /** Instantiate `param` to `tp` if the constraint stays satisfiable */
-  protected def tryInstantiate(param: TypeParamRef, tp: Type): Boolean = {
+  protected def tryInstantiate(param: VarRef, tp: Type): Boolean = {
     val saved = constraint
     constraint =
       if (addConstraint(param, tp, fromBelow = true) &&

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

@@ -6,8 +6,8 @@ import config.Printers.{default, typr}
 
 trait ConstraintRunInfo { self: Run =>
   private[this] var maxSize = 0
-  private[this] var maxConstraint: Constraint = _
-  def recordConstraintSize(c: Constraint, size: Int): Unit =
+  private[this] var maxConstraint: Constraint[_, _] = _
+  def recordConstraintSize(c: Constraint[_, _], size: Int): Unit =
     if (size > maxSize) {
       maxSize = size
       maxConstraint = c

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

@@ -717,12 +717,21 @@ object Contexts {
     def derived: GADTMap
   }
 
+  case class TvHandle(origin: TypeVarRef) extends Type with TypeVarHandle[TypeVarRef] {
+    override def computeHash(bs: Hashable.Binders): Int = 0
+    override def hash: Int = 0
+  }
+
   final class SmartGADTMap(
-    private[this] var myConstraint: Constraint = new OrderingConstraint(SimpleIdentityMap.Empty, SimpleIdentityMap.Empty, SimpleIdentityMap.Empty),
-    private[this] var mapping: SimpleIdentityMap[Symbol, TypeVar] = SimpleIdentityMap.Empty,
-  ) extends GADTMap with ConstraintHandling {
+    private[this] var myConstraint: Constraint[TypeVarRef, TypeVarRefBinder] =
+      new OrderingConstraint[TypeVarRef, TypeVarRefBinder](SimpleIdentityMap.Empty, SimpleIdentityMap.Empty, SimpleIdentityMap.Empty),
+    private[this] var mapping: SimpleIdentityMap[Symbol, TvHandle] = SimpleIdentityMap.Empty,
+  ) extends GADTMap with ConstraintHandling[TypeVarRef, TypeVarRefBinder] {
     import dotty.tools.dotc.config.Printers.gadts
 
+    override def isVarRef(r: Type): Boolean = r.isInstanceOf[TypeParamRef] ||
+      (r.isInstanceOf[TypeRef] && mapping.contains(r.typeSymbol(ctx)))
+
     override def debugBoundsDescription(implicit ctx: Context): String = {
       val sb = new mutable.StringBuilder
       sb ++= constraint.show
@@ -742,17 +751,18 @@ object Contexts {
       try op finally myCtx = savedCtx
     }
 
-    override protected def constraint = myConstraint
-    override protected def constraint_=(c: Constraint) = myConstraint = c
+    override protected def constraint: OwnConstraint = myConstraint
+    override protected def constraint_=(c: OwnConstraint) = myConstraint = c
 
     override def isSubType(tp1: Type, tp2: Type): Boolean = ctx.typeComparer.isSubType(tp1, tp2)
     override def isSameType(tp1: Type, tp2: Type): Boolean = ctx.typeComparer.isSameType(tp1, tp2)
 
-    private[this] def tvar(sym: Symbol)(implicit ctx: Context): TypeVar = inCtx(ctx) {
+    private[this] def tvar(sym: Symbol)(implicit ctx: Context): TvHandle = inCtx(ctx) {
       val res = mapping(sym) match {
-        case tv: TypeVar => tv
+        case tv: TvHandle => tv
         case null =>
-          val res = new TypeVar(sym.typeRef, creatorState = null)
+          // val res = new TypeVar(sym.typeRef, creatorState = null)
+          val res = TvHandle(sym.typeRef)
           gadts.println(i"GADTMap: created tvar $sym -> $res")
           constraint = constraint.add(res.origin.binder, res :: Nil)
           mapping = mapping.updated(sym, res)
@@ -773,7 +783,7 @@ object Contexts {
       }
 
       @annotation.tailrec def firstUninst(tp: Type): Type = tp match {
-        case tv: TypeVar =>
+        case tv: TypeVarHandle[_] =>
           val inst = _instType(tv.origin)
           if (inst.exists) firstUninst(inst) else tv
         case ref: TypeVarRef =>
@@ -805,15 +815,15 @@ object Contexts {
       }
 
       val symRef: TypeVarRef = firstUninst(tvar(sym)) match {
-        case tv: TypeVar => tv.origin
+        case tv: TypeVarHandle[_] => tv.origin
         case inst =>
           gadts.println(i"instantiated: $sym -> $inst")
           return cautiousSubtype(inst, bound, isSubtype = isUpper, allowNarrowing = true)
       }
 
       def doAddBound(bound: Type): Boolean = {
         val realBound = firstUninst(bound) match {
-          case tv: TypeVar => tv.origin
+          case tv: TypeVarHandle[_] => tv.origin
           case tp => tp
         }
 
@@ -838,7 +848,7 @@ object Contexts {
 
       val tvarBound = bound
       val res = tvarBound match {
-        case boundTvar: TypeVar =>
+        case boundTvar: TypeVarHandle[_] =>
           doAddBound(boundTvar)
         case tp => doAddBound(tp)
       }
@@ -864,16 +874,6 @@ object Contexts {
       this.myConstraint,
       this.mapping
     )
-
-    private final class TypeVarInsertingMap extends TypeMap {
-      override def apply(tp: Type): Type = tp match {
-        case tp: TypeRef =>
-          val sym = tp.typeSymbol
-          if (contains(sym)) tvar(sym) else tp
-        case _ =>
-          mapOver(tp)
-      }
-    }
   }
 
   @sharable object EmptyGADTMap extends GADTMap {