4 files changed, 14 insertions, 7 deletions
diff --git a/src/dotty/tools/dotc/typer/Checking.scala b/src/dotty/tools/dotc/typer/Checking.scala
index 37753fe65..6944197a1 100644
--- a/src/dotty/tools/dotc/typer/Checking.scala
+++ b/src/dotty/tools/dotc/typer/Checking.scala
@@ -174,6 +174,8 @@ object Checking {
         mapOver(tp)
       case tp @ RefinedType(parent, name, rinfo) =>
         tp.derivedRefinedType(this(parent), name, this(rinfo, nestedCycleOK, nestedCycleOK))
+      case tp: RecType =>
+        tp.rebind(this(tp.parent))
       case tp @ TypeRef(pre, name) =>
         try {
           // A prefix is interesting if it might contain (transitively) a reference
@@ -187,7 +189,7 @@ object Checking {
             case SuperType(thistp, _) => isInteresting(thistp)
             case AndType(tp1, tp2) => isInteresting(tp1) || isInteresting(tp2)
             case OrType(tp1, tp2) => isInteresting(tp1) && isInteresting(tp2)
-            case _: RefinedType => true
+            case _: RefinedOrRecType => true
             case _ => false
           }
           if (isInteresting(pre)) {
@@ -433,12 +435,14 @@ trait Checking {
   }
 
   /** Check that any top-level type arguments in this type are feasible, i.e. that
-   *  their lower bound conforms to their upper cound. If a type argument is
+   *  their lower bound conforms to their upper bound. If a type argument is
    *  infeasible, issue and error and continue with upper bound.
    */
   def checkFeasible(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type = tp match {
     case tp: RefinedType =>
       tp.derivedRefinedType(tp.parent, tp.refinedName, checkFeasible(tp.refinedInfo, pos, where))
+    case tp: RecType =>
+      tp.rebind(tp.parent)
     case tp @ TypeBounds(lo, hi) if !(lo <:< hi) =>
       ctx.error(d"no type exists between low bound $lo and high bound $hi$where", pos)
       TypeAlias(hi)
diff --git a/src/dotty/tools/dotc/typer/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala
index b686e6eed..47c3631b8 100644
--- a/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -430,8 +430,8 @@ trait TypeAssigner {
     val argBindingFns = tparams.map(tparam =>
       tparam.info.bounds
         .withBindingKind(BindingKind.fromVariance(tparam.variance))
-        .internalizeFrom(tparams))
-    val bodyFn = body.tpe.internalizeFrom(tparams)
+        .recursify(tparams))
+    val bodyFn = body.tpe.recursify(tparams)
     tree.withType(TypeApplicationsNewHK.TypeLambda(argBindingFns, bodyFn))
   }
 
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index d5a32dbc0..fb3418563 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -917,11 +917,12 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       if ((rsym.is(Method) || rsym.isType) && rsym.allOverriddenSymbols.isEmpty)
         ctx.error(i"refinement $rsym without matching type in parent $parent", refinement.pos)
       val rinfo = if (rsym is Accessor) rsym.info.resultType else rsym.info
-      RefinedType(parent, rsym.name, rt => rinfo.substThis(refineCls, RefinedThis(rt)))
+      RefinedType(parent, rsym.name, rinfo)
       // todo later: check that refinement is within bounds
     }
-    val res = cpy.RefinedTypeTree(tree)(tpt1, refinements1) withType
-      (tpt1.tpe /: refinements1)(addRefinement)
+    val refined = (tpt1.tpe /: refinements1)(addRefinement)
+    val res = cpy.RefinedTypeTree(tree)(tpt1, refinements1).withType(
+      RecType.closeOver(rt => refined.substThis(refineCls, RecThis(rt))))
     typr.println(i"typed refinement: ${res.tpe}")
     res
   }
diff --git a/src/dotty/tools/dotc/typer/Variances.scala b/src/dotty/tools/dotc/typer/Variances.scala
index bc9730140..e88423f98 100644
--- a/src/dotty/tools/dotc/typer/Variances.scala
+++ b/src/dotty/tools/dotc/typer/Variances.scala
@@ -77,6 +77,8 @@ object Variances {
       else flip(varianceInType(lo)(tparam)) & varianceInType(hi)(tparam)
     case tp @ RefinedType(parent, _, rinfo) =>
       varianceInType(parent)(tparam) & varianceInType(rinfo)(tparam)
+    case tp: RecType =>
+      varianceInType(tp.parent)(tparam)
     case tp @ MethodType(_, paramTypes) =>
       flip(varianceInTypes(paramTypes)(tparam)) & varianceInType(tp.resultType)(tparam)
     case ExprType(restpe) =>