[WIP] Tenantive new HK scheme.

For the moment under newHK flag.

Author: odersky

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

@@ -668,7 +668,7 @@ class Definitions {
   private var myLambdaTraits: Set[Symbol] = Set()
 
   /** The set of HigherKindedXYZ traits encountered so far */
-  def lambdaTraits: Set[Symbol] = myLambdaTraits
+  def lambdaTraitsOBS: Set[Symbol] = myLambdaTraits
 
   private var LambdaTraitForVariances = mutable.Map[List[Int], ClassSymbol]()
 
@@ -689,7 +689,7 @@ class Definitions {
    *   - 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 LambdaTrait(vcs: List[Int]): ClassSymbol = {
+  def LambdaTraitOBS(vcs: List[Int]): ClassSymbol = {
     assert(vcs.nonEmpty)
 
     def varianceFlags(v: Int) = v match {
@@ -704,16 +704,16 @@ class Definitions {
         val paramDecls = newScope
         for (i <- 0 until vcs.length)
           newTypeParam(cls, tpnme.hkArg(i), varianceFlags(vcs(i)), paramDecls)
-        newTypeField(cls, tpnme.hkApply, Covariant, paramDecls)
+        newTypeField(cls, tpnme.hkApplyOBS, Covariant, paramDecls)
         val parentTraitRefs =
           for (i <- 0 until vcs.length if vcs(i) != 0)
-          yield LambdaTrait(vcs.updated(i, 0)).typeRef
+          yield LambdaTraitOBS(vcs.updated(i, 0)).typeRef
         denot.info = ClassInfo(
             ScalaPackageClass.thisType, cls, ObjectClass.typeRef :: parentTraitRefs.toList, paramDecls)
       }
     }
 
-    val traitName = tpnme.hkLambda(vcs)
+    val traitName = tpnme.hkLambdaOBS(vcs)
 
     def createTrait = {
       val cls = newClassSymbol(

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

@@ -115,12 +115,12 @@ object NameOps {
     def hkArgIndex: Int =
       name.drop(tpnme.hkArgPrefixLength).toString.toInt
 
-    def isLambdaTraitName(implicit ctx: Context): Boolean =
-      name.isTypeName && name.startsWith(tpnme.hkLambdaPrefix)
+    def isLambdaTraitNameOBS(implicit ctx: Context): Boolean =
+      name.isTypeName && name.startsWith(tpnme.hkLambdaPrefixOBS)
 
-    def lambdaTraitVariances(implicit ctx: Context): List[Int] = {
-      val vs = name.drop(tpnme.hkLambdaPrefix.length)
-      vs.toList.map(c => tpnme.varianceSuffixes.indexOf(c) - 1)
+    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

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

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

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

@@ -479,8 +479,8 @@ object SymDenotations {
       name.decode == tpnme.REFINE_CLASS
 
     /** is this symbol a trait representing a type lambda? */
-    final def isLambdaTrait(implicit ctx: Context): Boolean =
-      isClass && name.startsWith(tpnme.hkLambdaPrefix) && owner == defn.ScalaPackageClass
+    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 = {