Revise liftToClasses to make CB work

The difference is that in an alias type `p.A = q.B`
we take `p` instead of `q` as the prefix to search.

Author: odersky

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

@@ -440,24 +440,29 @@ object Types {
         NoSymbol
     }
 
-    /** The least (wrt <:<) set of class symbols of which this type is a subtype
+    /** The least (wrt <:<) set of symbols satisfying the `include` prediacte of which this type is a subtype
      */
-    final def classSymbols(implicit ctx: Context): List[ClassSymbol] = this match {
+    final def parentSymbols(include: Symbol => Boolean)(implicit ctx: Context): List[Symbol] = this match {
       case tp: ClassInfo =>
         tp.cls :: Nil
       case tp: TypeRef =>
         val sym = tp.symbol
-        if (sym.isClass) sym.asClass :: Nil else tp.superType.classSymbols
+        if (include(sym)) sym :: Nil else tp.superType.parentSymbols(include)
       case tp: TypeProxy =>
-        tp.underlying.classSymbols
+        tp.underlying.parentSymbols(include)
       case AndType(l, r) =>
-        l.classSymbols | r.classSymbols
+        l.parentSymbols(include) | r.parentSymbols(include)
       case OrType(l, r) =>
-        l.classSymbols intersect r.classSymbols // TODO does not conform to spec
+        l.parentSymbols(include) intersect r.parentSymbols(include) // TODO does not conform to spec
       case _ =>
         Nil
     }
 
+    /** The least (wrt <:<) set of class symbols of which this type is a subtype
+     */
+    final def classSymbols(implicit ctx: Context): List[ClassSymbol] =
+      parentSymbols(_.isClass).asInstanceOf
+
     /** The term symbol associated with the type */
     @tailrec final def termSymbol(implicit ctx: Context): Symbol = this match {
       case tp: TermRef => tp.symbol

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

@@ -492,7 +492,19 @@ trait ImplicitRunInfo { self: Run =>
     object liftToClasses extends TypeMap {
       override implicit protected val ctx: Context = liftingCtx
       override def stopAtStatic = true
+
       def apply(tp: Type) = tp match {
+        case tp: TypeRef =>
+          val sym = tp.symbol
+          if (sym.isClass || sym.isOpaqueAlias) tp
+          else {
+            val pre = tp.prefix
+            def joinClass(tp: Type, cls: Symbol) =
+              AndType.make(tp, cls.typeRef.asSeenFrom(pre, cls.owner))
+            val lead = if (pre eq NoPrefix) defn.AnyType else apply(pre)
+            def isLiftTarget(sym: Symbol) = sym.isClass || sym.isOpaqueAlias
+            (lead /: tp.parentSymbols(isLiftTarget))(joinClass)
+          }
         case tp: NamedType =>
           tp.info match {
             case TypeAlias(alias) =>