Merge GenericType, TypeLambda and PolyType

1 files changed, 22 insertions, 22 deletions

diff --git a/src/dotty/tools/dotc/core/OrderingConstraint.scala b/src/dotty/tools/dotc/core/OrderingConstraint.scala
index 93e9878e7..72c7a8e51 100644
--- a/src/dotty/tools/dotc/core/OrderingConstraint.scala
+++ b/src/dotty/tools/dotc/core/OrderingConstraint.scala
@@ -14,7 +14,7 @@ import annotation.tailrec
 
 object OrderingConstraint {
 
-  type ArrayValuedMap[T] = SimpleMap[GenericType, Array[T]]
+  type ArrayValuedMap[T] = SimpleMap[PolyType, Array[T]]
 
   /** The type of `OrderingConstraint#boundsMap` */
   type ParamBounds = ArrayValuedMap[Type]
@@ -32,11 +32,11 @@ object OrderingConstraint {
 
   /** A lens for updating a single entry array in one of the three constraint maps */
   abstract class ConstraintLens[T <: AnyRef: ClassTag] {
-    def entries(c: OrderingConstraint, poly: GenericType): Array[T]
-    def updateEntries(c: OrderingConstraint, poly: GenericType, entries: Array[T])(implicit ctx: Context): OrderingConstraint
+    def entries(c: OrderingConstraint, poly: PolyType): Array[T]
+    def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[T])(implicit ctx: Context): OrderingConstraint
     def initial: T
 
-    def apply(c: OrderingConstraint, poly: GenericType, idx: Int) = {
+    def apply(c: OrderingConstraint, poly: PolyType, idx: Int) = {
       val es = entries(c, poly)
       if (es == null) initial else es(idx)
     }
@@ -47,7 +47,7 @@ object OrderingConstraint {
      *  parts of `current` which are not shared by `prev`.
      */
     def update(prev: OrderingConstraint, current: OrderingConstraint,
-        poly: GenericType, idx: Int, entry: T)(implicit ctx: Context): OrderingConstraint = {
+        poly: PolyType, idx: Int, entry: T)(implicit ctx: Context): OrderingConstraint = {
       var es = entries(current, poly)
       if (es != null && (es(idx) eq entry)) current
       else {
@@ -72,7 +72,7 @@ object OrderingConstraint {
       update(prev, current, param.binder, param.paramNum, entry)
 
     def map(prev: OrderingConstraint, current: OrderingConstraint,
-        poly: GenericType, idx: Int, f: T => T)(implicit ctx: Context): OrderingConstraint =
+        poly: PolyType, idx: Int, f: T => T)(implicit ctx: Context): OrderingConstraint =
      update(prev, current, poly, idx, f(apply(current, poly, idx)))
 
     def map(prev: OrderingConstraint, current: OrderingConstraint,
@@ -81,25 +81,25 @@ object OrderingConstraint {
   }
 
   val boundsLens = new ConstraintLens[Type] {
-    def entries(c: OrderingConstraint, poly: GenericType): Array[Type] =
+    def entries(c: OrderingConstraint, poly: PolyType): Array[Type] =
       c.boundsMap(poly)
-    def updateEntries(c: OrderingConstraint, poly: GenericType, entries: Array[Type])(implicit ctx: Context): OrderingConstraint =
+    def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[Type])(implicit ctx: Context): OrderingConstraint =
       newConstraint(c.boundsMap.updated(poly, entries), c.lowerMap, c.upperMap)
     def initial = NoType
   }
 
   val lowerLens = new ConstraintLens[List[PolyParam]] {
-    def entries(c: OrderingConstraint, poly: GenericType): Array[List[PolyParam]] =
+    def entries(c: OrderingConstraint, poly: PolyType): Array[List[PolyParam]] =
       c.lowerMap(poly)
-    def updateEntries(c: OrderingConstraint, poly: GenericType, entries: Array[List[PolyParam]])(implicit ctx: Context): OrderingConstraint =
+    def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[List[PolyParam]])(implicit ctx: Context): OrderingConstraint =
       newConstraint(c.boundsMap, c.lowerMap.updated(poly, entries), c.upperMap)
     def initial = Nil
   }
 
   val upperLens = new ConstraintLens[List[PolyParam]] {
-    def entries(c: OrderingConstraint, poly: GenericType): Array[List[PolyParam]] =
+    def entries(c: OrderingConstraint, poly: PolyType): Array[List[PolyParam]] =
       c.upperMap(poly)
-    def updateEntries(c: OrderingConstraint, poly: GenericType, entries: Array[List[PolyParam]])(implicit ctx: Context): OrderingConstraint =
+    def updateEntries(c: OrderingConstraint, poly: PolyType, entries: Array[List[PolyParam]])(implicit ctx: Context): OrderingConstraint =
       newConstraint(c.boundsMap, c.lowerMap, c.upperMap.updated(poly, entries))
     def initial = Nil
   }
@@ -149,7 +149,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
 // ----------- Contains tests --------------------------------------------------
 
-  def contains(pt: GenericType): Boolean = boundsMap(pt) != null
+  def contains(pt: PolyType): Boolean = boundsMap(pt) != null
 
   def contains(param: PolyParam): Boolean = {
     val entries = boundsMap(param.binder)
@@ -280,7 +280,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     stripParams(tp, paramBuf, isUpper)
       .orElse(if (isUpper) defn.AnyType else defn.NothingType)
 
-  def add(poly: GenericType, tvars: List[TypeVar])(implicit ctx: Context): This = {
+  def add(poly: PolyType, tvars: List[TypeVar])(implicit ctx: Context): This = {
     assert(!contains(poly))
     val nparams = poly.paramNames.length
     val entries1 = new Array[Type](nparams * 2)
@@ -293,7 +293,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
    *  Update all bounds to be normalized and update ordering to account for
    *  dependent parameters.
    */
-  private def init(poly: GenericType)(implicit ctx: Context): This = {
+  private def init(poly: PolyType)(implicit ctx: Context): This = {
     var current = this
     val loBuf, hiBuf = new mutable.ListBuffer[PolyParam]
     var i = 0
@@ -400,7 +400,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       def removeParam(ps: List[PolyParam]) =
         ps.filterNot(p => p.binder.eq(poly) && p.paramNum == idx)
 
-      def replaceParam(tp: Type, atPoly: GenericType, atIdx: Int): Type = tp match {
+      def replaceParam(tp: Type, atPoly: PolyType, atIdx: Int): Type = tp match {
         case bounds @ TypeBounds(lo, hi) =>
 
           def recombine(andor: AndOrType, op: (Type, Boolean) => Type, isUpper: Boolean): Type = {
@@ -440,9 +440,9 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     }
   }
 
-  def remove(pt: GenericType)(implicit ctx: Context): This = {
+  def remove(pt: PolyType)(implicit ctx: Context): This = {
     def removeFromOrdering(po: ParamOrdering) = {
-      def removeFromBoundss(key: GenericType, bndss: Array[List[PolyParam]]): Array[List[PolyParam]] = {
+      def removeFromBoundss(key: PolyType, bndss: Array[List[PolyParam]]): Array[List[PolyParam]] = {
         val bndss1 = bndss.map(_.filterConserve(_.binder ne pt))
         if (bndss.corresponds(bndss1)(_ eq _)) bndss else bndss1
       }
@@ -451,7 +451,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     newConstraint(boundsMap.remove(pt), removeFromOrdering(lowerMap), removeFromOrdering(upperMap))
   }
 
-  def isRemovable(pt: GenericType): Boolean = {
+  def isRemovable(pt: PolyType): Boolean = {
     val entries = boundsMap(pt)
     @tailrec def allRemovable(last: Int): Boolean =
       if (last < 0) true
@@ -464,7 +464,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
 // ---------- Exploration --------------------------------------------------------
 
-  def domainPolys: List[GenericType] = boundsMap.keys
+  def domainPolys: List[PolyType] = boundsMap.keys
 
   def domainParams: List[PolyParam] =
     for {
@@ -481,7 +481,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     true
   }
 
-  def foreachParam(p: (GenericType, Int) => Unit): Unit =
+  def foreachParam(p: (PolyType, Int) => Unit): Unit =
     boundsMap.foreachBinding { (poly, entries) =>
       0.until(poly.paramNames.length).foreach(p(poly, _))
     }
@@ -541,7 +541,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
   override def checkClosed()(implicit ctx: Context): Unit = {
     def isFreePolyParam(tp: Type) = tp match {
-      case PolyParam(binder: GenericType, _) => !contains(binder)
+      case PolyParam(binder: PolyType, _) => !contains(binder)
       case _ => false
     }
     def checkClosedType(tp: Type, where: String) =