Refactor Constraint to constrain TypeRefs

Author: Aleksander Boruch-Gruszecki

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

@@ -161,7 +161,7 @@ object Constants {
             case TypeBounds(lo, hi) =>
               if (hi.classSymbol.isPrimitiveValueClass) hi //constrain further with high bound
               else classBound(lo)
-            case NoType => classBound(param.binder.paramInfos(param.paramNum).lo)
+            case NoType => classBound(param.binder.paramInfos(param.refNum).lo)
             case inst => classBound(inst)
           }
         case pt => pt

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

@@ -5,6 +5,11 @@ 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:
  *
@@ -14,58 +19,59 @@ import printing.Showable
  *                   that has the TypeParamRef as origin.
  */
 abstract class Constraint extends Showable {
+  import Constraint._
 
   type This <: Constraint
 
   /** Does the constraint's domain contain the type parameters of `pt`? */
-  def contains(pt: TypeLambda): Boolean
+  def contains(pt: Binder): Boolean
 
   /** Does the constraint's domain contain the type parameter `param`? */
-  def contains(param: TypeParamRef): Boolean
+  def contains(param: VarRef): Boolean
 
   /** Does this constraint contain the type variable `tvar` and is it uninstantiated? */
   def contains(tvar: TypeVar): 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.
    */
-  def entry(param: TypeParamRef): Type
+  def entry(param: VarRef): Type
 
   /** The type variable corresponding to parameter `param`, or
    *  NoType, if `param` is not in constrained or is not paired with a type variable.
    */
-  def typeVarOfParam(param: TypeParamRef): Type
+  def typeVarOfParam(param: VarRef): Type
 
   /** Is it known that `param1 <:< param2`? */
-  def isLess(param1: TypeParamRef, param2: TypeParamRef): Boolean
+  def isLess(param1: VarRef, param2: VarRef): Boolean
 
   /** The parameters that are known to be smaller wrt <: than `param` */
-  def lower(param: TypeParamRef): List[TypeParamRef]
+  def lower(param: VarRef): List[VarRef]
 
   /** The parameters that are known to be greater wrt <: than `param` */
-  def upper(param: TypeParamRef): List[TypeParamRef]
+  def upper(param: VarRef): List[VarRef]
 
   /** lower(param) \ lower(butNot) */
-  def exclusiveLower(param: TypeParamRef, butNot: TypeParamRef): List[TypeParamRef]
+  def exclusiveLower(param: VarRef, butNot: VarRef): List[VarRef]
 
   /** upper(param) \ upper(butNot) */
-  def exclusiveUpper(param: TypeParamRef, butNot: TypeParamRef): List[TypeParamRef]
+  def exclusiveUpper(param: VarRef, butNot: VarRef): List[VarRef]
 
   /** The constraint bounds for given type parameter `param`.
    *  Poly params that are known to be smaller or greater than `param`
    *  are not contained in the return bounds.
    *  @pre `param` is not part of the constraint domain.
    */
-  def nonParamBounds(param: TypeParamRef)(implicit ctx: Context): TypeBounds
+  def nonParamBounds(param: VarRef)(implicit ctx: Context): TypeBounds
 
   /** The lower bound of `param` including all known-to-be-smaller parameters */
-  def fullLowerBound(param: TypeParamRef)(implicit ctx: Context): Type
+  def fullLowerBound(param: VarRef)(implicit ctx: Context): Type
 
   /** The upper bound of `param` including all known-to-be-greater parameters */
-  def fullUpperBound(param: TypeParamRef)(implicit ctx: Context): Type
+  def fullUpperBound(param: VarRef)(implicit ctx: Context): Type
 
   /** The bounds of `param` including all known-to-be-smaller and -greater parameters */
-  def fullBounds(param: TypeParamRef)(implicit ctx: Context): TypeBounds
+  def fullBounds(param: VarRef)(implicit ctx: Context): TypeBounds
 
   /** A new constraint which is derived from this constraint by adding
    *  entries for all type parameters of `poly`.
@@ -74,7 +80,7 @@ abstract class Constraint extends Showable {
    *                 satisfiability but will solved to give instances of
    *                 type variables.
    */
-  def add(poly: TypeLambda, tvars: List[TypeVar])(implicit ctx: Context): This
+  def add(poly: Binder, tvars: List[TypeVar])(implicit ctx: Context): This
 
   /** A new constraint which is derived from this constraint by updating
    *  the entry for parameter `param` to `tp`.
@@ -85,44 +91,44 @@ abstract class Constraint extends Showable {
    *
    * @pre  `this contains param`.
    */
-  def updateEntry(param: TypeParamRef, tp: Type)(implicit ctx: Context): This
+  def updateEntry(param: VarRef, tp: Type)(implicit ctx: Context): This
 
   /** A constraint that includes the relationship `p1 <: p2`.
    *  `<:` relationships between parameters ("edges") are propagated, but
    *  non-parameter bounds are left alone.
    */
-  def addLess(p1: TypeParamRef, p2: TypeParamRef)(implicit ctx: Context): This
+  def addLess(p1: VarRef, p2: VarRef)(implicit ctx: Context): This
 
   /** A constraint resulting from adding p2 = p1 to this constraint, and at the same
    *  time transferring all bounds of p2 to p1
    */
-  def unify(p1: TypeParamRef, p2: TypeParamRef)(implicit ctx: Context): This
+  def unify(p1: VarRef, p2: VarRef)(implicit ctx: Context): This
 
   /** A new constraint which is derived from this constraint by removing
    *  the type parameter `param` from the domain and replacing all top-level occurrences
    *  of the parameter elsewhere in the constraint by type `tp`, or a conservative
    *  approximation of it if that is needed to avoid cycles.
    *  Occurrences nested inside a refinement or prefix are not affected.
    */
-  def replace(param: TypeParamRef, tp: Type)(implicit ctx: Context): This
+  def replace(param: VarRef, tp: Type)(implicit ctx: Context): This
 
   /** Is entry associated with `pt` removable? This is the case if
    *  all type parameters of the entry are associated with type variables
    *  which have their `inst` fields set.
    */
-  def isRemovable(pt: TypeLambda): Boolean
+  def isRemovable(pt: Binder): Boolean
 
   /** A new constraint with all entries coming from `pt` removed. */
-  def remove(pt: TypeLambda)(implicit ctx: Context): This
+  def remove(pt: Binder)(implicit ctx: Context): This
 
   /** The type lambdas constrained by this constraint */
-  def domainLambdas: List[TypeLambda]
+  def domainLambdas: List[Binder]
 
   /** The type lambda parameters constrained by this constraint */
-  def domainParams: List[TypeParamRef]
+  def domainParams: List[VarRef]
 
   /** Check whether predicate holds for all parameters in constraint */
-  def forallParams(p: TypeParamRef => Boolean): Boolean
+  def forallParams(p: VarRef => Boolean): Boolean
 
   /** Perform operation `op` on all typevars that do not have their `inst` field set. */
   def foreachTypeVar(op: TypeVar => Unit): Unit

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

@@ -19,6 +19,7 @@ import config.Printers.{constr, typr}
  * Constraint handlers update the current constraint as a side effect.
  */
 trait ConstraintHandling {
+  import Constraint._
 
   def constr_println(msg: => String): Unit = constr.println(msg)
   def typr_println(msg: => String): Unit = typr.println(msg)
@@ -60,13 +61,13 @@ trait ConstraintHandling {
     */
   def instType(tvar: TypeVar): Type = constraint.entry(tvar.origin) match {
     case _: TypeBounds => NoType
-    case tp: TypeParamRef =>
+    case tp: VarRef =>
       var tvar1 = constraint.typeVarOfParam(tp)
       if (tvar1.exists) tvar1 else tp
     case tp => tp
   }
 
-  protected def addOneBound(param: TypeParamRef, bound: Type, isUpper: Boolean): Boolean =
+  protected def addOneBound(param: VarRef, bound: Type, isUpper: Boolean): Boolean =
     !constraint.contains(param) || {
       def occursIn(bound: Type): Boolean = {
         val b = bound.dealias
@@ -84,7 +85,7 @@ trait ConstraintHandling {
         assert(!occursIn(bound), s"$param occurs in $bound")
 
       val oldBounds @ TypeBounds(lo, hi) = constraint.nonParamBounds(param)
-      val equalBounds = isUpper && (lo eq bound) || !isUpper && (bound eq hi)
+      val equalBounds = isUpper && (bound eq lo) || !isUpper && (bound eq hi)
       if (equalBounds && !bound.existsPart(_.isInstanceOf[WildcardType])) {
         // The narrowed bounds are equal and do not contain wildcards,
         // so we can remove `param` from the constraint.
@@ -116,7 +117,7 @@ trait ConstraintHandling {
 
   private def location(implicit ctx: Context) = "" // i"in ${ctx.typerState.stateChainStr}" // use for debugging
 
-  protected def addUpperBound(param: TypeParamRef, bound: Type): Boolean = {
+  protected def addUpperBound(param: VarRef, bound: Type): Boolean = {
     def description = i"constraint $param <: $bound to\n$constraint"
     if (bound.isRef(defn.NothingClass) && ctx.typerState.isGlobalCommittable) {
       def msg = s"!!! instantiated to Nothing: $param, constraint = ${constraint.show}"
@@ -132,7 +133,7 @@ trait ConstraintHandling {
     res
   }
 
-  protected def addLowerBound(param: TypeParamRef, bound: Type): Boolean = {
+  protected def addLowerBound(param: VarRef, bound: Type): Boolean = {
     def description = i"constraint $param >: $bound to\n$constraint"
     constr_println(i"adding $description")
     val upper = constraint.upper(param)
@@ -143,7 +144,7 @@ trait ConstraintHandling {
     res
   }
 
-  protected def addLess(p1: TypeParamRef, p2: TypeParamRef): Boolean = {
+  protected def addLess(p1: VarRef, p2: VarRef): Boolean = {
     def description = i"ordering $p1 <: $p2 to\n$constraint"
     val res =
       if (constraint.isLess(p2, p1)) unify(p2, p1)
@@ -165,7 +166,7 @@ trait ConstraintHandling {
   /** Make p2 = p1, transfer all bounds of p2 to p1
    *  @pre  less(p1)(p2)
    */
-  private def unify(p1: TypeParamRef, p2: TypeParamRef): Boolean = {
+  private def unify(p1: VarRef, p2: VarRef): Boolean = {
     constr_println(s"unifying $p1 $p2")
     assert(constraint.isLess(p1, p2))
     val down = constraint.exclusiveLower(p2, p1)
@@ -224,7 +225,7 @@ trait ConstraintHandling {
    *  @return the instantiating type
    *  @pre `param` is in the constraint's domain.
    */
-  final def approximation(param: TypeParamRef, fromBelow: Boolean): Type = {
+  final def approximation(param: VarRef, fromBelow: Boolean): Type = {
     val avoidParam = new TypeMap {
       override def stopAtStatic = true
       def avoidInArg(arg: Type): Type =
@@ -283,9 +284,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 => isMultiSingleton(tp.info.hiBound)
+      case tp: TypeRef if !constraint.contains(tp : VarRef) => isMultiSingleton(tp.info.hiBound)
       case tp: TypeVar => isMultiSingleton(tp.underlying)
-      case tp: TypeParamRef => isMultiSingleton(bounds(tp).hi)
+      case tp: VarRef => isMultiSingleton(bounds(tp).hi)
       case _ => false
     }
     def isOrType(tp: Type): Boolean = tp.dealias match {
@@ -311,7 +312,7 @@ trait ConstraintHandling {
    *  a lower bound instantiation can be a singleton type only if the upper bound
    *  is also a singleton type.
    */
-  def instanceType(param: TypeParamRef, fromBelow: Boolean): Type = {
+  def instanceType(param: VarRef, fromBelow: Boolean): Type = {
     val inst = approximation(param, fromBelow).simplified
     if (fromBelow) widenInferred(inst, constraint.fullUpperBound(param)) else inst
   }
@@ -340,12 +341,12 @@ trait ConstraintHandling {
     }
 
   /** The current bounds of type parameter `param` */
-  def bounds(param: TypeParamRef): TypeBounds = {
+  def bounds(param: VarRef): TypeBounds = {
     val e = constraint.entry(param)
     if (e.exists) e.bounds
     else {
-      val pinfos = param.binder.paramInfos
-      if (pinfos != null) pinfos(param.paramNum) // pinfos == null happens in pos/i536.scala
+      val pinfos = param.binder.refInfos
+      if (pinfos != null) pinfos(param.refNum) // pinfos == null happens in pos/i536.scala
       else TypeBounds.empty
     }
   }
@@ -354,10 +355,10 @@ trait ConstraintHandling {
    *  and propagate all bounds.
    *  @param tvars   See Constraint#add
    */
-  def addToConstraint(tl: TypeLambda, tvars: List[TypeVar]): Boolean =
+  def addToConstraint(tl: Binder, tvars: List[TypeVar]): Boolean =
     checkPropagated(i"initialized $tl") {
       constraint = constraint.add(tl, tvars)
-      tl.paramRefs.forall { param =>
+      tl.boundRefs.forall { param =>
         constraint.entry(param) match {
           case bounds: TypeBounds =>
             val lower = constraint.lower(param)
@@ -375,14 +376,14 @@ trait ConstraintHandling {
     }
 
   /** Can `param` be constrained with new bounds? */
-  final def canConstrain(param: TypeParamRef): Boolean =
+  final def canConstrain(param: VarRef): Boolean =
     (!frozenConstraint || (caseLambda `eq` param.binder)) && constraint.contains(param)
 
   /** Is `param` assumed to be a sub- and super-type of any other type?
    *  This holds if `TypeVarsMissContext` is set unless `param` is a part
    *  of a MatchType that is currently normalized.
    */
-  final def assumedTrue(param: TypeParamRef): Boolean =
+  final def assumedTrue(param: VarRef): Boolean =
     ctx.mode.is(Mode.TypevarsMissContext) && (caseLambda `ne` param.binder)
 
   /** Add constraint `param <: bound` if `fromBelow` is false, `param >: bound` otherwise.
@@ -392,7 +393,7 @@ trait ConstraintHandling {
    *  not be AndTypes and lower bounds may not be OrTypes. This is assured by the
    *  way isSubType is organized.
    */
-  protected def addConstraint(param: TypeParamRef, bound: Type, fromBelow: Boolean): Boolean = {
+  protected def addConstraint(param: VarRef, bound: Type, fromBelow: Boolean): Boolean = {
     def description = i"constr $param ${if (fromBelow) ">:" else "<:"} $bound:\n$constraint"
     //checkPropagated(s"adding $description")(true) // DEBUG in case following fails
     checkPropagated(s"added $description") {
@@ -522,7 +523,7 @@ trait ConstraintHandling {
     if (Config.checkConstraintsPropagated && result && addConstraintInvocations == 0) {
       inFrozenConstraint {
         for (p <- constraint.domainParams) {
-          def check(cond: => Boolean, q: TypeParamRef, ordering: String, explanation: String): Unit =
+          def check(cond: => Boolean, q: VarRef, ordering: String, explanation: String): Unit =
             assert(cond, i"propagation failure for $p $ordering $q: $explanation\n$msg")
           for (u <- constraint.upper(p))
             check(bounds(p).hi <:< bounds(u).hi, u, "<:", "upper bound not propagated")