[WIP] Change HK encoding

docs/SyntaxSummary.txt

@@ -96,6 +96,7 @@ grammar.
   ClassQualifier    ::=  `[' id `]'
 
   Type              ::=  FunArgTypes `=>' Type                                  Function(ts, t)
+                      |  HkTypeParamClause `->' Type						    TypeLambda(ps, t)
                       |  InfixType
   FunArgTypes       ::=  InfixType
                       | `(' [ FunArgType {`,' FunArgType } ] `)'
@@ -125,7 +126,6 @@ grammar.
   TypeParamBounds   ::=  TypeBounds {`<%' Type} {`:' Type}                      ContextBounds(typeBounds, tps)
 
   Expr              ::=  FunParams `=>' Expr                                    Function(args, expr), Function(ValDef([implicit], id, TypeTree(), EmptyTree), expr)
-                      |  Expr1
   FunParams         ::=  Bindings
                       |  [`implicit'] id
                       |  `_'

src/dotty/tools/dotc/ast/Desugar.scala

@@ -66,7 +66,7 @@ object desugar {
       val relocate = new TypeMap {
         val originalOwner = sym.owner
         def apply(tp: Type) = tp match {
-          case tp: NamedType if tp.symbol.owner eq originalOwner =>
+          case tp: NamedType if tp.symbol.exists && (tp.symbol.owner eq originalOwner) =>
             val defctx = ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next
             var local = defctx.denotNamed(tp.name).suchThat(_ is ParamOrAccessor).symbol
             if (local.exists) (defctx.owner.thisType select local).dealias

src/dotty/tools/dotc/ast/Trees.scala

@@ -594,6 +594,12 @@ object Trees {
     def forwardTo = tpt
   }
 
+  /** [typeparams] -> tpt */
+  case class TypeLambdaTree[-T >: Untyped] private[ast] (tparams: List[TypeDef[T]], body: Tree[T])
+    extends TypTree[T] {
+    type ThisTree[-T >: Untyped] = TypeLambdaTree[T]
+  }
+
   /** => T */
   case class ByNameTypeTree[-T >: Untyped] private[ast] (result: Tree[T])
   extends TypTree[T] {
@@ -851,6 +857,7 @@ object Trees {
     type OrTypeTree = Trees.OrTypeTree[T]
     type RefinedTypeTree = Trees.RefinedTypeTree[T]
     type AppliedTypeTree = Trees.AppliedTypeTree[T]
+    type TypeLambdaTree = Trees.TypeLambdaTree[T]
     type ByNameTypeTree = Trees.ByNameTypeTree[T]
     type TypeBoundsTree = Trees.TypeBoundsTree[T]
     type Bind = Trees.Bind[T]
@@ -1028,6 +1035,10 @@ object Trees {
         case tree: AppliedTypeTree if (tpt eq tree.tpt) && (args eq tree.args) => tree
         case _ => finalize(tree, untpd.AppliedTypeTree(tpt, args))
       }
+      def TypeLambdaTree(tree: Tree)(tparams: List[TypeDef], body: Tree): TypeLambdaTree = tree match {
+        case tree: TypeLambdaTree if (tparams eq tree.tparams) && (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.TypeLambdaTree(tparams, body))
+      }
       def ByNameTypeTree(tree: Tree)(result: Tree): ByNameTypeTree = tree match {
         case tree: ByNameTypeTree if result eq tree.result => tree
         case _ => finalize(tree, untpd.ByNameTypeTree(result))
@@ -1160,6 +1171,8 @@ object Trees {
           cpy.RefinedTypeTree(tree)(transform(tpt), transformSub(refinements))
         case AppliedTypeTree(tpt, args) =>
           cpy.AppliedTypeTree(tree)(transform(tpt), transform(args))
+        case TypeLambdaTree(tparams, body) =>
+          cpy.TypeLambdaTree(tree)(transformSub(tparams), transform(body))
         case ByNameTypeTree(result) =>
           cpy.ByNameTypeTree(tree)(transform(result))
         case TypeBoundsTree(lo, hi) =>
@@ -1264,6 +1277,9 @@ object Trees {
             this(this(x, tpt), refinements)
           case AppliedTypeTree(tpt, args) =>
             this(this(x, tpt), args)
+          case TypeLambdaTree(tparams, body) =>
+            implicit val ctx: Context = localCtx
+            this(this(x, tparams), body)
           case ByNameTypeTree(result) =>
             this(x, result)
           case TypeBoundsTree(lo, hi) =>

src/dotty/tools/dotc/ast/tpd.scala

@@ -21,7 +21,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   private def ta(implicit ctx: Context) = ctx.typeAssigner
 
   def Modifiers(sym: Symbol)(implicit ctx: Context): Modifiers = Modifiers(
-    sym.flags & ModifierFlags,
+    sym.flags & (if (sym.isType) ModifierFlags | VarianceFlags else ModifierFlags),
     if (sym.privateWithin.exists) sym.privateWithin.asType.name else tpnme.EMPTY,
     sym.annotations map (_.tree))
 

src/dotty/tools/dotc/ast/untpd.scala

@@ -137,6 +137,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def OrTypeTree(left: Tree, right: Tree): OrTypeTree = new OrTypeTree(left, right)
   def RefinedTypeTree(tpt: Tree, refinements: List[Tree]): RefinedTypeTree = new RefinedTypeTree(tpt, refinements)
   def AppliedTypeTree(tpt: Tree, args: List[Tree]): AppliedTypeTree = new AppliedTypeTree(tpt, args)
+  def TypeLambdaTree(tparams: List[TypeDef], body: Tree): TypeLambdaTree = new TypeLambdaTree(tparams, body)
   def ByNameTypeTree(result: Tree): ByNameTypeTree = new ByNameTypeTree(result)
   def TypeBoundsTree(lo: Tree, hi: Tree): TypeBoundsTree = new TypeBoundsTree(lo, hi)
   def Bind(name: Name, body: Tree): Bind = new Bind(name, body)

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

@@ -77,6 +77,11 @@ object Config {
    */
   final val checkProjections = false
 
+  /** If this flag is set it is checked that &/| only apply to types
+   *  that are either both hk types or both * types.
+   */
+  final val checkKinds = true
+
   /** The recursion depth for showing a summarized string */
   final val summarizeDepth = 2
 

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

@@ -239,6 +239,8 @@ trait ConstraintHandling {
       def addParamBound(bound: PolyParam) =
         if (fromBelow) addLess(bound, param) else addLess(param, bound)
 
+      assert(param.isHK == bound.isHK, s"$param / $bound / $fromBelow")
+
       /** Drop all constrained parameters that occur at the toplevel in `bound` and
        *  handle them by `addLess` calls.
        *  The preconditions make sure that such parameters occur only
@@ -285,6 +287,8 @@ trait ConstraintHandling {
           if (!addParamBound(bound)) NoType
           else if (fromBelow) defn.NothingType
           else defn.AnyType
+        case bound: RefinedType =>
+          bound.normalizeHkApply
         case _ =>
           bound
       }

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

@@ -167,7 +167,7 @@ class Definitions {
     lazy val Any_hashCode = newMethod(AnyClass, nme.hashCode_, MethodType(Nil, IntType))
     lazy val Any_toString = newMethod(AnyClass, nme.toString_, MethodType(Nil, StringType))
     lazy val Any_##       = newMethod(AnyClass, nme.HASHHASH, ExprType(IntType), Final)
-    lazy val Any_getClass = newMethod(AnyClass, nme.getClass_, MethodType(Nil, ClassClass.typeRef), Final)
+    lazy val Any_getClass = newMethod(AnyClass, nme.getClass_, MethodType(Nil, ClassClass.typeRef.appliedTo(TypeBounds.empty)), Final)
     lazy val Any_isInstanceOf = newT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final)
     lazy val Any_asInstanceOf = newT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, PolyParam(_, 0), Final)
 
@@ -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 lambdaTraits: 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 LambdaTrait(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.hkApply, Covariant, paramDecls)
-        val parentTraitRefs =
-          for (i <- 0 until vcs.length if vcs(i) != 0)
-          yield LambdaTrait(vcs.updated(i, 0)).typeRef
-        denot.info = ClassInfo(
-            ScalaPackageClass.thisType, cls, ObjectClass.typeRef :: parentTraitRefs.toList, paramDecls)
-      }
-    }
-
-    val traitName = tpnme.hkLambda(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/Denotations.scala

@@ -146,6 +146,9 @@ object Denotations {
     /** Is this denotation different from NoDenotation or an ErrorDenotation? */
     def exists: Boolean = true
 
+    /** A denotation with the info of this denotation transformed using `f` */
+    def mapInfo(f: Type => Type)(implicit ctx: Context): Denotation
+
     /** If this denotation does not exist, fallback to alternative */
     final def orElse(that: => Denotation) = if (this.exists) this else that
 
@@ -242,7 +245,7 @@ object Denotations {
       }
       else if (exists && !qualifies(symbol)) NoDenotation
       else asSingleDenotation
-     }
+    }
 
     /** Form a denotation by conjoining with denotation `that`.
      *
@@ -456,6 +459,8 @@ object Denotations {
       else if (!d2.exists) d1
       else derivedMultiDenotation(d1, d2)
     }
+    def mapInfo(f: Type => Type)(implicit ctx: Context): Denotation =
+      derivedMultiDenotation(denot1.mapInfo(f), denot2.mapInfo(f))
     def derivedMultiDenotation(d1: Denotation, d2: Denotation) =
       if ((d1 eq denot1) && (d2 eq denot2)) this else MultiDenotation(d1, d2)
     override def toString = alternatives.mkString(" <and> ")
@@ -488,6 +493,9 @@ object Denotations {
       if ((symbol eq this.symbol) && (info eq this.info)) this
       else newLikeThis(symbol, info)
 
+    def mapInfo(f: Type => Type)(implicit ctx: Context): SingleDenotation =
+      derivedSingleDenotation(symbol, f(info))
+
     def orElse(that: => SingleDenotation) = if (this.exists) this else that
 
     def altsWith(p: Symbol => Boolean): List[SingleDenotation] =

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

@@ -436,7 +436,8 @@ object Flags {
 
   /** Flags representing modifiers that can appear in trees */
   final val ModifierFlags =
-    SourceModifierFlags | Module | Param | Synthetic | Package | Local | commonFlags(Mutable)
+    SourceModifierFlags | Module | Param | Synthetic | Package | Local |
+    commonFlags(Mutable)
       // | Trait is subsumed by commonFlags(Lazy) from SourceModifierFlags
 
   assert(ModifierFlags.isTermFlags && ModifierFlags.isTypeFlags)

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

@@ -0,0 +1,34 @@
+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.
+ */
+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
+}

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

@@ -115,14 +115,6 @@ object NameOps {
     def hkArgIndex: Int =
       name.drop(tpnme.hkArgPrefixLength).toString.toInt
 
-    def isLambdaTraitName(implicit ctx: Context): Boolean =
-      name.isTypeName && name.startsWith(tpnme.hkLambdaPrefix)
-
-    def lambdaTraitVariances(implicit ctx: Context): List[Int] = {
-      val vs = name.drop(tpnme.hkLambdaPrefix.length)
-      vs.toList.map(c => tpnme.varianceSuffixes.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 hkApply: N              = "$Apply"
     val hkArgPrefix: N          = "$hk"
-    val hkLambdaPrefix: 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 hkLambda(vcs: List[Int]): TypeName = hkLambdaPrefix ++ vcs.map(varianceSuffix).mkString
     def hkArg(n: Int): TypeName = hkArgPrefix ++ n.toString
 
-    def varianceSuffix(v: Int): Char = varianceSuffixes.charAt(v + 1)
-    val varianceSuffixes = "NIP"
-
     final val Conforms = encode("<:<")
   }
 

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

@@ -179,21 +179,21 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def substRefinedThis(tp: Type, from: Type, to: Type, theMap: SubstRefinedThisMap): Type =
+  final def substRecThis(tp: Type, from: Type, to: Type, theMap: SubstRecThisMap): Type =
     tp match {
-      case tp @ RefinedThis(binder) =>
+      case tp @ RecThis(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))
+        else tp.derivedSelect(substRecThis(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))
+        tp.derivedRefinedType(substRecThis(tp.parent, from, to, theMap), tp.refinedName, substRecThis(tp.refinedInfo, from, to, theMap))
       case tp: TypeAlias =>
-        tp.derivedTypeAlias(substRefinedThis(tp.alias, from, to, theMap))
+        tp.derivedTypeAlias(substRecThis(tp.alias, from, to, theMap))
       case _ =>
-        (if (theMap != null) theMap else new SubstRefinedThisMap(from, to))
+        (if (theMap != null) theMap else new SubstRecThisMap(from, to))
           .mapOver(tp)
     }
 
@@ -266,8 +266,8 @@ 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)
   }
 
   final class SubstParamMap(from: ParamType, to: Type) extends DeepTypeMap {