Remove old hk scheme

- Simplify RefinedType

- Drop recursive definition of RefinedThis - this is now
taken over by RecType.
- Drop RefinedThis.
- Simplify typeParams

The logic avoiding forcing is no longer needed.
- Remove unused code and out of date comments.

src/dotty/tools/dotc/config/Config.scala

@@ -8,8 +8,6 @@ object Config {
   final val cacheMemberNames = true
   final val cacheImplicitScopes = true
 
-  final val newHK = true
-
   final val checkCacheMembersNamed = false
 
   /** When updating a constraint bound, check that the constrained parameter

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

@@ -663,71 +663,6 @@ class Definitions {
 
   def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
 
-  // ----- LambdaXYZ traits ------------------------------------------
-
-  private var myLambdaTraits: Set[Symbol] = Set()
-
-  /** The set of HigherKindedXYZ traits encountered so far */
-  def lambdaTraitsOBS: Set[Symbol] = myLambdaTraits
-
-  private var LambdaTraitForVariances = mutable.Map[List[Int], ClassSymbol]()
-
-  /** The HigherKinded trait corresponding to symbols `boundSyms` (which are assumed
-   *  to be the type parameters of a higher-kided type). This is a class symbol that
-   *  would be generated by the following schema.
-   *
-   *      trait LambdaXYZ extends Object with P1 with ... with Pn {
-   *        type v_1 hk$0; ...; type v_N hk$N;
-   *        type +$Apply
-   *      }
-   *
-   *  Here:
-   *
-   *   - v_i are the variances of the bound symbols (i.e. +, -, or empty).
-   *   - XYZ is a string of length N with one letter for each variant of a bound symbol,
-   *     using `P` (positive variance), `N` (negative variance), `I` (invariant).
-   *   - for each positive or negative variance v_i there is a parent trait Pj which
-   *     is the same as LambdaXYZ except that it has `I` in i-th position.
-   */
-  def LambdaTraitOBS(vcs: List[Int]): ClassSymbol = {
-    assert(vcs.nonEmpty)
-
-    def varianceFlags(v: Int) = v match {
-      case -1 => Contravariant
-      case  0 => EmptyFlags
-      case  1 => Covariant
-    }
-
-    val completer = new LazyType  {
-      def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
-        val cls = denot.asClass.classSymbol
-        val paramDecls = newScope
-        for (i <- 0 until vcs.length)
-          newTypeParam(cls, tpnme.hkArg(i), varianceFlags(vcs(i)), paramDecls)
-        newTypeField(cls, tpnme.hkApplyOBS, Covariant, paramDecls)
-        val parentTraitRefs =
-          for (i <- 0 until vcs.length if vcs(i) != 0)
-          yield LambdaTraitOBS(vcs.updated(i, 0)).typeRef
-        denot.info = ClassInfo(
-            ScalaPackageClass.thisType, cls, ObjectClass.typeRef :: parentTraitRefs.toList, paramDecls)
-      }
-    }
-
-    val traitName = tpnme.hkLambdaOBS(vcs)
-
-    def createTrait = {
-      val cls = newClassSymbol(
-        ScalaPackageClass,
-        traitName,
-        PureInterfaceCreationFlags | Synthetic,
-        completer)
-      myLambdaTraits += cls
-      cls
-    }
-
-    LambdaTraitForVariances.getOrElseUpdate(vcs, createTrait)
-  }
-
   // ----- primitive value class machinery ------------------------------------------
 
   /** This class would also be obviated by the implicit function type design */

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

@@ -116,14 +116,6 @@ object NameOps {
     def hkArgIndex: Int =
       name.drop(tpnme.hkArgPrefixLength).toString.toInt
 
-    def isLambdaTraitNameOBS(implicit ctx: Context): Boolean =
-      name.isTypeName && name.startsWith(tpnme.hkLambdaPrefixOBS)
-
-    def lambdaTraitVariancesOBS(implicit ctx: Context): List[Int] = {
-      val vs = name.drop(tpnme.hkLambdaPrefixOBS.length)
-      vs.toList.map(c => tpnme.varianceSuffixesOBS.indexOf(c) - 1)
-    }
-
     /** If the name ends with $nn where nn are
       * all digits, strip the $ and the digits.
       * Otherwise return the argument.

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

@@ -529,9 +529,7 @@ object StdNames {
 
     val synthSwitch: N          = "$synthSwitch"
 
-    val hkApplyOBS: N              = "$Apply"
     val hkArgPrefix: N          = "$hk"
-    val hkLambdaPrefixOBS: N       = "Lambda$"
     val hkArgPrefixHead: Char   = hkArgPrefix.head
     val hkArgPrefixLength: Int  = hkArgPrefix.length
 
@@ -744,12 +742,8 @@ object StdNames {
     def syntheticTypeParamNames(num: Int): List[TypeName] =
       (0 until num).map(syntheticTypeParamName)(breakOut)
 
-    def hkLambdaOBS(vcs: List[Int]): TypeName = hkLambdaPrefixOBS ++ vcs.map(varianceSuffixOBS).mkString
     def hkArg(n: Int): TypeName = hkArgPrefix ++ n.toString
 
-    def varianceSuffixOBS(v: Int): Char = varianceSuffixesOBS.charAt(v + 1)
-    val varianceSuffixesOBS = "NIP"
-
     final val Conforms = encode("<:<")
   }
 

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

@@ -179,24 +179,6 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def substRefinedThis(tp: Type, from: Type, to: Type, theMap: SubstRefinedThisMap): Type =
-    tp match {
-      case tp @ RefinedThis(binder) =>
-        if (binder eq from) to else tp
-      case tp: NamedType =>
-        if (tp.currentSymbol.isStatic) tp
-        else tp.derivedSelect(substRefinedThis(tp.prefix, from, to, theMap))
-      case _: ThisType | _: BoundType | NoPrefix =>
-        tp
-      case tp: RefinedType =>
-        tp.derivedRefinedType(substRefinedThis(tp.parent, from, to, theMap), tp.refinedName, substRefinedThis(tp.refinedInfo, from, to, theMap))
-      case tp: TypeAlias =>
-        tp.derivedTypeAlias(substRefinedThis(tp.alias, from, to, theMap))
-      case _ =>
-        (if (theMap != null) theMap else new SubstRefinedThisMap(from, to))
-          .mapOver(tp)
-    }
-
   final def substRecThis(tp: Type, from: Type, to: Type, theMap: SubstRecThisMap): Type =
     tp match {
       case tp @ RecThis(binder) =>
@@ -284,10 +266,6 @@ trait Substituters { this: Context =>
     def apply(tp: Type): Type = substThis(tp, from, to, this)
   }
 
-  final class SubstRefinedThisMap(from: Type, to: Type) extends DeepTypeMap {
-    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)
   }

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

@@ -483,10 +483,6 @@ object SymDenotations {
     final def isRefinementClass(implicit ctx: Context): Boolean =
       name.decode == tpnme.REFINE_CLASS
 
-    /** is this symbol a trait representing a type lambda? */
-    final def isLambdaTraitOBS(implicit ctx: Context): Boolean =
-      isClass && name.startsWith(tpnme.hkLambdaPrefixOBS) && owner == defn.ScalaPackageClass
-
     /** Is this symbol a package object or its module class? */
     def isPackageObject(implicit ctx: Context): Boolean = {
       val poName = if (isType) nme.PACKAGE_CLS else nme.PACKAGE