Introduce recursive types

Map self-references in refinements to recursive types. This
commit does this for refinement types appearing in source.
We still have to do it for unpickled refinements.

Test apply-equiv got moved to pending because it simulates
the old higher-kinded type encoding in source, which relies
on the old representation in terms of self-referential refinement
types. The plan is not to adapt this encoding to the new
representation, but to replace it with a different encoding
that makes critical use of the added power of recursive types.

Author: odersky

src/dotty/tools/dotc/core/Substituters.scala

@@ -197,6 +197,24 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
+  final def substRecThis(tp: Type, from: Type, to: Type, theMap: SubstRecThisMap): Type =
+    tp match {
+      case tp @ RecThis(binder) =>
+        if (binder eq from) to else tp
+      case tp: NamedType =>
+        if (tp.currentSymbol.isStatic) tp
+        else tp.derivedSelect(substRecThis(tp.prefix, from, to, theMap))
+      case _: ThisType | _: BoundType | NoPrefix =>
+        tp
+      case tp: RefinedType =>
+        tp.derivedRefinedType(substRecThis(tp.parent, from, to, theMap), tp.refinedName, substRecThis(tp.refinedInfo, from, to, theMap))
+      case tp: TypeAlias =>
+        tp.derivedTypeAlias(substRecThis(tp.alias, from, to, theMap))
+      case _ =>
+        (if (theMap != null) theMap else new SubstRecThisMap(from, to))
+          .mapOver(tp)
+    }
+
   final def substParam(tp: Type, from: ParamType, to: Type, theMap: SubstParamMap): Type =
     tp match {
       case tp: BoundType =>
@@ -270,6 +288,10 @@ trait Substituters { this: Context =>
     def apply(tp: Type): Type = substRefinedThis(tp, from, to, this)
   }
 
+  final class SubstRecThisMap(from: Type, to: Type) extends DeepTypeMap {
+    def apply(tp: Type): Type = substRecThis(tp, from, to, this)
+  }
+
   final class SubstParamMap(from: ParamType, to: Type) extends DeepTypeMap {
     def apply(tp: Type) = substParam(tp, from, to, this)
   }

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

@@ -1117,10 +1117,11 @@ object SymDenotations {
 
     def debugString = toString + "#" + symbol.id // !!! DEBUG
 
-        def hasSkolems(tp: Type): Boolean = tp match {
+    def hasSkolems(tp: Type): Boolean = tp match {
       case tp: SkolemType => true
       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.paramBounds.exists(hasSkolems) || hasSkolems(tp.resType)
       case tp: MethodType => tp.paramTypes.exists(hasSkolems) || hasSkolems(tp.resType)
       case tp: ExprType => hasSkolems(tp.resType)

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

@@ -22,17 +22,25 @@ object TypeApplicationsNewHK {
   import TypeApplications._
 
   object TypeLambda {
-    def apply(argBindingFns: List[RefinedType => TypeBounds],
-              bodyFn: RefinedType => Type)(implicit ctx: Context): Type = {
+    def apply(argBindingFns: List[RecType => TypeBounds],
+              bodyFn: RecType => Type)(implicit ctx: Context): Type = {
       val argNames = argBindingFns.indices.toList.map(tpnme.hkArg)
-      RefinedType.recursive(bodyFn, argNames, argBindingFns)
+      var idx = 0
+      RecType.closeOver(rt =>
+        (bodyFn(rt) /: argBindingFns) { (parent, argBindingFn) =>
+          val res = RefinedType(parent, tpnme.hkArg(idx), argBindingFn(rt))
+          idx += 1
+          res
+        })
     }
 
     def unapply(tp: Type)(implicit ctx: Context): Option[(List[TypeBounds], Type)] = {
       def decompose(t: Type, acc: List[TypeBounds]): (List[TypeBounds], Type) = t match {
         case t @ RefinedType(p, rname, rinfo: TypeBounds)
         if rname.isHkArgName && rinfo.isBinding =>
           decompose(p, rinfo.bounds :: acc)
+        case t: RecType =>
+          decompose(t.parent, acc)
         case _ =>
           (acc, t)
       }
@@ -78,13 +86,13 @@ object TypeApplications {
    *    [v1 X1: B1, ..., vn Xn: Bn] -> T
    *    ==>
    *    ([X_i := this.$hk_i] T) { type v_i $hk_i: (new)B_i }
-   *    
+   *
    *    [X] -> List[X]
-   *    
+   *
    *    List { type List$A = this.$hk_0 } { type $hk_0 }
-   *    
+   *
    *    [X] -> X
-   *    
+   *
    *    mu(this) this.$hk_0 & { type $hk_0 }
    */
   object TypeLambda {
@@ -212,6 +220,10 @@ object TypeApplications {
   def argRefs(rt: RefinedType, n: Int)(implicit ctx: Context) =
     List.range(0, n).map(i => RefinedThis(rt).select(tpnme.hkArg(i)))
 
+  /** The references `<rt>.this.$hk0, ..., <rt>.this.$hk<n-1>`. */
+  def argRefs(rt: RecType, n: Int)(implicit ctx: Context) =
+    List.range(0, n).map(i => RecThis(rt).select(tpnme.hkArg(i)))
+
   /** Merge `tp1` and `tp2` under a common lambda, combining them with `op`.
    *  @param tparams1   The type parameters of `tp1`
    *  @param tparams2   The type parameters of `tp2`
@@ -400,7 +412,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  but without forcing anything.
    */
   def classNotLambda(implicit ctx: Context): Boolean = self.stripTypeVar match {
-    case self: RefinedType =>
+    case self: RefinedOrRecType =>
       self.parent.classNotLambda
     case self: TypeRef =>
       self.denot.exists && {
@@ -428,6 +440,14 @@ class TypeApplications(val self: Type) extends AnyVal {
       new ctx.SafeSubstMap(tparams, argRefs(rt, tparams.length))
         .apply(self).asInstanceOf[T]
 
+  /** Replace references to type parameters with references to hk arguments `this.$hk_i`
+   * Care is needed not to cause cyclic reference errors, hence `SafeSubstMap`.
+   */
+  def recursify[T <: Type](tparams: List[Symbol])(implicit ctx: Context): RecType => T =
+    (rt: RecType) =>
+      new ctx.SafeSubstMap(tparams, argRefs(rt, tparams.length))
+        .apply(self).asInstanceOf[T]
+
   /** Lambda abstract `self` with given type parameters. Examples:
    *
    *      type T[X] = U        becomes    type T = [X] -> U
@@ -546,6 +566,8 @@ class TypeApplications(val self: Type) extends AnyVal {
           arg.prefix.select(boundLambda)
         case arg: RefinedType =>
           arg.derivedRefinedType(adaptArg(arg.parent), arg.refinedName, arg.refinedInfo)
+        case arg: RecType =>
+          arg.derivedRecType(adaptArg(arg.parent))
         case arg @ TypeAlias(alias) =>
           arg.derivedTypeAlias(adaptArg(alias))
         case arg @ TypeBounds(lo, hi) =>
@@ -814,6 +836,8 @@ class TypeApplications(val self: Type) extends AnyVal {
         }
       case tp: RefinedType =>
         recur(tp.refinedInfo) || recur(tp.parent)
+      case tp: RecType =>
+        recur(tp.parent)
       case tp: TypeBounds =>
         recur(tp.lo) || recur(tp.hi)
       case tp: AnnotatedType =>

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

@@ -378,6 +378,9 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
           isSubRefinements(tp1w.asInstanceOf[RefinedType], tp2, skipped2)
       }
       compareRefined
+    case tp2: RecType =>
+      val tp1stable = ensureStableSingleton(tp1)
+      isSubType(fixRecs(tp1stable, tp1stable.widenExpr), tp2.substRecThis(tp2, tp1stable))
     case OrType(tp21, tp22) =>
       // Rewrite T1 <: (T211 & T212) | T22 to T1 <: (T211 | T22) and T1 <: (T212 | T22)
       // and analogously for T1 <: T21 | (T221 & T222)
@@ -465,7 +468,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         case _ =>
           def isNullable(tp: Type): Boolean = tp.dealias match {
             case tp: TypeRef => tp.symbol.isNullableClass
-            case tp: RefinedType => isNullable(tp.parent)
+            case tp: RefinedOrRecType => isNullable(tp.parent)
             case AndType(tp1, tp2) => isNullable(tp1) && isNullable(tp2)
             case OrType(tp1, tp2) => isNullable(tp1) || isNullable(tp2)
             case _ => false
@@ -494,6 +497,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       isNewSubType(tp1.parent, tp2) ||
       compareHkLambda(tp1, tp2, inOrder = true) ||
       compareAliasedRefined(tp1, tp2, inOrder = true)
+    case tp1: RecType =>
+      isNewSubType(tp1.parent, tp2)
     case AndType(tp11, tp12) =>
       // Rewrite (T111 | T112) & T12 <: T2 to (T111 & T12) <: T2 and (T112 | T12) <: T2
       // and analogously for T11 & (T121 | T122) & T12 <: T2
@@ -642,6 +647,25 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     }
   }
 
+  /** Replace any top-level recursive type `{ z => T }` in `tp` with 
+   *  `[z := anchor]T`.
+   */
+  private def fixRecs(anchor: SingletonType, tp: Type): Type = {
+    def fix(tp: Type): Type = tp.stripTypeVar match {
+      case tp: RecType => fix(tp.parent).substRecThis(tp, anchor)
+      case tp @ RefinedType(parent, rname, rinfo) => tp.derivedRefinedType(fix(parent), rname, rinfo)
+      case tp: PolyParam => fixOrElse(bounds(tp).hi, tp)
+      case tp: TypeProxy => fixOrElse(tp.underlying, tp)
+      case tp: AndOrType => tp.derivedAndOrType(fix(tp.tp1), fix(tp.tp2))
+      case tp => tp
+    }
+    def fixOrElse(tp: Type, fallback: Type) = {
+      val tp1 = fix(tp)
+      if (tp1 ne tp) tp1 else fallback
+    }
+    fix(tp)
+  }
+
   /** The symbol referred to in the refinement of `rt` */
   private def refinedSymbol(rt: RefinedType) = rt.parent.member(rt.refinedName).symbol
 
@@ -772,7 +796,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
 
   /** A type has been covered previously in subtype checking if it
    *  is some combination of TypeRefs that point to classes, where the
-   *  combiners are RefinedTypes, AndTypes or AnnotatedTypes.
+   *  combiners are RefinedTypes, RecTypes, AndTypes or AnnotatedTypes.
    *  One exception: Refinements referring to basetype args are never considered
    *  to be already covered. This is necessary because such refined types might
    *  still need to be compared with a compareAliasRefined.
@@ -781,6 +805,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     case tp: TypeRef => tp.symbol.isClass && tp.symbol != NothingClass && tp.symbol != NullClass
     case tp: ProtoType => false
     case tp: RefinedType => isCovered(tp.parent) && !refinedSymbol(tp).is(BaseTypeArg)
+    case tp: RecType => isCovered(tp.parent)
     case tp: AnnotatedType => isCovered(tp.underlying)
     case AndType(tp1, tp2) => isCovered(tp1) && isCovered(tp2)
     case _ => false
@@ -1118,6 +1143,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         case _ =>
           NoType
       }
+    case tp1: RecType =>
+      tp1.rebind(distributeAnd(tp1.parent, tp2))
     case tp1: TypeBounds =>
       tp2 match {
         case tp2: TypeBounds => tp1 & tp2

src/dotty/tools/dotc/core/TypeOps.scala

@@ -232,11 +232,16 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
           }
         case _ =>
       }
+
       tp1 match {
+        case tp1: RecType =>
+          tp1.rebind(approximateOr(tp1.parent, tp2))
         case tp1: TypeProxy if !isClassRef(tp1) =>
           approximateUnion(next(tp1) | tp2)
         case _ =>
           tp2 match {
+            case tp2: RecType =>
+              tp2.rebind(approximateOr(tp1, tp2.parent))
             case tp2: TypeProxy if !isClassRef(tp2) =>
               approximateUnion(tp1 | next(tp2))
             case _ =>
@@ -252,16 +257,32 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     if (ctx.featureEnabled(defn.LanguageModuleClass, nme.keepUnions)) tp
     else tp match {
       case tp: OrType =>
-        approximateOr(tp.tp1, tp.tp2)
+        approximateOr(tp.tp1, tp.tp2)  // Maybe refactor using liftToRec?
       case tp @ AndType(tp1, tp2) =>
         tp derived_& (approximateUnion(tp1), approximateUnion(tp2))
       case tp: RefinedType =>
         tp.derivedRefinedType(approximateUnion(tp.parent), tp.refinedName, tp.refinedInfo)
+      case tp: RecType =>
+        tp.rebind(approximateUnion(tp.parent))
       case _ =>
         tp
     }
   }
 
+  /** Not currently needed:
+   *
+  def liftToRec(f: (Type, Type) => Type)(tp1: Type, tp2: Type)(implicit ctx: Context) = {
+    def f2(tp1: Type, tp2: Type): Type = tp2 match {
+      case tp2: RecType => tp2.rebind(f(tp1, tp2.parent))
+      case _ => f(tp1, tp2)
+    }
+    tp1 match {
+      case tp1: RecType => tp1.rebind(f2(tp1.parent, tp2))
+      case _ => f2(tp1, tp2)
+    }
+  }
+  */
+
   private def enterArgBinding(formal: Symbol, info: Type, cls: ClassSymbol, decls: Scope) = {
     val lazyInfo = new LazyType { // needed so we do not force `formal`.
       def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {