Remove refinement encoding of hk types

Remove the code that implemented the encoding of hk types
using refinements.

Drop the notion that RefinedTypes can be type parameters. This is
no longer true under the new representation.

Also, refactoring MemberBinding -> TypeParamInfo

17 files changed, 112 insertions, 653 deletions

diff --git a/src/dotty/tools/dotc/config/Config.scala b/src/dotty/tools/dotc/config/Config.scala
index cd2b7ea4b..eba42e881 100644
--- a/src/dotty/tools/dotc/config/Config.scala
+++ b/src/dotty/tools/dotc/config/Config.scala
@@ -10,8 +10,6 @@ object Config {
 
   final val checkCacheMembersNamed = false
 
-  final val newHK = true
-
   /** When updating a constraint bound, check that the constrained parameter
    *  does not appear at the top-level of either of its bounds.
    */
diff --git a/src/dotty/tools/dotc/core/ConstraintHandling.scala b/src/dotty/tools/dotc/core/ConstraintHandling.scala
index 44b6abe12..ace441566 100644
--- a/src/dotty/tools/dotc/core/ConstraintHandling.scala
+++ b/src/dotty/tools/dotc/core/ConstraintHandling.scala
@@ -286,8 +286,6 @@ trait ConstraintHandling {
           if (!addParamBound(bound)) NoType
           else if (fromBelow) defn.NothingType
           else defn.AnyType
-        case bound: RefinedType if !Config.newHK =>
-          bound.normalizeHkApplyOLD
         case _ =>
           bound
       }
diff --git a/src/dotty/tools/dotc/core/MemberBinding.scala b/src/dotty/tools/dotc/core/MemberBinding.scala
deleted file mode 100644
index bff8b30a0..000000000
--- a/src/dotty/tools/dotc/core/MemberBinding.scala
+++ /dev/null
@@ -1,35 +0,0 @@
-package dotty.tools.dotc.core
-
-import Names.Name
-import Contexts.Context
-import Types.{Type, TypeBounds}
-
-/** A common super trait of Symbol and Refinement.
- *  Used to capture the attributes of type parameters
- *  which can be implemented as either symbols or refinements.
- *  TODO: Rename (TypeParamInfo?)
- */
-trait MemberBinding {
-
-  /** Does this binding represent a type parameter?
-   *  Only in that case the rest of the binding's methods are significant.
-   */
-  def isTypeParam(implicit ctx: Context): Boolean
-
-  /** The name of the member */
-  def memberName(implicit ctx: Context): Name
-
-  /** The info of the member */
-  def memberBounds(implicit ctx: Context): TypeBounds
-
-  /** The info of the member as seen from a prefix type.
-   *  This can be different from `memberInfo` if the binding
-   *  is a type symbol of a class.
-   */
-  def memberBoundsAsSeenFrom(pre: Type)(implicit ctx: Context): TypeBounds
-
-  /** The variance of the type parameter
-   *  @pre: isTypeParam = true
-   */
-  def memberVariance(implicit ctx: Context): Int
-}
\ No newline at end of file
diff --git a/src/dotty/tools/dotc/core/NameOps.scala b/src/dotty/tools/dotc/core/NameOps.scala
index 120540dc7..f5e0eb8cd 100644
--- a/src/dotty/tools/dotc/core/NameOps.scala
+++ b/src/dotty/tools/dotc/core/NameOps.scala
@@ -101,21 +101,6 @@ object NameOps {
         name.length > 0 && name.last == '=' && name.head != '=' && isOperatorPart(name.head)
     }
 
-    /** Is this the name of a higher-kinded type parameter of a Lambda? */
-    def isHkArgNameOLD =
-      name.length > 0 &&
-      name.head == tpnme.hkArgPrefixHeadOLD &&
-      name.startsWith(tpnme.hkArgPrefixOLD) && {
-        val digits = name.drop(tpnme.hkArgPrefixLengthOLD)
-        digits.length <= 4 && digits.forall(_.isDigit)
-      }
-
-    /** The index of the higher-kinded type parameter with this name.
-     *  Pre: isLambdaArgName.
-     */
-    def hkArgIndexOLD: Int =
-      name.drop(tpnme.hkArgPrefixLengthOLD).toString.toInt
-
     /** If the name ends with $nn where nn are
       * all digits, strip the $ and the digits.
       * Otherwise return the argument.
diff --git a/src/dotty/tools/dotc/core/StdNames.scala b/src/dotty/tools/dotc/core/StdNames.scala
index 0adf80d8f..778d13cab 100644
--- a/src/dotty/tools/dotc/core/StdNames.scala
+++ b/src/dotty/tools/dotc/core/StdNames.scala
@@ -529,10 +529,6 @@ object StdNames {
 
     val synthSwitch: N          = "$synthSwitch"
 
-    val hkArgPrefixOLD: N          = "$hk"
-    val hkArgPrefixHeadOLD: Char   = hkArgPrefixOLD.head
-    val hkArgPrefixLengthOLD: Int  = hkArgPrefixOLD.length
-
     // unencoded operators
     object raw {
       final val AMP  : N  = "&"
@@ -746,8 +742,6 @@ object StdNames {
     def syntheticLambdaParamNames(num: Int): List[TypeName] =
       (0 until num).map(syntheticLambdaParamName)(breakOut)
 
-    def hkArgOLD(n: Int): TypeName = hkArgPrefixOLD ++ n.toString
-
     final val Conforms = encode("<:<")
   }
 
diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala
index c7eb54812..df8bc8116 100644
--- a/src/dotty/tools/dotc/core/Symbols.scala
+++ b/src/dotty/tools/dotc/core/Symbols.scala
@@ -367,7 +367,7 @@ object Symbols {
    *  @param coord  The coordinates of the symbol (a position or an index)
    *  @param id     A unique identifier of the symbol (unique per ContextBase)
    */
-  class Symbol private[Symbols] (val coord: Coord, val id: Int) extends DotClass with MemberBinding with printing.Showable {
+  class Symbol private[Symbols] (val coord: Coord, val id: Int) extends DotClass with TypeParamInfo with printing.Showable {
 
     type ThisName <: Name
 
@@ -489,12 +489,12 @@ object Symbols {
      */
     def pos: Position = if (coord.isPosition) coord.toPosition else NoPosition
 
-    // MemberBinding methods
+    // TypeParamInfo methods
     def isTypeParam(implicit ctx: Context) = denot.is(TypeParam)
-    def memberName(implicit ctx: Context): Name = name
-    def memberBounds(implicit ctx: Context) = denot.info.bounds
-    def memberBoundsAsSeenFrom(pre: Type)(implicit ctx: Context) = pre.memberInfo(this).bounds
-    def memberVariance(implicit ctx: Context) = denot.variance
+    def paramName(implicit ctx: Context): Name = name
+    def paramBounds(implicit ctx: Context) = denot.info.bounds
+    def paramBoundsAsSeenFrom(pre: Type)(implicit ctx: Context) = pre.memberInfo(this).bounds
+    def paramVariance(implicit ctx: Context) = denot.variance
 
 // -------- Printing --------------------------------------------------------
 
diff --git a/src/dotty/tools/dotc/core/TypeApplications.scala b/src/dotty/tools/dotc/core/TypeApplications.scala
index e989e42b7..a09039521 100644
--- a/src/dotty/tools/dotc/core/TypeApplications.scala
+++ b/src/dotty/tools/dotc/core/TypeApplications.scala
@@ -46,67 +46,16 @@ object TypeApplications {
 
   /** Does the variance of type parameter `tparam1` conform to the variance of type parameter `tparam2`?
    */
-  def varianceConforms(tparam1: MemberBinding, tparam2: MemberBinding)(implicit ctx: Context): Boolean =
-    varianceConforms(tparam1.memberVariance, tparam2.memberVariance)
+  def varianceConforms(tparam1: TypeParamInfo, tparam2: TypeParamInfo)(implicit ctx: Context): Boolean =
+    varianceConforms(tparam1.paramVariance, tparam2.paramVariance)
 
   /** Doe 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[MemberBinding], tparams2: List[MemberBinding])(implicit ctx: Context): Boolean =
+  def variancesConform(tparams1: List[TypeParamInfo], tparams2: List[TypeParamInfo])(implicit ctx: Context): Boolean =
     tparams1.corresponds(tparams2)(varianceConforms)
 
-  def fallbackTypeParamsOLD(variances: List[Int])(implicit ctx: Context): List[MemberBinding] = {
-    def memberBindings(vs: List[Int]): Type = vs match {
-      case Nil => NoType
-      case v :: vs1 =>
-        RefinedType(
-            memberBindings(vs1),
-            tpnme.hkArgOLD(vs1.length),
-            TypeBounds.empty.withBindingKind(BindingKind.fromVariance(v)))
-    }
-    def decompose(t: Type, acc: List[MemberBinding]): List[MemberBinding] = t match {
-      case t: RefinedType => decompose(t.parent, t :: acc)
-      case NoType => acc
-    }
-    decompose(memberBindings(variances), Nil)
-  }
-
-  /** Extractor for
-   *
-   *    [v1 X1: B1, ..., vn Xn: Bn] -> T
-   *    ==>
-   *    ([X_i := this.$hk_i] T) { type v_i $hk_i: (new)B_i }
-   */
-  object TypeLambdaOLD {
-    def apply(argBindingFns: List[RecType => TypeBounds],
-              bodyFn: RecType => Type)(implicit ctx: Context): Type = {
-      val argNames = argBindingFns.indices.toList.map(tpnme.hkArgOLD)
-      var idx = 0
-      RecType.closeOver(rt =>
-        (bodyFn(rt) /: argBindingFns) { (parent, argBindingFn) =>
-          val res = RefinedType(parent, tpnme.hkArgOLD(idx), argBindingFn(rt))
-          idx += 1
-          res
-        })
-    }
-
-    def unapply(tp: Type)(implicit ctx: Context): Option[( /*List[Int], */ List[TypeBounds], Type)] = {
-      def decompose(t: Type, acc: List[TypeBounds]): (List[TypeBounds], Type) = t match {
-        case t @ RefinedType(p, rname, rinfo: TypeBounds) if t.isTypeParam =>
-          decompose(p, rinfo.bounds :: acc)
-        case t: RecType =>
-          decompose(t.parent, acc)
-        case _ =>
-          (acc, t)
-      }
-      decompose(tp, Nil) match {
-        case (Nil, _) => None
-        case x => Some(x)
-      }
-    }
-  }
-
   /** Extractor for
    *
    *    [v1 X1: B1, ..., vn Xn: Bn] -> C[X1, ..., Xn]
@@ -118,33 +67,14 @@ object TypeApplications {
    */
   object EtaExpansion {
     def apply(tycon: Type)(implicit ctx: Context) = {
-      if (Config.newHK) assert(tycon.typeParams.nonEmpty, tycon)
-      else assert(tycon.isEtaExpandableOLD)
+      assert(tycon.typeParams.nonEmpty, tycon)
       tycon.EtaExpand(tycon.typeParamSymbols)
     }
 
-    def unapply(tp: Type)(implicit ctx: Context): Option[TypeRef] =
-      if (Config.newHK)
-        tp match {
-          case tp @ TypeLambda(tparams, AppliedType(fn: TypeRef, args))
-          if (args == tparams.map(_.toArg)) => Some(fn)
-          case _ => None
-        }
-      else {
-        def argsAreForwarders(args: List[Type], n: Int): Boolean = args match {
-          case Nil =>
-            n == 0
-          case TypeRef(RecThis(rt), sel) :: args1 if false =>
-            rt.eq(tp) && sel == tpnme.hkArgOLD(n - 1) && argsAreForwarders(args1, n - 1)
-          case _ =>
-            false
-        }
-        tp match {
-          case TypeLambdaOLD(argBounds, AppliedType(fn: TypeRef, args))
-          if argsAreForwarders(args, tp.typeParams.length) => Some(fn)
-          case _ => None
-        }
-      }
+    def unapply(tp: Type)(implicit ctx: Context): Option[TypeRef] = tp match {
+      case tp @ TypeLambda(tparams, AppliedType(fn: TypeRef, args)) if (args == tparams.map(_.toArg)) => Some(fn)
+      case _ => None
+    }
   }
 
   /** Extractor for type application T[U_1, ..., U_n]. This is the refined type
@@ -165,13 +95,13 @@ object TypeApplications {
           refinements = rt :: refinements
           tycon = rt.parent.stripTypeVar
         }
-        def collectArgs(tparams: List[MemberBinding],
+        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 =>
             Some((tycon, argBuf.toList))
           case RefinedType(_, rname, rinfo) :: refinements1
-          if tparams.nonEmpty && rname == tparams.head.memberName =>
+          if tparams.nonEmpty && rname == tparams.head.paramName =>
             collectArgs(tparams.tail, refinements1, argBuf += rinfo.argInfo)
           case _ =>
             None
@@ -186,44 +116,16 @@ object TypeApplications {
 
    /** Adapt all arguments to possible higher-kinded type parameters using etaExpandIfHK
    */
-  def etaExpandIfHK(tparams: List[MemberBinding], 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 {
-      def bounds(tparam: MemberBinding) = tparam match {
+      def bounds(tparam: TypeParamInfo) = tparam match {
         case tparam: Symbol => tparam.infoOrCompleter
-        case tparam: RefinedType if !Config.newHK => tparam.memberBounds
-        case tparam: LambdaParam => tparam.memberBounds
+        case tparam: LambdaParam => tparam.paramBounds
       }
       args.zipWithConserve(tparams)((arg, tparam) => arg.etaExpandIfHK(bounds(tparam)))
     }
 
-  /** The references `<rt>.this.$hk0, ..., <rt>.this.$hk<n-1>`. */
-  def argRefsOLD(rt: RecType, n: Int)(implicit ctx: Context) =
-    List.range(0, n).map(i => RecThis(rt).select(tpnme.hkArgOLD(i)))
-
-  private class InstMapOLD(fullType: Type)(implicit ctx: Context) extends TypeMap {
-    var localRecs: Set[RecType] = Set.empty
-    var keptRefs: Set[Name] = Set.empty
-    var tyconIsHK: Boolean = true
-    def apply(tp: Type): Type = tp match {
-      case tp @ TypeRef(RecThis(rt), sel) if sel.isHkArgNameOLD && localRecs.contains(rt) =>
-        fullType.member(sel).info match {
-          case TypeAlias(alias) => apply(alias)
-          case _ => keptRefs += sel; tp
-        }
-      case tp: TypeVar if !tp.inst.exists =>
-        val bounds = tp.instanceOpt.orElse(ctx.typeComparer.bounds(tp.origin))
-        bounds.foreachPart {
-          case TypeRef(RecThis(rt), sel) if sel.isHkArgNameOLD && localRecs.contains(rt) =>
-            keptRefs += sel
-          case _ =>
-        }
-        tp
-      case _ =>
-        mapOver(tp)
-    }
-  }
-
   /** A type map that tries to reduce a (part of) the result type of the type lambda `tycon`
    *  with the given `args`(some of which are wildcard arguments represented by type bounds).
    *  Non-wildcard arguments are substituted everywhere as usual. A wildcard argument
@@ -281,7 +183,7 @@ 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[MemberBinding] = /*>|>*/ track("typeParams") /*<|<*/ {
+  final def typeParams(implicit ctx: Context): List[TypeParamInfo] = /*>|>*/ track("typeParams") /*<|<*/ {
     self match {
       case self: ClassInfo =>
         self.cls.typeParams
@@ -293,8 +195,7 @@ class TypeApplications(val self: Type) extends AnyVal {
         else if (!tsym.isCompleting) tsym.info.typeParams
         else Nil
       case self: RefinedType =>
-        val precedingParams = self.parent.typeParams.filterNot(_.memberName == self.refinedName)
-        if (self.isTypeParam) precedingParams :+ self else precedingParams
+        self.parent.typeParams.filterNot(_.paramName == self.refinedName)
       case self: RecType =>
         self.parent.typeParams
       case _: HKApply | _: SingletonType =>
@@ -309,7 +210,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** If `self` is a higher-kinded type, its type parameters $hk_i, otherwise Nil */
-  final def hkTypeParams(implicit ctx: Context): List[MemberBinding] =
+  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 */
@@ -384,7 +285,7 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** Is self type higher-kinded (i.e. of kind != "*")? */
   def isHK(implicit ctx: Context): Boolean = self.dealias match {
     case self: TypeRef => self.info.isHK
-    case self: RefinedType => !Config.newHK && self.isTypeParam
+    case self: RefinedType => false
     case self: TypeLambda => true
     case self: HKApply => false
     case self: SingletonType => false
@@ -410,8 +311,7 @@ class TypeApplications(val self: Type) extends AnyVal {
           if (!tsym.isCompleting || tsym.isAliasType) tsym.info.knownHK
           else 0
       }
-    case self: RefinedType =>
-      if (!Config.newHK && self.isTypeParam) 1 else -1
+    case self: RefinedType => -1
     case self: TypeLambda => 1
     case self: HKApply => -1
     case self: SingletonType => -1
@@ -423,12 +323,6 @@ class TypeApplications(val self: Type) extends AnyVal {
     case _ => -1
   }
 
-  /** is receiver a higher-kinded application? */
-  def isHKApplyOLD(implicit ctx: Context): Boolean = self match {
-    case self @ RefinedType(_, name, _) => name.isHkArgNameOLD && !self.isTypeParam
-    case _ => false
-  }
-
   /** True if it can be determined without forcing that the class symbol
    *  of this application exists. Equivalent to
    *
@@ -457,25 +351,6 @@ class TypeApplications(val self: Type) extends AnyVal {
       self
   }
 
-  /** 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 recursifyOLD[T <: Type](tparams: List[MemberBinding])(implicit ctx: Context): RecType => T =
-    tparams match {
-      case (_: Symbol) :: _ =>
-        (rt: RecType) =>
-          new ctx.SafeSubstMap(tparams.asInstanceOf[List[Symbol]], argRefsOLD(rt, tparams.length))
-            .apply(self).asInstanceOf[T]
-      case _ =>
-        def mapRefs(rt: RecType) = new TypeMap {
-          def apply(t: Type): Type = t match {
-            case rthis: RecThis if tparams contains rthis.binder.parent => RecThis(rt)
-            case _ => mapOver(t)
-          }
-        }
-        mapRefs(_).apply(self).asInstanceOf[T]
-    }
-
   /** Lambda abstract `self` with given type parameters. Examples:
    *
    *      type T[X] = U        becomes    type T = [X] -> U
@@ -485,124 +360,18 @@ class TypeApplications(val self: Type) extends AnyVal {
    */
   def LambdaAbstract(tparams: List[Symbol])(implicit ctx: Context): Type = {
     def expand(tp: Type) =
-      if (Config.newHK)
-        TypeLambda(
-          tpnme.syntheticLambdaParamNames(tparams.length), tparams.map(_.variance))(
-            tl => tparams.map(tparam => tl.lifted(tparams, tparam.info).bounds),
-            tl => tl.lifted(tparams, tp))
-      else
-        TypeLambdaOLD(
-          tparams.map(tparam =>
-            tparam.memberBoundsAsSeenFrom(self)
-              .withBindingKind(BindingKind.fromVariance(tparam.variance))
-              .recursifyOLD(tparams)),
-          tp.recursifyOLD(tparams))
-
+      TypeLambda(
+        tpnme.syntheticLambdaParamNames(tparams.length), tparams.map(_.variance))(
+          tl => tparams.map(tparam => tl.lifted(tparams, tparam.info).bounds),
+          tl => tl.lifted(tparams, tp))
     assert(!isHK, self)
-    if (Config.newHK) self match {
+    self match {
       case self: TypeAlias =>
         self.derivedTypeAlias(expand(self.alias))
       case self @ TypeBounds(lo, hi) =>
         self.derivedTypeBounds(lo, expand(hi))
       case _ => expand(self)
     }
-    else self match {
-      case self: TypeAlias =>
-        self.derivedTypeAlias(expand(self.alias.normalizeHkApplyOLD))
-      case self @ TypeBounds(lo, hi) =>
-        self.derivedTypeBounds(lo, expand(hi.normalizeHkApplyOLD))
-      case _ => expand(self)
-    }
-  }
-
-  /** If `self` is a * type, perform the following rewritings:
-   *
-   *  1. For every occurrence of `z.$hk_i`, where `z` is a RecThis type that refers
-   *     to some recursive type in `self`, if the member of `self.hk$i` has an alias
-   *     type `= U`:
-   *
-   *         z.$hk_i  -->  U
-   *
-   *  2. For every top-level binding `type A = z.$hk_i$, where `z` is a RecThis type that refers
-   *     to some recursive type in `self`, if the member of `self` has bounds `S..U`:
-   *
-   *         type A = z.$hk_i  -->  type A >: S <: U
-   *
-   *  3. If the type constructor preceding all bindings is a * type, delete every top-level
-   *     binding `{ type $hk_i ... }` where `$hk_i` does not appear in the prefix of the binding.
-   *     I.e.
-   *
-   *         T { type $hk_i ... }  -->  T
-   *
-   *     If `$hk_i` does not appear in `T`.
-   *
-   *  A binding is top-level if it can be reached by
-   *
-   *   - following aliases unless the type is a LazyRef
-   *     (need to keep cycle breakers around, see i974.scala)
-   *   - dropping refinements and rec-types
-   *   - going from a wildcard type to its upper bound
-   */
-  def normalizeHkApplyOLD(implicit ctx: Context): Type = self.strictDealias match {
-    case self1 @ RefinedType(_, rname, _) if rname.isHkArgNameOLD && self1.typeParams.isEmpty =>
-      val inst = new InstMapOLD(self)
-
-      def instTop(tp: Type): Type = tp.strictDealias match {
-        case tp: RecType =>
-          inst.localRecs += tp
-          tp.rebind(instTop(tp.parent))
-        case tp @ RefinedType(parent, rname, rinfo) =>
-          rinfo match {
-            case TypeAlias(TypeRef(RecThis(rt), sel)) if sel.isHkArgNameOLD && inst.localRecs.contains(rt) =>
-              val bounds @ TypeBounds(_, _) = self.member(sel).info
-              instTop(tp.derivedRefinedType(parent, rname, bounds.withBindingKind(NoBinding)))
-            case _ =>
-              val parent1 = instTop(parent)
-              if (rname.isHkArgNameOLD &&
-                !inst.tyconIsHK &&
-                !inst.keptRefs.contains(rname)) parent1
-              else tp.derivedRefinedType(parent1, rname, inst(rinfo))
-          }
-        case tp @ WildcardType(bounds @ TypeBounds(lo, hi)) =>
-          tp.derivedWildcardType(bounds.derivedTypeBounds(inst(lo), instTop(hi)))
-        case tp: LazyRef =>
-          instTop(tp.ref)
-        case tp =>
-          inst.tyconIsHK = tp.isHK
-          inst(tp)
-      }
-
-      def isLazy(tp: Type): Boolean = tp.strictDealias match {
-        case tp: RefinedOrRecType => isLazy(tp.parent)
-        case tp @ WildcardType(bounds @ TypeBounds(lo, hi)) => isLazy(hi)
-        case tp: LazyRef => true
-        case _ => false
-      }
-
-      val reduced =
-        if (isLazy(self1)) {
-          // A strange dance is needed here to make 974.scala compile.
-          val res = LazyRef(() => instTop(self))
-          res.ref         // without this line, pickling 974.scala fails with an assertion error
-                          // saying that we address a RecThis outside its Rec (in the case of RecThis of pickleNewType)
-          res             // without this line, typing 974.scala gives a stackoverflow in asSeenFrom.
-        }
-        else instTop(self)
-      if (reduced ne self) {
-        hk.println(i"reduce $self  -->  $reduced / ${inst.tyconIsHK}")
-        //hk.println(s"reduce $self  -->  $reduced")
-      }
-      reduced
-    case _ => self
-  }
-
-  /** A type ref is eta expandable if it refers to a non-lambda class.
-   *  In that case we can look for parameterized base types of the type
-   *  to eta expand them.
-   */
-  def isEtaExpandableOLD(implicit ctx: Context) = self match {
-    case self: TypeRef => self.symbol.isClass
-    case _ => false
   }
 
   /** Convert a type constructor `TC` which has type parameters `T1, ..., Tn`
@@ -681,23 +450,12 @@ class TypeApplications(val self: Type) extends AnyVal {
     else {
       def adaptArg(arg: Type): Type = arg match {
         case arg @ TypeLambda(tparams, body) if
-             !tparams.corresponds(hkParams)(_.memberVariance == _.memberVariance) &&
+             !tparams.corresponds(hkParams)(_.paramVariance == _.paramVariance) &&
              tparams.corresponds(hkParams)(varianceConforms) =>
-          TypeLambda(tparams.map(_.memberName), hkParams.map(_.memberVariance))(
+          TypeLambda(tparams.map(_.paramName), hkParams.map(_.paramVariance))(
             tl => arg.paramBounds.map(_.subst(arg, tl).bounds),
             tl => arg.resultType.subst(arg, tl)
           )
-        case arg @ TypeLambdaOLD(tparamBounds, body) if
-             !arg.typeParams.corresponds(hkParams)(_.memberVariance == _.memberVariance) &&
-             arg.typeParams.corresponds(hkParams)(varianceConforms) =>
-          def adjustVariance(bounds: TypeBounds, tparam: MemberBinding): TypeBounds =
-            bounds.withBindingKind(BindingKind.fromVariance(tparam.memberVariance))
-          def lift[T <: Type](tp: T): (RecType => T) = arg match {
-            case rt0: RecType => tp.subst(rt0, _).asInstanceOf[T]
-            case _ => (x => tp)
-          }
-          val adjusted = (tparamBounds, hkParams).zipped.map(adjustVariance)
-          TypeLambdaOLD(adjusted.map(lift), lift(body))
         case arg @ TypeAlias(alias) =>
           arg.derivedTypeAlias(adaptArg(alias))
         case arg @ TypeBounds(lo, hi) =>
@@ -731,16 +489,6 @@ class TypeApplications(val self: Type) extends AnyVal {
         self.instantiate(args)
       case EtaExpansion(self1) =>
         self1.appliedTo(args)
-      case TypeLambdaOLD(_, body) if !args.exists(_.isInstanceOf[TypeBounds]) =>
-        def substHkArgs = new TypeMap {
-          def apply(tp: Type): Type = tp match {
-            case TypeRef(RecThis(rt), name) if rt.eq(self) && name.isHkArgNameOLD =>
-              args(name.hkArgIndexOLD)
-            case _ =>
-              mapOver(tp)
-          }
-        }
-        substHkArgs(body)
       case self1: WildcardType =>
         self1
       case _ =>
@@ -753,12 +501,12 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  @param args     = `U1, ..., Un`
    *  @param tparams  are assumed to be the type parameters of `T`.
    */
-  final def appliedTo(args: List[Type], typParams: List[MemberBinding])(implicit ctx: Context): Type = {
-    def matchParams(t: Type, tparams: List[MemberBinding], args: List[Type])(implicit ctx: Context): Type = args match {
+  final def appliedTo(args: List[Type], typParams: List[TypeParamInfo])(implicit ctx: Context): Type = {
+    def matchParams(t: Type, tparams: List[TypeParamInfo], args: List[Type])(implicit ctx: Context): Type = args match {
       case arg :: args1 =>
         try {
           val tparam :: tparams1 = tparams
-          matchParams(RefinedType(t, tparam.memberName, arg.toBounds(tparam)), tparams1, args1)
+          matchParams(RefinedType(t, tparam.paramName, arg.toBounds(tparam)), tparams1, args1)
         } catch {
           case ex: MatchError =>
             println(s"applied type mismatch: $self with underlying ${self.underlyingIfProxy}, args = $args, typeParams = $typParams") // !!! DEBUG
@@ -790,12 +538,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       case _ if typParams.isEmpty || typParams.head.isInstanceOf[LambdaParam] =>
         HKApply(self, args)
       case dealiased =>
-        matchParams(dealiased, typParams, args) match {
-          case refined @ RefinedType(_, pname, _) if !Config.newHK && pname.isHkArgNameOLD =>
-            refined.betaReduceOLD
-          case refined =>
-            refined
-        }
+        matchParams(dealiased, typParams, args)
     }
   }
 
@@ -810,34 +553,21 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  up hk type parameters matching the arguments. This is needed when unpickling
    *  Scala2 files such as `scala.collection.generic.Mapfactory`.
    */
-  final def safeAppliedTo(args: List[Type])(implicit ctx: Context) =
-    if (Config.newHK)
-      self match {
-        case self: TypeRef if !self.symbol.isClass && self.symbol.isCompleting =>
-          HKApply(self, args)
-        case _ =>
-          appliedTo(args, typeParams)
-      }
-    else {
-      val safeTypeParams = self match {
-        case self: TypeRef if !self.symbol.isClass && self.symbol.isCompleting =>
-          // This happens when unpickling e.g. scala$collection$generic$GenMapFactory$$CC
-          ctx.warning(i"encountered F-bounded higher-kinded type parameters for ${self.symbol}; assuming they are invariant")
-          fallbackTypeParamsOLD(args map alwaysZero)
-        case _ =>
-          typeParams
-      }
-      appliedTo(args, safeTypeParams)
-    }
+  final def safeAppliedTo(args: List[Type])(implicit ctx: Context) = self match {
+    case self: TypeRef if !self.symbol.isClass && self.symbol.isCompleting =>
+      HKApply(self, args)
+    case _ =>
+      appliedTo(args, typeParams)
+  }
 
   /** Turn this type, which is used as an argument for
    *  type parameter `tparam`, into a TypeBounds RHS
    */
-  final def toBounds(tparam: MemberBinding)(implicit ctx: Context): TypeBounds = self match {
+  final def toBounds(tparam: TypeParamInfo)(implicit ctx: Context): TypeBounds = self match {
     case self: TypeBounds => // this can happen for wildcard args
       self
     case _ =>
-      val v = tparam.memberVariance
+      val v = tparam.paramVariance
       /* Not neeeded.
       if (v > 0 && !(tparam is Local) && !(tparam is ExpandedTypeParam)) TypeBounds.upper(self)
       else if (v < 0 && !(tparam is Local) && !(tparam is ExpandedTypeParam)) TypeBounds.lower(self)
diff --git a/src/dotty/tools/dotc/core/TypeComparer.scala b/src/dotty/tools/dotc/core/TypeComparer.scala
index 38b45b2b0..55a964ee9 100644
--- a/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -364,16 +364,9 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
               // This twist is needed to make collection/generic/ParFactory.scala compile
               fourthTry(tp1, tp2) || compareRefinedSlow
             case _ =>
-              if (tp2.isTypeParam) {
-                compareHkLambdaOLD(tp1, tp2) ||
-                fourthTry(tp1, tp2)
-              }
-              else {
-                compareHkApplyOLD(tp2, tp1, inOrder = false) ||
-                compareRefinedSlow ||
-                fourthTry(tp1, tp2) ||
-                compareAliasedRefined(tp2, tp1, inOrder = false)
-              }
+              compareRefinedSlow ||
+              fourthTry(tp1, tp2) ||
+              compareAliasedRefined(tp2, tp1, inOrder = false) // @@@ still needed?
           }
         else // fast path, in particular for refinements resulting from parameterization.
           isSubRefinements(tp1w.asInstanceOf[RefinedType], tp2, skipped2) &&
@@ -399,7 +392,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
           // so the bounds checking should look like this:
           //
           //   tparams1.corresponds(tparams2)((tparam1, tparam2) =>
-          //     isSubType(tparam2.memberBounds.subst(tp2, tp1), tparam1.memberBounds))
+          //     isSubType(tparam2.paramBounds.subst(tp2, tp1), tparam1.paramBounds))
           //
           // But that would invalidate a pattern such as
           // `[X0 <: Number] -> Number   <:<    [X0] -> Any`
@@ -531,7 +524,6 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       }
       isNewSubType(tp1.underlying.widenExpr, tp2) || comparePaths
     case tp1: RefinedType =>
-      compareHkApplyOLD(tp1, tp2, inOrder = true) ||
       isNewSubType(tp1.parent, tp2) ||
       compareAliasedRefined(tp1, tp2, inOrder = true)
     case tp1: RecType =>
@@ -693,10 +685,10 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
   /** Subtype test for corresponding arguments in `args1`, `args2` according to
    *  variances in type parameters `tparams`.
    */
-  def isSubArgs(args1: List[Type], args2: List[Type], tparams: List[MemberBinding]): Boolean =
+  def isSubArgs(args1: List[Type], args2: List[Type], tparams: List[TypeParamInfo]): Boolean =
     if (args1.isEmpty) args2.isEmpty
     else args2.nonEmpty && {
-      val v = tparams.head.memberVariance
+      val v = tparams.head.paramVariance
       (v > 0 || isSubType(args2.head, args1.head)) &&
       (v < 0 || isSubType(args1.head, args2.head))
     }
@@ -706,7 +698,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
    *   - the type parameters of `B` match one-by-one the variances of `tparams`,
    *   - `B` satisfies predicate `p`.
    */
-  private def testLifted(tp1: Type, tp2: Type, tparams: List[MemberBinding], p: Type => Boolean): Boolean = {
+  private def testLifted(tp1: Type, tp2: Type, tparams: List[TypeParamInfo], p: Type => Boolean): Boolean = {
     val classBounds = tp2.classSymbols
     def recur(bcs: List[ClassSymbol]): Boolean = bcs match {
       case bc :: bcs1 =>
@@ -722,109 +714,6 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     recur(tp1.baseClasses)
   }
 
-  /** Handle subtype tests
-   *
-   *      app <:< other   if inOrder = true
-   *      other <:< app   if inOrder = false
-   *
-   *  where `app` is an hk application but `other` is not.
-   *
-   *  As a first step, if `app` appears on the right, try to normalize it using
-   *  `normalizeHkApply`, if that gives a different type proceed with a regular subtype
-   *  test using that type instead of `app`.
-   *
-   *  Otherwise, if `app` has constrainable poly param as type constructor,
-   *  perform the following steps:
-   *
-   *   (1) If not `inOrder` then perform the next steps until they all succeed
-   *       for each base type of other which
-   *        - derives from a class bound of `app`,
-   *        - has the same number of type parameters as `app`
-   *        - has type parameter variances which conform to those of `app`.
-   *       If `inOrder` then perform the same steps on the original `other` type.
-   *
-   *   (2) Try to eta expand the constructor of `other`.
-   *
-   *   (3a) In mode `TypevarsMissConetxt` replace the projection's hk constructor parameter
-   *        by the eta expansion of step (2) reapplied to the projection's arguments.
-   *   (3b) In normal mode, try to unify the projection's hk constructor parameter with
-   *        the eta expansion of step(2)
-   *
-   *   (4) If `inOrder`, test `app <: other` else test `other <: app`.
-   */
-  def compareHkApplyOLD(app: RefinedType, other: Type, inOrder: Boolean): Boolean = {
-    def tryInfer(tp: Type): Boolean = ctx.traceIndented(i"compareHK($app, $other, inOrder = $inOrder, constr = $tp)", subtyping) {
-      tp match {
-        case tp: TypeVar => tryInfer(tp.underlying)
-        case param: PolyParam if canConstrain(param) =>
-
-          def unifyWith(liftedOther: Type): Boolean = {
-            subtyping.println(i"unify with $liftedOther")
-            liftedOther.typeConstructor.widen match {
-              case tycon: TypeRef if tycon.isEtaExpandableOLD && tycon.typeParams.nonEmpty =>
-                val (ok, app1) =
-                  if (ctx.mode.is(Mode.TypevarsMissContext))
-                    (true, EtaExpansion(tycon).appliedTo(app.argInfos))
-                  else
-                    (tryInstantiate(param, EtaExpansion(tycon)), app)
-                ok &&
-                (if (inOrder) isSubType(app1, other) else isSubType(other, app1))
-              case _ =>
-                false
-            }
-          }
-          val hkTypeParams = param.typeParams
-          subtyping.println(i"classBounds = ${app.classSymbols}")
-          subtyping.println(i"base classes = ${other.baseClasses}")
-          subtyping.println(i"type params = $hkTypeParams, ${app.classSymbol}")
-          if (inOrder) unifyWith(other)
-          else testLifted(other, app, hkTypeParams, unifyWith)
-        case _ =>
-          // why only handle the case where one of the sides is a typevar or poly param?
-          // If the LHS is a hk application, then the normal logic already handles
-          // all other cases. Indeed, say you have
-          //
-          //     type C[T] <: List[T]
-          //
-          // where C is an abstract type. Then to verify `C[Int] <: List[Int]`,
-          // use compareRefinedslow to get `C <: List` and verify that
-          //
-          //      C#List$T = C$$hk0 = Int
-          //
-          // If the RHS is a hk application, we can also go through
-          // the normal logic because lower bounds are not parameterized.
-          // If were to re-introduce parameterized lower bounds of hk types
-          // we'd have to add some logic to handle them here.
-          false
-      }
-    }
-    app.isHKApplyOLD && !other.isHKApplyOLD && {
-      val reduced = if (inOrder) app else app.normalizeHkApplyOLD
-      if (reduced ne app)
-        if (inOrder) isSubType(reduced, other) else isSubType(other, reduced)
-      else tryInfer(app.typeConstructor.dealias)
-    }
-  }
-
-  /** Compare type lambda with non-lambda type. */
-  def compareHkLambdaOLD(tp1: Type, tp2: RefinedType): Boolean = tp1.stripTypeVar match {
-    case TypeLambdaOLD(args1, body1) =>
-      //println(i"comparing $tp1 <:< $tp2")
-      tp2 match {
-        case TypeLambdaOLD(args2, body2) =>
-          args1.corresponds(args2)((arg1, arg2) =>
-            varianceConforms(BindingKind.toVariance(arg1.bindingKind),
-                              BindingKind.toVariance(arg2.bindingKind))) &&
-          // don't compare bounds; it would go in the wrong sense anyway.
-          isSubType(body1, body2)
-        case _ => false
-      }
-    case RefinedType(parent1, _, _) =>
-      compareHkLambdaOLD(parent1, tp2)
-    case _ =>
-      false
-  }
-
   /** Say we are comparing a refined type `P{type M = U}` or `P{type M >: L <: U}`.
    *  If P#M refers to a BaseTypeArg aliased to some other typeref P#N,
    *  do the same comparison with `P{type N = U}` or `P{type N >: L <: U}`, respectively.
@@ -1324,45 +1213,25 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
   private def liftIfHK(tp1: Type, tp2: Type, op: (Type, Type) => Type, original: (Type, Type) => Type) = {
     val tparams1 = tp1.typeParams
     val tparams2 = tp2.typeParams
-    if (!Config.newHK && tparams1.isEmpty || tparams2.isEmpty) op(tp1, tp2)
-    else if (Config.newHK && tparams1.isEmpty)
+    if (tparams1.isEmpty)
       if (tparams2.isEmpty) op(tp1, tp2)
-      else original(tp1, tp2.appliedTo(tp2.typeParams.map(_.memberBoundsAsSeenFrom(tp2))))
-    else if (Config.newHK && tparams2.isEmpty)
-      original(tp1.appliedTo(tp1.typeParams.map(_.memberBoundsAsSeenFrom(tp1))), tp2)
-    else if (!Config.newHK && (tparams1.isEmpty || tparams2.isEmpty)) op(tp1, tp2)
-    else if (!Config.newHK && tparams1.length != tparams2.length) mergeConflict(tp1, tp2)
-    else if (Config.newHK) {
+      else original(tp1, tp2.appliedTo(tp2.typeParams.map(_.paramBoundsAsSeenFrom(tp2))))
+    else if (tparams2.isEmpty)
+      original(tp1.appliedTo(tp1.typeParams.map(_.paramBoundsAsSeenFrom(tp1))), tp2)
+    else {
       val numArgs = tparams1.length
       def argRefs(tl: GenericType) = List.range(0, numArgs).map(PolyParam(tl, _))
       TypeLambda(
         paramNames = tpnme.syntheticLambdaParamNames(numArgs),
         variances = (tparams1, tparams2).zipped.map((tparam1, tparam2) =>
-          (tparam1.memberVariance + tparam2.memberVariance) / 2))(
+          (tparam1.paramVariance + tparam2.paramVariance) / 2))(
         paramBoundsExp = tl => (tparams1, tparams2).zipped.map((tparam1, tparam2) =>
-          tl.lifted(tparams1, tparam1.memberBoundsAsSeenFrom(tp1)).bounds &
-          tl.lifted(tparams2, tparam2.memberBoundsAsSeenFrom(tp2)).bounds),
+          tl.lifted(tparams1, tparam1.paramBoundsAsSeenFrom(tp1)).bounds &
+          tl.lifted(tparams2, tparam2.paramBoundsAsSeenFrom(tp2)).bounds),
         resultTypeExp = tl =>
           original(tl.lifted(tparams1, tp1).appliedTo(argRefs(tl)),
              tl.lifted(tparams2, tp2).appliedTo(argRefs(tl))))
     }
-    else {
-      val bindings: List[RecType => TypeBounds] =
-        (tparams1, tparams2).zipped.map { (tparam1, tparam2) =>
-          val b1: RecType => TypeBounds =
-            tparam1.memberBoundsAsSeenFrom(tp1).recursifyOLD(tparams1)
-          val b2: RecType => TypeBounds =
-            tparam2.memberBoundsAsSeenFrom(tp2).recursifyOLD(tparams2)
-          (rt: RecType) => (b1(rt) & b2(rt))
-            .withBindingKind(
-              BindingKind.fromVariance(
-                (tparam1.memberVariance + tparam2.memberVariance) / 2))
-        }
-      val app1: RecType => Type = rt => tp1.appliedTo(argRefsOLD(rt, tparams1.length))
-      val app2: RecType => Type = rt => tp2.appliedTo(argRefsOLD(rt, tparams2.length))
-      val body: RecType => Type = rt => op(app1(rt), app2(rt))
-      TypeLambdaOLD(bindings, body)
-    }
   }
 
   /** Try to distribute `&` inside type, detect and handle conflicts
@@ -1652,19 +1521,5 @@ class ExplainingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
     }
   }
 
-  override def compareHkApplyOLD(app: RefinedType, other: Type, inOrder: Boolean) =
-    if (app.isHKApplyOLD)
-      traceIndented(i"compareHkApply $app, $other, $inOrder, ${app.normalizeHkApplyOLD}") {
-        super.compareHkApplyOLD(app, other, inOrder)
-      }
-    else super.compareHkApplyOLD(app, other, inOrder)
-
-  override def compareHkLambdaOLD(tp1: Type, tp2: RefinedType): Boolean =
-    if (tp2.isTypeParam)
-      traceIndented(i"compareHkLambda $tp1, $tp2") {
-        super.compareHkLambdaOLD(tp1, tp2)
-      }
-    else super.compareHkLambdaOLD(tp1, tp2)
-
   override def toString = "Subtype trace:" + { try b.toString finally b.clear() }
 }
diff --git a/src/dotty/tools/dotc/core/TypeOps.scala b/src/dotty/tools/dotc/core/TypeOps.scala
index 0d02de1da..3a797cce3 100644
--- a/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/src/dotty/tools/dotc/core/TypeOps.scala
@@ -158,7 +158,6 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       tp
     case tp: RefinedType =>
       tp.derivedRefinedType(simplify(tp.parent, theMap), tp.refinedName, simplify(tp.refinedInfo, theMap))
-        .normalizeHkApplyOLD
     case tp: TypeAlias =>
       tp.derivedTypeAlias(simplify(tp.alias, theMap))
     case AndType(l, r) =>
@@ -386,7 +385,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
     // Strip all refinements from parent type, populating `refinements` and `formals` maps.
     def normalizeToRef(tp: Type): TypeRef = {
       def fail = throw new TypeError(s"unexpected parent type: $tp")
-      tp.dealias.normalizeHkApplyOLD match {
+      tp.dealias match {
         case tp: TypeRef =>
           tp
         case tp @ RefinedType(tp1, name: TypeName, rinfo) =>
diff --git a/src/dotty/tools/dotc/core/TypeParamInfo.scala b/src/dotty/tools/dotc/core/TypeParamInfo.scala
new file mode 100644
index 000000000..ff3c8fca7
--- /dev/null
+++ b/src/dotty/tools/dotc/core/TypeParamInfo.scala
@@ -0,0 +1,29 @@
+package dotty.tools.dotc.core
+
+import Names.Name
+import Contexts.Context
+import Types.{Type, TypeBounds}
+
+/** A common super trait of Symbol and LambdaParam.
+ *  Used to capture the attributes of type parameters which can be implemented as either.
+ */
+trait TypeParamInfo {
+
+  /** Is this the info of a type parameter? Might be wrong for symbols */
+  def isTypeParam(implicit ctx: Context): Boolean
+
+  /** The name of the type parameter */
+  def paramName(implicit ctx: Context): Name
+
+  /** The info of the type parameter */
+  def paramBounds(implicit ctx: Context): TypeBounds
+
+  /** The info of the type parameter as seen from a prefix type.
+   *  This can be different from `memberInfo` if the binding
+   *  is a type symbol of a class.
+   */
+  def paramBoundsAsSeenFrom(pre: Type)(implicit ctx: Context): TypeBounds
+
+  /** The variance of the type parameter */
+  def paramVariance(implicit ctx: Context): Int
+}
\ No newline at end of file
diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala
index c9d2b5029..9150925ff 100644
--- a/src/dotty/tools/dotc/core/Types.scala
+++ b/src/dotty/tools/dotc/core/Types.scala
@@ -116,12 +116,8 @@ object Types {
           case TypeAlias(tp) => tp.isRef(sym)
           case _ =>  this1.symbol eq sym
         }
-      case this1: RefinedType =>
-        !this1.isTypeParam && this1.parent.isRef(sym)
-      case this1: RecType =>
-        this1.parent.isRef(sym)
-      case _ =>
-        false
+      case this1: RefinedOrRecType => this1.parent.isRef(sym)
+      case _ => false
     }
 
     /** Is this type a (neither aliased nor applied) reference to class `sym`? */
@@ -939,7 +935,7 @@ object Types {
         tp.underlying.underlyingClassRef(refinementOK)
       case tp: RefinedType =>
         def isParamName = tp.classSymbol.typeParams.exists(_.name == tp.refinedName)
-        if (refinementOK || tp.isTypeParam || isParamName) tp.underlying.underlyingClassRef(refinementOK)
+        if (refinementOK || isParamName) tp.underlying.underlyingClassRef(refinementOK)
         else NoType
       case tp: RecType =>
         tp.underlying.underlyingClassRef(refinementOK)
@@ -2099,8 +2095,7 @@ object Types {
    *  @param infoFn: A function that produces the info of the refinement declaration,
    *                 given the refined type itself.
    */
-  abstract case class RefinedType(parent: Type, refinedName: Name, refinedInfo: Type)
-    extends RefinedOrRecType with BindingType with MemberBinding {
+  abstract case class RefinedType(parent: Type, refinedName: Name, refinedInfo: Type) extends RefinedOrRecType {
 
     override def underlying(implicit ctx: Context) = parent
 
@@ -2111,42 +2106,6 @@ object Types {
       this
     }
 
-    def betaReduceOLD(implicit ctx: Context): Type = refinedInfo match {
-      case TypeAlias(alias) if refinedName.isHkArgNameOLD =>
-        def instantiate(rt: RecType) = new TypeMap {
-          def apply(t: Type) = t match {
-            case TypeRef(RecThis(`rt`), `refinedName`) => alias
-            case tp: TypeRef =>
-              val pre1 = apply(tp.prefix)
-              if (pre1 ne tp.prefix) tp.newLikeThis(pre1) else tp
-            case _ => mapOver(t)
-          }
-        }
-        def substAlias(tp: Type): Type = tp.safeDealias match {
-          case tp @ RefinedType(p, rname, rinfo) if tp.isTypeParam =>
-            if (rname == refinedName) p // check bounds?
-            else tp.derivedRefinedType(substAlias(p), rname, rinfo)
-          case tp: RecType =>
-            val p1 = substAlias(tp.parent)
-            if (p1 ne tp.parent) tp.rebind(instantiate(tp)(p1))
-            else tp
-          case _ =>
-            tp
-        }
-        parent match {
-          case parent: LazyRef =>
-            LazyRef(() => derivedRefinedType(parent.ref, refinedName, refinedInfo))
-          case _ =>
-            val reduced = substAlias(parent)
-            if (reduced ne parent) {
-              hk.println(i"REDUCE $this ----> ${reduced}")
-              reduced
-            } else this
-        }
-      case _ =>
-        this
-    }
-
     def derivedRefinedType(parent: Type, refinedName: Name, refinedInfo: Type)(implicit ctx: Context): Type =
       if ((parent eq this.parent) && (refinedName eq this.refinedName) && (refinedInfo eq this.refinedInfo)) this
       else {
@@ -2156,7 +2115,7 @@ object Types {
         // A Y-check error (incompatible types involving hk lambdas) for dotty itself.
         // TODO: investigate and, if possible, drop after revision.
         val normalizedRefinedInfo = refinedInfo.substRecThis(dummyRec, dummyRec)
-        RefinedType(parent, refinedName, normalizedRefinedInfo).betaReduceOLD
+        RefinedType(parent, refinedName, normalizedRefinedInfo)
       }
 
     /** Add this refinement to `parent`, provided If `refinedName` is a member of `parent`. */
@@ -2164,17 +2123,6 @@ object Types {
       if (parent.member(refinedName).exists) derivedRefinedType(parent, refinedName, refinedInfo)
       else parent
 
-    // MemberBinding methods
-    // TODO: Needed?
-    def isTypeParam(implicit ctx: Context) = refinedInfo match {
-      case tp: TypeBounds => tp.isBinding
-      case _ => false
-    }
-    def memberName(implicit ctx: Context) = refinedName
-    def memberBounds(implicit ctx: Context) = refinedInfo.bounds
-    def memberBoundsAsSeenFrom(pre: Type)(implicit ctx: Context) = memberBounds
-    def memberVariance(implicit ctx: Context) = BindingKind.toVariance(refinedInfo.bounds.bindingKind)
-
     override def equals(that: Any) = that match {
       case that: RefinedType =>
         this.parent == that.parent &&
@@ -2623,7 +2571,7 @@ object Types {
 
     def duplicate(paramNames: List[TypeName] = this.paramNames, paramBounds: List[TypeBounds] = this.paramBounds, resType: Type)(implicit ctx: Context): GenericType
 
-    def lifted(tparams: List[MemberBinding], t: Type)(implicit ctx: Context): Type =
+    def lifted(tparams: List[TypeParamInfo], t: Type)(implicit ctx: Context): Type =
       tparams match {
         case LambdaParam(poly, _) :: _ =>
           t.subst(poly, this)
@@ -2710,12 +2658,12 @@ object Types {
   }
 
   /** The parameter of a type lambda */
-  case class LambdaParam(tl: TypeLambda, n: Int) extends MemberBinding {
+  case class LambdaParam(tl: TypeLambda, n: Int) extends TypeParamInfo {
     def isTypeParam(implicit ctx: Context) = true
-    def memberName(implicit ctx: Context): TypeName = tl.paramNames(n)
-    def memberBounds(implicit ctx: Context): TypeBounds = tl.paramBounds(n)
-    def memberBoundsAsSeenFrom(pre: Type)(implicit ctx: Context): TypeBounds = memberBounds
-    def memberVariance(implicit ctx: Context): Int = tl.variances(n)
+    def paramName(implicit ctx: Context): TypeName = tl.paramNames(n)
+    def paramBounds(implicit ctx: Context): TypeBounds = tl.paramBounds(n)
+    def paramBoundsAsSeenFrom(pre: Type)(implicit ctx: Context): TypeBounds = paramBounds
+    def paramVariance(implicit ctx: Context): Int = tl.variances(n)
     def toArg: Type = PolyParam(tl, n)
   }
 
@@ -2756,7 +2704,7 @@ object Types {
       case _ => defn.AnyType
     }
 
-    def typeParams(implicit ctx: Context): List[MemberBinding] = {
+    def typeParams(implicit ctx: Context): List[TypeParamInfo] = {
       val tparams = tycon.typeParams
       if (tparams.isEmpty) TypeLambda.any(args.length).typeParams else tparams
     }
@@ -3574,10 +3522,10 @@ object Types {
           if (inst.exists) apply(inst) else tp
 
         case tp: HKApply =>
-          def mapArg(arg: Type, tparam: MemberBinding): Type = {
+          def mapArg(arg: Type, tparam: TypeParamInfo): Type = {
             val saved = variance
-            if (tparam.memberVariance < 0) variance = -variance
-            else if (tparam.memberVariance == 0) variance = 0
+            if (tparam.paramVariance < 0) variance = -variance
+            else if (tparam.paramVariance == 0) variance = 0
             try this(arg)
             finally variance = saved
           }
diff --git a/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index f604bff62..6a51b9642 100644
--- a/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -257,7 +257,7 @@ class TreePickler(pickler: TastyPickler) {
     case tpe: TypeLambda =>
       writeByte(LAMBDAtype)
       val paramNames = tpe.typeParams.map(tparam =>
-        varianceToPrefix(tparam.memberVariance) +: tparam.memberName)
+        varianceToPrefix(tparam.paramVariance) +: tparam.paramName)
       pickleMethodic(tpe.resultType, paramNames, tpe.paramBounds)
     case tpe: MethodType if richTypes =>
       writeByte(METHODtype)
diff --git a/src/dotty/tools/dotc/printing/PlainPrinter.scala b/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 880804b9e..656650d91 100644
--- a/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -51,8 +51,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
           homogenize(tp1) & homogenize(tp2)
         case OrType(tp1, tp2) =>
           homogenize(tp1) | homogenize(tp2)
-        case tp: RefinedType if !Config.newHK =>
-          tp.normalizeHkApplyOLD
         case tp: SkolemType =>
           homogenize(tp.info)
         case tp: LazyRef =>
diff --git a/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index c772267e7..34456d0b9 100644
--- a/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -113,36 +113,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (defn.isFunctionClass(cls)) return toTextFunction(args)
         if (defn.isTupleClass(cls)) return toTextTuple(args)
         return (toTextLocal(tycon) ~ "[" ~ Text(args map argText, ", ") ~ "]").close
-      case tp @ TypeLambdaOLD(argBoundss, body) =>
-        val variances = argBoundss.map(b => BindingKind.toVariance(b.bindingKind))
-        val prefix = ((('X' - 'A') + lambdaNestingLevel) % 26 + 'A').toChar
-        val paramNames = argBoundss.indices.toList.map(prefix.toString + _)
-        val instantiate = new TypeMap {
-          def contains(tp1: Type, tp2: Type): Boolean =
-            tp1.eq(tp2) || {
-              tp1.stripTypeVar match {
-                case tp1: RefinedOrRecType => contains(tp1.parent, tp2)
-                case _ => false
-              }
-            }
-          def apply(t: Type): Type = t match {
-            case TypeRef(RecThis(rt), name) if name.isHkArgNameOLD && contains(tp, rt) =>
-              // Make up a name that prints as "Xi". Need to be careful we do not
-              // accidentally unique-hash to something else. That's why we can't
-              // use prefix = NoPrefix or a WithFixedSym instance.
-              TypeRef.withSymAndName(
-                defn.EmptyPackageClass.thisType, defn.AnyClass,
-                paramNames(name.hkArgIndexOLD).toTypeName)
-            case _ =>
-              mapOver(t)
-          }
-        }
-        val instArgs = argBoundss.map(instantiate).asInstanceOf[List[TypeBounds]]
-        val instBody = instantiate(body).dropAlias
-        lambdaNestingLevel += 1
-        try
-          return typeLambdaText(paramNames, variances, instArgs, instBody)
-        finally lambdaNestingLevel -=1
       case tp: TypeRef =>
         val hideType = tp.symbol is AliasPreferred
         if (hideType && !ctx.phase.erasedTypes && !tp.symbol.isCompleting) {
diff --git a/src/dotty/tools/dotc/typer/TypeAssigner.scala b/src/dotty/tools/dotc/typer/TypeAssigner.scala
index e26ea1138..0344ae6c6 100644
--- a/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -4,10 +4,9 @@ package typer
 
 import core._
 import ast._
-import config.Config.newHK
 import Scopes._, Contexts._, Constants._, Types._, Symbols._, Names._, Flags._, Decorators._
 import ErrorReporting._, Annotations._, Denotations._, SymDenotations._, StdNames._, TypeErasure._
-import TypeApplications.{AppliedType, TypeLambdaOLD}
+import TypeApplications.AppliedType
 import util.Positions._
 import config.Printers._
 import ast.Trees._
@@ -99,7 +98,7 @@ trait TypeAssigner {
           val base = apply(tycon)
           var args = tp.baseArgInfos(base.typeSymbol)
           if (base.typeParams.length != args.length)
-            args = base.typeParams.map(_.memberBounds)
+            args = base.typeParams.map(_.paramBounds)
           base.appliedTo(args)
         case tp @ RefinedType(parent, name, rinfo) if variance > 0 =>
           val parent1 = apply(tp.parent)
@@ -413,7 +412,7 @@ trait TypeAssigner {
     def refineNamed(tycon: Type, arg: Tree) = arg match {
       case ast.Trees.NamedArg(name, argtpt) =>
         // Dotty deviation: importing ast.Trees._ and matching on NamedArg gives a cyclic ref error
-        val tparam = tparams.find(_.memberName == name) match {
+        val tparam = tparams.find(_.paramName == name) match {
           case Some(tparam) => tparam
           case none => ntparams.find(_.name == name).getOrElse(NoSymbol)
         }
@@ -430,16 +429,7 @@ trait TypeAssigner {
   }
 
   def assignType(tree: untpd.TypeLambdaTree, tparamDefs: List[TypeDef], body: Tree)(implicit ctx: Context) =
-    if (newHK) tree.withType(TypeLambda.fromSymbols(tparamDefs.map(_.symbol), body.tpe))
-    else {
-      val tparams = tparamDefs.map(_.symbol)
-      val argBindingFns = tparams.map(tparam =>
-        tparam.info.bounds
-          .withBindingKind(BindingKind.fromVariance(tparam.variance))
-          .recursifyOLD(tparams))
-      val bodyFn = body.tpe.recursifyOLD(tparams)
-      tree.withType(TypeLambdaOLD(argBindingFns, bodyFn))
-  }
+    tree.withType(TypeLambda.fromSymbols(tparamDefs.map(_.symbol), body.tpe))
 
   def assignType(tree: untpd.ByNameTypeTree, result: Tree)(implicit ctx: Context) =
     tree.withType(ExprType(result.tpe))
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 49d69f04e..da176427a 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -942,10 +942,10 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             ctx.error(d"wrong number of type arguments for ${tpt1.tpe}, should be ${tparams.length}", tree.pos)
             args = args.take(tparams.length)
           }
-          def typedArg(arg: untpd.Tree, tparam: MemberBinding) = {
+          def typedArg(arg: untpd.Tree, tparam: TypeParamInfo) = {
             val (desugaredArg, argPt) =
               if (ctx.mode is Mode.Pattern)
-                (if (isVarPattern(arg)) desugar.patternVar(arg) else arg, tparam.memberBounds)
+                (if (isVarPattern(arg)) desugar.patternVar(arg) else arg, tparam.paramBounds)
               else
                 (arg, WildcardType)
             typed(desugaredArg, argPt)
diff --git a/src/dotty/tools/dotc/typer/Variances.scala b/src/dotty/tools/dotc/typer/Variances.scala
index a2f9a0f16..a8abe5e30 100644
--- a/src/dotty/tools/dotc/typer/Variances.scala
+++ b/src/dotty/tools/dotc/typer/Variances.scala
@@ -84,11 +84,11 @@ object Variances {
     case ExprType(restpe) =>
       varianceInType(restpe)(tparam)
     case tp @ HKApply(tycon, args) =>
-      def varianceInArgs(v: Variance, args: List[Type], tparams: List[MemberBinding]): Variance =
+      def varianceInArgs(v: Variance, args: List[Type], tparams: List[TypeParamInfo]): Variance =
         args match {
           case arg :: args1 =>
             varianceInArgs(
-              v & compose(varianceInType(arg)(tparam), tparams.head.memberVariance),
+              v & compose(varianceInType(arg)(tparam), tparams.head.paramVariance),
               args1, tparams.tail)
           case nil =>
             v