Abstract type parameters out from type symbols

In the new hk scheme, a type parameter can be represented by a
refinement without a corresponding symbol. Therefore, we need
to disentangle the info inherent in a type parameter from the
contents of a type symbol. We achieve this by creating a common
super trait "MemerInfo" of Symbol and RefinedType.

Author: odersky

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

@@ -0,0 +1,21 @@
+package dotty.tools.dotc.core
+
+import Names.Name
+import Contexts.Context
+import Types.Type
+
+/** The common info associated with a member symbol and a refinement */
+trait MemberInfo {
+
+  def exists(implicit ctx: Context): Boolean
+
+  def memberName(implicit ctx: Context): Name
+
+  def memberInfo(implicit ctx: Context): Type
+
+  def memberInfoAsSeenFrom(pre: Type)(implicit ctx: Context): Type
+
+  def memberVariance(implicit ctx: Context): Int
+
+
+}

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 printing.Showable {
+  class Symbol private[Symbols] (val coord: Coord, val id: Int) extends DotClass with MemberInfo with printing.Showable {
 
     type ThisName <: Name
 
@@ -489,6 +489,13 @@ object Symbols {
      */
     def pos: Position = if (coord.isPosition) coord.toPosition else NoPosition
 
+    // MemberInfo methods
+    def exists(implicit ctx: Context) = denot.exists
+    def memberName(implicit ctx: Context): Name = name
+    def memberInfo(implicit ctx: Context) = denot.info
+    def memberInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = pre.memberInfo(this)
+    def memberVariance(implicit ctx: Context) = denot.variance
+
 // -------- Printing --------------------------------------------------------
 
     /** The prefix string to be used when displaying this symbol without denotation */

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

@@ -75,10 +75,10 @@ object TypeApplications {
   /** Does the variance of `sym1` conform to the variance of `sym2`?
    *  This is the case if the variances are the same or `sym` is nonvariant.
    */
-  def varianceConforms(sym1: TypeSymbol, sym2: TypeSymbol)(implicit ctx: Context) =
-    sym1.variance == sym2.variance || sym2.variance == 0
+  def varianceConforms(sym1: MemberInfo, sym2: MemberInfo)(implicit ctx: Context) =
+    sym1.memberVariance == sym2.memberVariance || sym2.memberVariance == 0
 
-  def variancesConform(syms1: List[TypeSymbol], syms2: List[TypeSymbol])(implicit ctx: Context) =
+  def variancesConform(syms1: List[MemberInfo], syms2: List[MemberInfo])(implicit ctx: Context) =
     syms1.corresponds(syms2)(varianceConforms)
 
   /** Extractor for
@@ -143,7 +143,7 @@ object TypeApplications {
   object EtaExpansion {
     def apply(tycon: TypeRef)(implicit ctx: Context) = {
       assert(tycon.isEtaExpandable)
-      tycon.EtaExpand(tycon.typeParams)
+      tycon.EtaExpand(tycon.typeParamSymbols)
     }
 
     def unapply(tp: Type)(implicit ctx: Context): Option[TypeRef] = {
@@ -280,7 +280,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[TypeSymbol] = /*>|>*/ track("typeParams") /*<|<*/ {
+  final def typeParams(implicit ctx: Context): List[MemberInfo] = /*>|>*/ track("typeParams") /*<|<*/ {
     self match {
       case self: ClassInfo =>
         self.cls.typeParams
@@ -309,7 +309,7 @@ class TypeApplications(val self: Type) extends AnyVal {
           val sym = self.parent.classSymbol
           if (sym.isLambdaTrait) return sym.typeParams
         }
-        self.parent.typeParams.filterNot(_.name == self.refinedName)
+        self.parent.typeParams.filterNot(_.memberName == self.refinedName)
       case self: SingletonType =>
         Nil
       case self: TypeProxy =>
@@ -319,6 +319,12 @@ class TypeApplications(val self: Type) extends AnyVal {
     }
   }
 
+  final def typeParamSymbols(implicit ctx: Context): List[TypeSymbol] = {
+    val tparams = typeParams
+    assert(tparams.isEmpty || tparams.head.isInstanceOf[Symbol])
+    tparams.asInstanceOf[List[TypeSymbol]]
+  }
+
   /** The named type parameters declared or inherited by this type.
    *  These are all uninstantiated named type parameters of this type or one
    *  of its base types.
@@ -498,7 +504,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  v1 is compatible with v2, if v1 = v2 or v2 is non-variant.
    */
   def EtaExpand(tparams: List[TypeSymbol])(implicit ctx: Context): Type = {
-    val tparamsToUse = if (variancesConform(typeParams, tparams)) tparams else typeParams
+    val tparamsToUse = if (variancesConform(typeParams, tparams)) tparams else typeParamSymbols
     self.appliedTo(tparams map (_.typeRef)).LambdaAbstract(tparamsToUse)
       //.ensuring(res => res.EtaReduce =:= self, s"res = $res, core = ${res.EtaReduce}, self = $self, hc = ${res.hashCode}")
   }
@@ -508,7 +514,7 @@ class TypeApplications(val self: Type) extends AnyVal {
     case self: RefinedType =>
       self.derivedRefinedType(self.parent.EtaExpandCore, self.refinedName, self.refinedInfo)
     case _ =>
-      self.EtaExpand(self.typeParams)
+      self.EtaExpand(self.typeParamSymbols)
   }
 
   /** Eta expand if `self` is a (non-lambda) class reference and `bound` is a higher-kinded type */
@@ -621,12 +627,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[TypeSymbol])(implicit ctx: Context): Type = {
-    def matchParams(t: Type, tparams: List[TypeSymbol], args: List[Type])(implicit ctx: Context): Type = args match {
+  final def appliedTo(args: List[Type], typParams: List[MemberInfo])(implicit ctx: Context): Type = {
+    def matchParams(t: Type, tparams: List[MemberInfo], args: List[Type])(implicit ctx: Context): Type = args match {
       case arg :: args1 =>
         try {
           val tparam :: tparams1 = tparams
-          matchParams(RefinedType(t, tparam.name, arg.toBounds(tparam)), tparams1, args1)
+          matchParams(RefinedType(t, tparam.memberName, arg.toBounds(tparam)), tparams1, args1)
         } catch {
           case ex: MatchError =>
             println(s"applied type mismatch: $self $args, typeParams = $typParams") // !!! DEBUG
@@ -667,11 +673,11 @@ class TypeApplications(val self: Type) extends AnyVal {
   /** Turn this type, which is used as an argument for
    *  type parameter `tparam`, into a TypeBounds RHS
    */
-  final def toBounds(tparam: Symbol)(implicit ctx: Context): TypeBounds = self match {
+  final def toBounds(tparam: MemberInfo)(implicit ctx: Context): TypeBounds = self match {
     case self: TypeBounds => // this can happen for wildcard args
       self
     case _ =>
-      val v = tparam.variance
+      val v = tparam.memberVariance
       /* 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)

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

@@ -534,7 +534,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[TypeSymbol], p: Type => Boolean): Boolean = {
+  private def testLifted(tp1: Type, tp2: Type, tparams: List[MemberInfo], p: Type => Boolean): Boolean = {
     val classBounds = tp2.member(tpnme.hkApply).info.classSymbols
     def recur(bcs: List[ClassSymbol]): Boolean = bcs match {
       case bc :: bcs1 =>
@@ -647,7 +647,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     }
   }
 
-  /** Replace any top-level recursive type `{ z => T }` in `tp` with 
+  /** Replace any top-level recursive type `{ z => T }` in `tp` with
    *  `[z := anchor]T`.
    */
   private def fixRecs(anchor: SingletonType, tp: Type): Type = {
@@ -1117,8 +1117,8 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
    *  in where we allow which interpretation.
    */
   private def liftIfHK(tp1: Type, tp2: Type, op: (Type, Type) => Type) = {
-    val tparams1 = tp1.typeParams
-    val tparams2 = tp2.typeParams
+    val tparams1 = tp1.typeParamSymbols // TODO revise for new hk scheme
+    val tparams2 = tp2.typeParamSymbols
     def onlyNamed(tparams: List[TypeSymbol]) = tparams.forall(!_.is(ExpandedName))
     if (tparams1.isEmpty || tparams2.isEmpty ||
         onlyNamed(tparams1) && onlyNamed(tparams2)) op(tp1, tp2)

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

@@ -861,7 +861,7 @@ object Types {
         def isParamName = tp.classSymbol.typeParams.exists(_.name == tp.refinedName)
         if (refinementOK || isParamName) tp.underlying.underlyingClassRef(refinementOK)
         else NoType
-      case tp: RecType if refinementOK => tp.parent 
+      case tp: RecType if refinementOK => tp.parent
       case _ => NoType
     }
 
@@ -2043,7 +2043,7 @@ object Types {
    *                 given the refined type itself.
    */
   abstract case class RefinedType(private var myParent: Type, refinedName: Name, private var myRefinedInfo: Type)
-    extends RefinedOrRecType with BindingType {
+    extends RefinedOrRecType with BindingType with MemberInfo {
 
     final def parent = myParent
     final def refinedInfo = myRefinedInfo
@@ -2082,6 +2082,13 @@ object Types {
       if (parent.member(refinedName).exists) derivedRefinedType(parent, refinedName, refinedInfo)
       else parent
 
+    // MemberInfo methods
+    def exists(implicit ctx: Context) = true
+    def memberName(implicit ctx: Context) = refinedName
+    def memberInfo(implicit ctx: Context) = refinedInfo
+    def memberInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = refinedInfo
+    def memberVariance(implicit ctx: Context) = BindingKind.toVariance(refinedInfo.bounds.bindingKind)
+
     override def equals(that: Any) = that match {
       case that: RefinedType =>
         this.parent == that.parent &&

src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -272,7 +272,7 @@ class ClassfileParser(
               if (sig(index) == '<') {
                 accept('<')
                 var tp1: Type = tp
-                var formals = tp.typeParams
+                var formals = tp.typeParamSymbols
                 while (sig(index) != '>') {
                   sig(index) match {
                     case variance @ ('+' | '-' | '*') =>

src/dotty/tools/dotc/typer/Implicits.scala

@@ -322,7 +322,7 @@ trait ImplicitRunInfo { self: RunInfo =>
               }
               def addParentScope(parent: TypeRef): Unit = {
                 iscopeRefs(parent) foreach addRef
-                for (param <- parent.typeParams)
+                for (param <- parent.typeParamSymbols)
                   comps ++= iscopeRefs(pre.member(param.name).info)
               }
               val companion = cls.companionModule

src/dotty/tools/dotc/typer/Namer.scala

@@ -989,7 +989,7 @@ class Namer { typer: Typer =>
         if (args.nonEmpty) {
           val tycon = tp.withoutArgs(args)
           val tycon1 = this(tycon)
-          val tparams = tycon.typeParams
+          val tparams = tycon.typeParamSymbols
           val args1 = if (args.length == tparams.length) etaExpandIfHK(tparams, args) else args
           if ((tycon1 eq tycon) && (args1 eq args)) tp else tycon1.appliedTo(args1)
         } else mapOver(tp)

src/dotty/tools/dotc/typer/TypeAssigner.scala

@@ -409,7 +409,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(_.name == name) match {
+        val tparam = tparams.find(_.memberName == name) match {
           case Some(tparam) => tparam
           case none => ntparams.find(_.name == name).getOrElse(NoSymbol)
         }

src/dotty/tools/dotc/typer/Typer.scala

@@ -934,14 +934,14 @@ 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: Symbol) = {
+          def typedArg(arg: untpd.Tree, tparam: MemberInfo) = {
             val (desugaredArg, argPt) =
               if (ctx.mode is Mode.Pattern)
-                (if (isVarPattern(arg)) desugar.patternVar(arg) else arg, tparam.info)
+                (if (isVarPattern(arg)) desugar.patternVar(arg) else arg, tparam.memberInfo)
               else
                 (arg, WildcardType)
             val arg1 = typed(desugaredArg, argPt)
-            adaptTypeArg(arg1, tparam.info)
+            adaptTypeArg(arg1, tparam.memberInfo)
           }
           args.zipWithConserve(tparams)(typedArg(_, _)).asInstanceOf[List[Tree]]
         }