Change definition of isLegalPrefix so that it allows projecting on an abstract type.

This is needed to make the encoding og higher-kinded types work. E.g.

    Rep[Int]

would be represented as

    Rep { type Arg$0 = Int } # Apply

where Apply is an abstract member of the base class Lambfa$I of Rep.

Author: odersky

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

@@ -117,14 +117,15 @@ object Types {
     }
 
    /** A type T is a legal prefix in a type selection T#A if
-     *  T is stable or T contains no abstract types
+     *  T is stable or T contains no abstract types except possibly A.
      *  !!! Todo: What about non-final vals that contain abstract types?
      */
-    final def isLegalPrefix(implicit ctx: Context): Boolean =
+    final def isLegalPrefixFor(selector: Name)(implicit ctx: Context): Boolean =
       isStable || {
         val absTypeNames = memberNames(abstractTypeNameFilter)
         if (absTypeNames.nonEmpty) typr.println(s"abstract type members of ${this.showWithUnderlying()}: $absTypeNames")
-        absTypeNames.isEmpty
+        absTypeNames.isEmpty ||
+          absTypeNames.head == selector && absTypeNames.tail.isEmpty
       }
 
     /** Is this type guaranteed not to have `null` as a value?

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

@@ -51,8 +51,8 @@ trait Checking {
   /** Check that type `tp` is a legal prefix for '#'.
    *  @return The type itself
    */
-  def checkLegalPrefix(tp: Type, pos: Position)(implicit ctx: Context): Unit =
-    if (!tp.isLegalPrefix) ctx.error(d"$tp is not a valid prefix for '#'", pos)
+  def checkLegalPrefix(tp: Type, selector: Name, pos: Position)(implicit ctx: Context): Unit =
+    if (!tp.isLegalPrefixFor(selector)) ctx.error(d"$tp is not a valid prefix for '# $selector'", pos)
 
  /** Check that `tp` is a class type with a stable prefix. Also, if `isFirst` is
    *  false check that `tp` is a trait.
@@ -139,7 +139,7 @@ trait NoChecking extends Checking {
   override def checkValue(tree: Tree, proto: Type)(implicit ctx: Context): tree.type = tree
   override def checkBounds(args: List[tpd.Tree], poly: PolyType, pos: Position)(implicit ctx: Context): Unit = ()
   override def checkStable(tp: Type, pos: Position)(implicit ctx: Context): Unit = ()
-  override def checkLegalPrefix(tp: Type, pos: Position)(implicit ctx: Context): Unit = ()
+  override def checkLegalPrefix(tp: Type, selector: Name, pos: Position)(implicit ctx: Context): Unit = ()
   override def checkClassTypeWithStablePrefix(tp: Type, pos: Position, traitReq: Boolean)(implicit ctx: Context): Type = tp
   override def checkImplicitParamsNotSingletons(vparamss: List[List[ValDef]])(implicit ctx: Context): Unit = ()
   override def checkFeasible(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type = tp

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

@@ -277,7 +277,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   def typedSelectFromTypeTree(tree: untpd.SelectFromTypeTree, pt: Type)(implicit ctx: Context): SelectFromTypeTree = track("typedSelectFromTypeTree") {
     val qual1 = typedType(tree.qualifier, selectionProto(tree.name, pt, this))
-    checkLegalPrefix(qual1.tpe, qual1.pos)
+    checkLegalPrefix(qual1.tpe, tree.name, qual1.pos)
     assignType(cpy.SelectFromTypeTree(tree, qual1, tree.name), qual1)
   }
 

test/dotc/tests.scala

@@ -67,6 +67,7 @@ class tests extends CompilerTest {
   @Test def neg_autoTupling = compileFile(posDir, "autoTuplingTest", "-language:noAutoTupling" :: Nil, xerrors = 4)
   @Test def neg_autoTupling2 = compileFile(negDir, "autoTuplingTest", xerrors = 4)
   @Test def neg_companions = compileFile(negDir, "companions", xerrors = 1)
+  @Test def neg_projections = compileFile(negDir, "projections", xerrors = 1)
   @Test def neg_i39 = compileFile(negDir, "i39", xerrors = 1)
   @Test def neg_i50_volatile = compileFile(negDir, "i50-volatile", xerrors = 4)
   @Test def neg_t0273_doubledefs = compileFile(negDir, "t0273", xerrors = 1)

tests/neg/projections.scala

@@ -0,0 +1,7 @@
+class projections {
+
+  class Lambda { type Arg; type Apply }
+
+  var x: (Lambda { type Apply = Int }) # Apply = _ // error: illegal prefix
+
+}

tests/pos/projections.scala

@@ -0,0 +1,14 @@
+class projections {
+
+  class Lambda { type Arg; type Apply }
+
+  var x: (Lambda { type Apply = Int; type Arg = String }) # Apply = _
+  var y: Int = _
+  x = y
+  y = x
+
+  var xx: (Lambda { type Apply = Arg } { type Arg = Int }) # Apply = _
+  xx = y
+  y = xx
+
+}