Further refactorings

- Use TypeLambda instead of PolyType.
- Further harmonize factory operations

Author: odersky

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

@@ -14,7 +14,7 @@ import config.Printers.constr
  *  over values of the following types:
  *
  *   - TypeLambda    A constraint constrains the type parameters of a set of TypeLambdas
- *   - TypeParamRef  The parameters of the constrained polytypes
+ *   - TypeParamRef  The parameters of the constrained type lambdas
  *   - TypeVar       Every constrained parameter might be associated with a TypeVar
  *                   that has the TypeParamRef as origin.
  */
@@ -120,10 +120,10 @@ abstract class Constraint extends Showable {
   /** A new constraint with all entries coming from `pt` removed. */
   def remove(pt: TypeLambda)(implicit ctx: Context): This
 
-  /** The polytypes constrained by this constraint */
-  def domainPolys: List[TypeLambda]
+  /** The type lambdas constrained by this constraint */
+  def domainLambdas: List[TypeLambda]
 
-  /** The polytype parameters constrained by this constraint */
+  /** The type lambda parameters constrained by this constraint */
   def domainParams: List[TypeParamRef]
 
   /** Check whether predicate holds for all parameters in constraint */

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

@@ -51,10 +51,10 @@ trait ConstraintHandling {
    */
   protected var homogenizeArgs = false
 
-  /** We are currently comparing polytypes. Used as a flag for
+  /** We are currently comparing type lambdas. Used as a flag for
    *  optimization: when `false`, no need to do an expensive `pruneLambdaParams`
    */
-  protected var comparedPolyTypes: Set[PolyType] = Set.empty
+  protected var comparedTypeLambdas: Set[TypeLambda] = Set.empty
 
   private def addOneBound(param: TypeParamRef, bound: Type, isUpper: Boolean): Boolean =
     !constraint.contains(param) || {
@@ -307,21 +307,21 @@ trait ConstraintHandling {
     if (e.exists) e.bounds else param.binder.paramInfos(param.paramNum)
   }
 
-  /** Add polytype `pt`, possibly with type variables `tvars`, to current constraint
+  /** Add type lambda `tl`, possibly with type variables `tvars`, to current constraint
    *  and propagate all bounds.
    *  @param tvars   See Constraint#add
    */
-  def addToConstraint(pt: PolyType, tvars: List[TypeVar]): Unit =
+  def addToConstraint(tl: TypeLambda, tvars: List[TypeVar]): Unit =
     assert {
-      checkPropagated(i"initialized $pt") {
-        constraint = constraint.add(pt, tvars)
-        pt.paramNames.indices.forall { i =>
-          val param = TypeParamRef(pt, i)
+      checkPropagated(i"initialized $tl") {
+        constraint = constraint.add(tl, tvars)
+        tl.paramNames.indices.forall { i =>
+          val param = TypeParamRef(tl, i)
           val bounds = constraint.nonParamBounds(param)
           val lower = constraint.lower(param)
           val upper = constraint.upper(param)
           if (lower.nonEmpty && !bounds.lo.isRef(defn.NothingClass) ||
-            upper.nonEmpty && !bounds.hi.isRef(defn.AnyClass)) constr.println(i"INIT*** $pt")
+            upper.nonEmpty && !bounds.hi.isRef(defn.AnyClass)) constr.println(i"INIT*** $tl")
           lower.forall(addOneBound(_, bounds.hi, isUpper = true)) &&
             upper.forall(addOneBound(_, bounds.lo, isUpper = false))
         }
@@ -358,10 +358,10 @@ trait ConstraintHandling {
        *  missing.
        */
       def pruneLambdaParams(tp: Type) =
-        if (comparedPolyTypes.nonEmpty) {
+        if (comparedTypeLambdas.nonEmpty) {
           val approx = new ApproximatingTypeMap {
             def apply(t: Type): Type = t match {
-              case t @ TypeParamRef(pt: PolyType, n) if comparedPolyTypes contains pt =>
+              case t @ TypeParamRef(pt: TypeLambda, n) if comparedTypeLambdas contains pt =>
                 val effectiveVariance = if (fromBelow) -variance else variance
                 val bounds = pt.paramInfos(n)
                 if (effectiveVariance > 0) bounds.lo

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

@@ -112,17 +112,17 @@ import OrderingConstraint._
  *  @param boundsMap a map from TypeLambda to arrays.
  *               Each array contains twice the number of entries as there a type parameters
  *               in the TypeLambda. The first half of the array contains the type bounds that constrain the
- *               polytype's type parameters. The second half might contain type variables that
+ *               lambda's type parameters. The second half might contain type variables that
  *               track the corresponding parameters, or is left empty (filled with nulls).
  *               An instantiated type parameter is represented by having its instance type in
  *               the corresponding array entry. The dual use of arrays for poly params
  *               and typevars is to save space and hopefully gain some speed.
  *
  *  @param lowerMap a map from TypeLambdas to arrays. Each array entry corresponds
- *               to a parameter P of the polytype; it contains all constrained parameters
+ *               to a parameter P of the type lambda; it contains all constrained parameters
  *               Q that are known to be smaller than P, i.e. Q <: P.
  *  @param upperMap a map from TypeLambdas to arrays. Each array entry corresponds
- *               to a parameter P of the polytype; it contains all constrained parameters
+ *               to a parameter P of the type lambda; it contains all constrained parameters
  *               Q that are known to be greater than P, i.e. P <: Q.
  */
 class OrderingConstraint(private val boundsMap: ParamBounds,
@@ -456,7 +456,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
 // ---------- Exploration --------------------------------------------------------
 
-  def domainPolys: List[TypeLambda] = boundsMap.keys
+  def domainLambdas: List[TypeLambda] = boundsMap.keys
 
   def domainParams: List[TypeParamRef] =
     for {
@@ -584,7 +584,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     val uninstVarsText = " uninstVars = " ~
       Text(uninstVars map (_.toText(printer)), ", ") ~ ";"
     val constrainedText =
-      " constrained types = " ~ Text(domainPolys map (_.toText(printer)), ", ")
+      " constrained types = " ~ Text(domainLambdas map (_.toText(printer)), ", ")
     val boundsText =
       " bounds = " ~ {
         val assocs =
@@ -614,8 +614,8 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       case _ =>" := " + tp
     }
     val constrainedText =
-      " constrained types = " + domainPolys.mkString("\n")
-    val boundsText =
+      " constrained types = " + domainLambdas.mkString("\n")
+    val boundsText = domainLambdas
       " bounds = " + {
         val assocs =
           for (param <- domainParams)

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

@@ -1,21 +1,23 @@
 package dotty.tools.dotc.core
 
-import Names.TypeName
+import Names.Name
 import Contexts.Context
-import Types.{Type, TypeBounds}
+import Types.Type
 
 /** A common super trait of Symbol and LambdaParam.
  *  Used to capture the attributes of type parameters which can be implemented as either.
  */
 trait ParamInfo {
 
+  type ThisName <: Name
+
   /** Is this the info of a type parameter? Will return `false` for symbols
    *  that are not type parameters.
    */
   def isTypeParam(implicit ctx: Context): Boolean
 
   /** The name of the type parameter */
-  def paramName(implicit ctx: Context): TypeName
+  def paramName(implicit ctx: Context): ThisName
 
   /** The info of the type parameter */
   def paramInfo(implicit ctx: Context): Type
@@ -37,4 +39,8 @@ trait ParamInfo {
 
   /** A type that refers to the parameter */
   def paramRef(implicit ctx: Context): Type
+}
+
+object ParamInfo {
+  type Of[N] = ParamInfo { type ThisName = N }
 }

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

@@ -1141,7 +1141,7 @@ object SymDenotations {
       case tp: NamedType => hasSkolems(tp.prefix)
       case tp: RefinedType => hasSkolems(tp.parent) || hasSkolems(tp.refinedInfo)
       case tp: RecType => hasSkolems(tp.parent)
-      case tp: PolyType => tp.paramInfos.exists(hasSkolems) || hasSkolems(tp.resType)
+      case tp: TypeLambda => tp.paramInfos.exists(hasSkolems) || hasSkolems(tp.resType)
       case tp: MethodType => tp.paramInfos.exists(hasSkolems) || hasSkolems(tp.resType)
       case tp: ExprType => hasSkolems(tp.resType)
       case tp: HKApply => hasSkolems(tp.tycon) || tp.args.exists(hasSkolems)

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

@@ -513,11 +513,11 @@ object Symbols {
      */
     def pos: Position = if (coord.isPosition) coord.toPosition else NoPosition
 
-    // ParamInfo methods
+    // ParamInfo types and methods
     def isTypeParam(implicit ctx: Context) = denot.is(TypeParam)
-    def paramName(implicit ctx: Context) = name.asTypeName
+    def paramName(implicit ctx: Context) = name.asInstanceOf[ThisName]
     def paramInfo(implicit ctx: Context) = denot.info.bounds
-    def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = pre.memberInfo(this)
+    def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = pre.memberInfo(this).bounds
     def paramInfoOrCompleter(implicit ctx: Context): Type = denot.infoOrCompleter
     def paramVariance(implicit ctx: Context) = denot.variance
     def paramRef(implicit ctx: Context) = denot.typeRef

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

@@ -20,6 +20,8 @@ import java.util.NoSuchElementException
 
 object TypeApplications {
 
+  type TypeParamInfo = ParamInfo.Of[TypeName]
+
   /** Assert type is not a TypeBounds instance and return it unchanged */
   val noBounds = (tp: Type) => tp match {
     case tp: TypeBounds => throw new AssertionError("no TypeBounds allowed")
@@ -46,14 +48,14 @@ object TypeApplications {
 
   /** Does the variance of type parameter `tparam1` conform to the variance of type parameter `tparam2`?
    */
-  def varianceConforms(tparam1: ParamInfo, tparam2: ParamInfo)(implicit ctx: Context): Boolean =
+  def varianceConforms(tparam1: TypeParamInfo, tparam2: TypeParamInfo)(implicit ctx: Context): Boolean =
     varianceConforms(tparam1.paramVariance, tparam2.paramVariance)
 
   /** Do the variances of type parameters `tparams1` conform to the variances
    *  of corresponding type parameters `tparams2`?
    *  This is only the case of `tparams1` and `tparams2` have the same length.
    */
-  def variancesConform(tparams1: List[ParamInfo], tparams2: List[ParamInfo])(implicit ctx: Context): Boolean =
+  def variancesConform(tparams1: List[TypeParamInfo], tparams2: List[TypeParamInfo])(implicit ctx: Context): Boolean =
     tparams1.corresponds(tparams2)(varianceConforms)
 
   /** Extractor for
@@ -72,7 +74,7 @@ object TypeApplications {
     }
 
     def unapply(tp: Type)(implicit ctx: Context): Option[TypeRef] = tp match {
-      case tp @ PolyType(tparams, AppliedType(fn: TypeRef, args)) if (args == tparams.map(_.toArg)) => Some(fn)
+      case tp @ PolyType/*###*/(tparams, AppliedType(fn: TypeRef, args)) if (args == tparams.map(_.toArg)) => Some(fn)
       case _ => None
     }
   }
@@ -95,7 +97,7 @@ object TypeApplications {
           refinements = rt :: refinements
           tycon = rt.parent.stripTypeVar
         }
-        def collectArgs(tparams: List[ParamInfo],
+        def collectArgs(tparams: List[TypeParamInfo],
                         refinements: List[RefinedType],
                         argBuf: mutable.ListBuffer[Type]): Option[(Type, List[Type])] = refinements match {
           case Nil if tparams.isEmpty && argBuf.nonEmpty =>
@@ -116,7 +118,7 @@ object TypeApplications {
 
    /** Adapt all arguments to possible higher-kinded type parameters using etaExpandIfHK
    */
-  def EtaExpandIfHK(tparams: List[ParamInfo], args: List[Type])(implicit ctx: Context): List[Type] =
+  def EtaExpandIfHK(tparams: List[TypeParamInfo], args: List[Type])(implicit ctx: Context): List[Type] =
     if (tparams.isEmpty) args
     else args.zipWithConserve(tparams)((arg, tparam) => arg.EtaExpandIfHK(tparam.paramInfoOrCompleter))
 
@@ -159,7 +161,7 @@ object TypeApplications {
    *  result type. Using this mode, we can guarantee that `appliedTo` will never
    *  produce a higher-kinded application with a type lambda as type constructor.
    */
-  class Reducer(tycon: PolyType, args: List[Type])(implicit ctx: Context) extends TypeMap {
+  class Reducer(tycon: TypeLambda, args: List[Type])(implicit ctx: Context) extends TypeMap {
     private var available = (0 until args.length).toSet
     var allReplaced = true
     def hasWildcardArg(p: TypeParamRef) =
@@ -208,11 +210,11 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  with the bounds on its hk args. See `LambdaAbstract`, where these
    *  types get introduced, and see `isBoundedLambda` below for the test.
    */
-  final def typeParams(implicit ctx: Context): List[ParamInfo] = /*>|>*/ track("typeParams") /*<|<*/ {
+  final def typeParams(implicit ctx: Context): List[TypeParamInfo] = /*>|>*/ track("typeParams") /*<|<*/ {
     self match {
       case self: ClassInfo =>
         self.cls.typeParams
-      case self: PolyType =>
+      case self: TypeLambda =>
         self.typeParams
       case self: TypeRef =>
         val tsym = self.symbol
@@ -235,7 +237,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** If `self` is a higher-kinded type, its type parameters, otherwise Nil */
-  final def hkTypeParams(implicit ctx: Context): List[ParamInfo] =
+  final def hkTypeParams(implicit ctx: Context): List[TypeParamInfo] =
     if (isHK) typeParams else Nil
 
   /** If `self` is a generic class, its type parameter symbols, otherwise Nil */
@@ -250,7 +252,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   def isHK(implicit ctx: Context): Boolean = self.dealias match {
     case self: TypeRef => self.info.isHK
     case self: RefinedType => false
-    case self: PolyType => true
+    case self: TypeLambda => true
     case self: SingletonType => false
     case self: TypeVar =>
       // Using `origin` instead of `underlying`, as is done for typeParams,
@@ -273,16 +275,9 @@ class TypeApplications(val self: Type) extends AnyVal {
    *
    *      type T[X] = U        becomes    type T = [X] -> U
    *      type T[X] >: L <: U  becomes    type T >: L <: ([X] -> U)
-   *
-   *  TODO: Handle parameterized lower bounds
    */
-  def LambdaAbstract(tparams: List[ParamInfo])(implicit ctx: Context): Type = {
-    def nameWithVariance(tparam: ParamInfo) =
-      tparam.paramName.withVariance(tparam.paramVariance)
-    def expand(tp: Type) =
-      PolyType(tparams.map(nameWithVariance))(
-          tl => tparams.map(tparam => tl.lifted(tparams, tparam.paramInfo).bounds),
-          tl => tl.lifted(tparams, tp))
+  def LambdaAbstract(tparams: List[TypeParamInfo])(implicit ctx: Context): Type = {
+    def expand(tp: Type) = PolyType/*HKTypeLambda*/.fromParams(tparams, tp)
     if (tparams.isEmpty) self
     else self match {
       case self: TypeAlias =>
@@ -362,10 +357,10 @@ class TypeApplications(val self: Type) extends AnyVal {
     if (hkParams.isEmpty) self
     else {
       def adaptArg(arg: Type): Type = arg match {
-        case arg @ PolyType(tparams, body) if
+        case arg @ PolyType(tparams, body) if /*###*/
              !tparams.corresponds(hkParams)(_.paramVariance == _.paramVariance) &&
              tparams.corresponds(hkParams)(varianceConforms) =>
-          PolyType(
+          PolyType(/*###*/
             (tparams, hkParams).zipped.map((tparam, hkparam) =>
               tparam.paramName.withVariance(hkparam.paramVariance)))(
             tl => arg.paramInfos.map(_.subst(arg, tl).bounds),
@@ -409,7 +404,7 @@ class TypeApplications(val self: Type) extends AnyVal {
     val dealiased = stripped.safeDealias
     if (args.isEmpty || ctx.erasedTypes) self
     else dealiased match {
-      case dealiased: PolyType =>
+      case dealiased: TypeLambda =>
         def tryReduce =
           if (!args.exists(_.isInstanceOf[TypeBounds])) {
             val followAlias = Config.simplifyApplications && {