Simplify ConstraintHandling#fullBounds

Author: abgruszecki

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

@@ -34,8 +34,6 @@ trait ConstraintHandling[AbstractContext] {
   protected def constraint: Constraint
   protected def constraint_=(c: Constraint): Unit
 
-  protected def externalize(param: TypeParamRef)(implicit ctx: Context): Type
-
   private[this] var addConstraintInvocations = 0
 
   /** If the constraint is frozen we cannot add new bounds to the constraint. */
@@ -71,28 +69,20 @@ trait ConstraintHandling[AbstractContext] {
     case tp => tp
   }
 
-  def nonParamBounds(param: TypeParamRef)(implicit ctx: Context): TypeBounds =
-    constraint.nonParamBounds(param) match {
-      case TypeAlias(tpr: TypeParamRef) => TypeAlias(externalize(tpr))
-      case tb => tb
-    }
+  def nonParamBounds(param: TypeParamRef)(implicit actx: AbstractContext): TypeBounds = constraint.nonParamBounds(param)
 
-  def fullLowerBound(param: TypeParamRef)(implicit ctx: Context): Type =
-    (nonParamBounds(param).lo /: constraint.minLower(param)) {
-      (t, u) => t | externalize(u)
-    }
+  def fullLowerBound(param: TypeParamRef)(implicit actx: AbstractContext): Type =
+    (nonParamBounds(param).lo /: constraint.minLower(param))(_ | _)
 
-  def fullUpperBound(param: TypeParamRef)(implicit ctx: Context): Type =
-    (nonParamBounds(param).hi /: constraint.minUpper(param)) {
-      (t, u) => t & externalize(u)
-    }
+  def fullUpperBound(param: TypeParamRef)(implicit actx: AbstractContext): Type =
+    (nonParamBounds(param).hi /: constraint.minUpper(param))(_ & _)
 
   /** Full bounds of `param`, including other lower/upper params.
     *
     * Note that underlying operations perform subtype checks - for this reason, recursing on `fullBounds`
     * of some param when comparing types might lead to infinite recursion. Consider `bounds` instead.
     */
-  def fullBounds(param: TypeParamRef)(implicit ctx: Context): TypeBounds =
+  def fullBounds(param: TypeParamRef)(implicit actx: AbstractContext): TypeBounds =
     nonParamBounds(param).derivedTypeBounds(fullLowerBound(param), fullUpperBound(param))
 
   protected def addOneBound(param: TypeParamRef, bound: Type, isUpper: Boolean)(implicit actx: AbstractContext): Boolean =

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

@@ -180,17 +180,33 @@ final class ProperGadtConstraint private(
   override protected def constraint = myConstraint
   override protected def constraint_=(c: Constraint) = myConstraint = c
 
-  override protected def externalize(param: TypeParamRef)(implicit ctx: Context): Type =
-    reverseMapping(param) match {
-      case sym: Symbol => sym.typeRef
-      case null => param
-    }
-
   override def isSubType(tp1: Type, tp2: Type)(implicit ctx: Context): Boolean = ctx.typeComparer.isSubType(tp1, tp2)
   override def isSameType(tp1: Type, tp2: Type)(implicit ctx: Context): Boolean = ctx.typeComparer.isSameType(tp1, tp2)
 
+   override def nonParamBounds(param: TypeParamRef)(implicit ctx: Context): TypeBounds =
+     constraint.nonParamBounds(param) match {
+       case TypeAlias(tpr: TypeParamRef) => TypeAlias(externalize(tpr))
+       case tb => tb
+     }
+
+   override def fullLowerBound(param: TypeParamRef)(implicit ctx: Context): Type =
+     (nonParamBounds(param).lo /: constraint.minLower(param)) {
+       (t, u) => t | externalize(u)
+     }
+
+   override def fullUpperBound(param: TypeParamRef)(implicit ctx: Context): Type =
+     (nonParamBounds(param).hi /: constraint.minUpper(param)) {
+       (t, u) => t & externalize(u)
+     }
+
   // ---- Private ----------------------------------------------------------
 
+  private[this] def externalize(param: TypeParamRef)(implicit ctx: Context): Type =
+    reverseMapping(param) match {
+      case sym: Symbol => sym.typeRef
+      case null => param
+    }
+
   private[this] def tvar(sym: Symbol)(implicit ctx: Context): TypeVar = {
     mapping(sym) match {
       case tv: TypeVar =>

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

@@ -33,8 +33,6 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] {
   def constraint: Constraint = state.constraint
   def constraint_=(c: Constraint): Unit = state.constraint = c
 
-  override protected def externalize(param: TypeParamRef)(implicit ctx: Context): Type = param
-
   private[this] var pendingSubTypes: mutable.Set[(Type, Type)] = null
   private[this] var recCount = 0
   private[this] var monitored = false

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -210,7 +210,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
           val bounds =
             if (constr.contains(tp)) {
               val ctx0 = ctx.addMode(Mode.Printing)
-              ctx0.typeComparer.fullBounds(tp.origin)(ctx0)
+              ctx0.typeComparer.fullBounds(tp.origin)
             }
             else TypeBounds.empty
           if (bounds.isTypeAlias) toText(bounds.lo) ~ (Str("^") provided ctx.settings.YprintDebug.value)