Rename MemberInfo -> MemberBinding

Also change MemberInfo.exists to MemberBinding.isTypeParam.

Author: odersky

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

@@ -4,18 +4,31 @@ 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
-
+/** 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 memberInfo(implicit ctx: Context): Type
 
+  /** 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 memberInfoAsSeenFrom(pre: Type)(implicit ctx: Context): Type
 
+  /** The variance of the type parameter
+   *  @pre: isTypeParam = true
+   */
   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 MemberInfo with printing.Showable {
+  class Symbol private[Symbols] (val coord: Coord, val id: Int) extends DotClass with MemberBinding with printing.Showable {
 
     type ThisName <: Name
 
@@ -489,8 +489,8 @@ object Symbols {
      */
     def pos: Position = if (coord.isPosition) coord.toPosition else NoPosition
 
-    // MemberInfo methods
-    def exists(implicit ctx: Context) = denot.exists
+    // MemberBinding methods
+    def isTypeParam(implicit ctx: Context) = denot.is(TypeParam)
     def memberName(implicit ctx: Context): Name = name
     def memberInfo(implicit ctx: Context) = denot.info
     def memberInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = pre.memberInfo(this)

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: MemberInfo, sym2: MemberInfo)(implicit ctx: Context) =
+  def varianceConforms(sym1: MemberBinding, sym2: MemberBinding)(implicit ctx: Context) =
     sym1.memberVariance == sym2.memberVariance || sym2.memberVariance == 0
 
-  def variancesConform(syms1: List[MemberInfo], syms2: List[MemberInfo])(implicit ctx: Context) =
+  def variancesConform(syms1: List[MemberBinding], syms2: List[MemberBinding])(implicit ctx: Context) =
     syms1.corresponds(syms2)(varianceConforms)
 
   /** Extractor for
@@ -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[MemberInfo] = /*>|>*/ track("typeParams") /*<|<*/ {
+  final def typeParams(implicit ctx: Context): List[MemberBinding] = /*>|>*/ track("typeParams") /*<|<*/ {
     self match {
       case self: ClassInfo =>
         self.cls.typeParams
@@ -627,8 +627,8 @@ 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[MemberInfo])(implicit ctx: Context): Type = {
-    def matchParams(t: Type, tparams: List[MemberInfo], args: List[Type])(implicit ctx: Context): Type = args match {
+  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 {
       case arg :: args1 =>
         try {
           val tparam :: tparams1 = tparams
@@ -673,7 +673,7 @@ 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: MemberInfo)(implicit ctx: Context): TypeBounds = self match {
+  final def toBounds(tparam: MemberBinding)(implicit ctx: Context): TypeBounds = self match {
     case self: TypeBounds => // this can happen for wildcard args
       self
     case _ =>

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[MemberInfo], p: Type => Boolean): Boolean = {
+  private def testLifted(tp1: Type, tp2: Type, tparams: List[MemberBinding], p: Type => Boolean): Boolean = {
     val classBounds = tp2.member(tpnme.hkApply).info.classSymbols
     def recur(bcs: List[ClassSymbol]): Boolean = bcs match {
       case bc :: bcs1 =>
@@ -726,24 +726,31 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     val rebindNeeded = tp2.refinementRefersToThis
     val base = if (rebindNeeded) ensureStableSingleton(tp1) else tp1
     val rinfo2 = if (rebindNeeded) tp2.refinedInfo.substRefinedThis(tp2, base) else tp2.refinedInfo
+    val mbr = base.member(name)
+
     def qualifies(m: SingleDenotation) = isSubType(m.info, rinfo2)
-    def memberMatches(mbr: Denotation): Boolean = mbr match { // inlined hasAltWith for performance
+
+    def memberMatches: Boolean = mbr match { // inlined hasAltWith for performance
       case mbr: SingleDenotation => qualifies(mbr)
       case _ => mbr hasAltWith qualifies
     }
-    /*>|>*/ ctx.traceIndented(i"hasMatchingMember($base . $name :? ${tp2.refinedInfo}) ${base.member(name).info.show} $rinfo2", subtyping) /*<|<*/ {
-      memberMatches(base member name) ||
-        tp1.isInstanceOf[SingletonType] &&
-        { // special case for situations like:
-          //    class C { type T }
-          //    val foo: C
-          //    foo.type <: C { type T = foo.T }
-          rinfo2 match {
-            case rinfo2: TypeAlias =>
-              !defn.isBottomType(base.widen) && (base select name) =:= rinfo2.alias
-            case _ => false
-          }
-        }
+
+    // special case for situations like:
+    //    class C { type T }
+    //    val foo: C
+    //    foo.type <: C { type T = foo.T }
+    def selfReferentialMatch = tp1.isInstanceOf[SingletonType] && {
+      rinfo2 match {
+        case rinfo2: TypeAlias =>
+          !defn.isBottomType(base.widen) && (base select name) =:= rinfo2.alias
+        case _ => false
+      }
+    }
+
+    def varianceMatches = true // TODO: fill in
+
+    /*>|>*/ ctx.traceIndented(i"hasMatchingMember($base . $name :? ${tp2.refinedInfo}) ${mbr.info.show} $rinfo2", subtyping) /*<|<*/ {
+      (memberMatches || selfReferentialMatch) && varianceMatches
     }
   }
 

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

@@ -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 with MemberInfo {
+    extends RefinedOrRecType with BindingType with MemberBinding {
 
     final def parent = myParent
     final def refinedInfo = myRefinedInfo
@@ -2082,8 +2082,11 @@ object Types {
       if (parent.member(refinedName).exists) derivedRefinedType(parent, refinedName, refinedInfo)
       else parent
 
-    // MemberInfo methods
-    def exists(implicit ctx: Context) = true
+    // MemberBinding methods
+    def isTypeParam(implicit ctx: Context) = refinedInfo match {
+      case tp: TypeBounds => tp.isBinding
+      case _ => false
+    }
     def memberName(implicit ctx: Context) = refinedName
     def memberInfo(implicit ctx: Context) = refinedInfo
     def memberInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = refinedInfo

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

@@ -413,7 +413,7 @@ trait TypeAssigner {
           case Some(tparam) => tparam
           case none => ntparams.find(_.name == name).getOrElse(NoSymbol)
         }
-        if (tparam.exists) RefinedType(tycon, name, argtpt.tpe.toBounds(tparam))
+        if (tparam.isTypeParam) RefinedType(tycon, name, argtpt.tpe.toBounds(tparam))
         else errorType(i"$tycon does not have a parameter or abstract type member named $name", arg.pos)
       case _ =>
         errorType(s"named and positional type arguments may not be mixed", arg.pos)

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

@@ -934,7 +934,7 @@ 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: MemberInfo) = {
+          def typedArg(arg: untpd.Tree, tparam: MemberBinding) = {
             val (desugaredArg, argPt) =
               if (ctx.mode is Mode.Pattern)
                 (if (isVarPattern(arg)) desugar.patternVar(arg) else arg, tparam.memberInfo)