More targeted eta-lifting

Eta-lifting picked some arbitrary base type. It turned out that i94-nada failed once we add
a product trait to case classes (in the next commit) because Eta-Kifting picked Product
as the base type, even though the target type was bounded by Monad. We now change the scheme
so that the target type is included in the lifting, in order to avoid that we lift to
useless types.

Author: odersky

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

@@ -23,6 +23,7 @@ object Printers {
   val completions = noPrinter
   val gadts = noPrinter
   val hk = noPrinter
+  val variances = noPrinter
   val incremental = noPrinter
   val config = noPrinter
   val transforms = noPrinter

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

@@ -463,16 +463,18 @@ class TypeApplications(val self: Type) extends AnyVal {
     self.appliedTo(tparams map (_.typeRef)).LambdaAbstract(tparams)
   }
 
-  /** If this type has a base type `B[T1, ..., Tn]` where the type parameters
-   *  of `B` match one-by-one the variances of `tparams`, convert it to
+  /** Test whether this type has a base type `B[T1, ..., Tn]` where the type parameters
+   *  of `B` match one-by-one the variances of `tparams`, and where the lambda
+   *  abstracted type
    *
    *     LambdaXYZ { type Apply = B[$hkArg$0, ..., $hkArg$n] }
    *               { type $hkArg$0 = T1; ...; type $hkArg$n = Tn }
    *
+   *  satisfies predicate `p`. Try base types in the order of ther occurrence in `baseClasses`.
    *  A type parameter matches a varianve V if it has V as its variance or if V == 0.
    */
-  def EtaLiftTo(tparams: List[Symbol])(implicit ctx: Context): Type = {
-    def tryLift(bcs: List[ClassSymbol]): Type = bcs match {
+  def testLifted(tparams: List[Symbol], p: Type => Boolean)(implicit ctx: Context): Boolean = {
+    def tryLift(bcs: List[ClassSymbol]): Boolean = bcs match {
       case bc :: bcs1 =>
         val tp = self.baseTypeWithArgs(bc)
         val targs = tp.argInfos
@@ -481,19 +483,20 @@ class TypeApplications(val self: Type) extends AnyVal {
           param2.variance == param2.variance || param2.variance == 0
         if ((tycon.typeParams corresponds tparams)(variancesMatch)) {
           val expanded = tycon.EtaExpand
-          val res = (expanded /: targs) { (partialInst, targ) =>
+          val lifted = (expanded /: targs) { (partialInst, targ) =>
             val tparam = partialInst.typeParams.head
             RefinedType(partialInst, tparam.name, targ.bounds.withVariance(tparam.variance))
           }
-          hk.println(i"eta lifting $self --> $res")
-          res
+          ctx.traceIndented(i"eta lifting $self --> $lifted", hk) {
+            p(lifted) || tryLift(bcs1)
+          }
         }
         else tryLift(bcs1)
       case nil =>
-        NoType
+        false
     }
-    if (tparams.isEmpty) NoType
-    else if (typeParams.nonEmpty) EtaExpand
+    if (tparams.isEmpty) false
+    else if (typeParams.nonEmpty) p(EtaExpand)
     else tryLift(self.baseClasses)
   }
 }

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

@@ -454,7 +454,7 @@ class TypeComparer(initctx: Context) extends DotClass {
         def isHKSubType = tp2.name == tpnme.Apply && {
           val lambda2 = tp2.prefix.LambdaClass(forcing = true)
           lambda2.exists && !tp1.isLambda &&
-            isSubType(tp1.EtaLiftTo(lambda2.typeParams), tp2.prefix)
+            tp1.testLifted(lambda2.typeParams, isSubType(_, tp2.prefix))
         }
         def compareNamed = {
           implicit val ctx: Context = this.ctx // Dotty deviation: implicits need explicit type
@@ -673,7 +673,7 @@ class TypeComparer(initctx: Context) extends DotClass {
              || hasMatchingMember(name2)
              || fourthTry(tp1, tp2)
              )
-          || needsEtaLift(tp1, tp2) && isSubType(tp1.EtaLiftTo(tp2.typeParams), tp2)
+          || needsEtaLift(tp1, tp2) && tp1.testLifted(tp2.typeParams, isSubType(_, tp2))
           )
       }
       compareRefined
@@ -768,7 +768,7 @@ class TypeComparer(initctx: Context) extends DotClass {
           isNewSubType(tp1.parent, tp2)
         }
         finally pendingRefinedBases = saved
-      } || needsEtaLift(tp2, tp1) && isSubType(tp1, tp2.EtaLiftTo(tp1.typeParams))
+      } || needsEtaLift(tp2, tp1) && tp2.testLifted(tp1.typeParams, isSubType(tp1, _))
     case AndType(tp11, tp12) =>
       isNewSubType(tp11, tp2) || isNewSubType(tp12, tp2)
     case _ =>

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

@@ -6,6 +6,7 @@ import core._
 import Types._, Contexts._, Flags._, Symbols._, Annotations._, Trees._, NameOps._
 import Decorators._
 import Variances._
+import config.Printers.variances
 
 /** Provides `check` method to check that all top-level definitions
  *  in tree are variance correct. Does not recurse inside methods.
@@ -77,7 +78,7 @@ class VarianceChecker()(implicit ctx: Context) {
      *  explicitly (their TypeDefs will be passed here.) For MethodTypes, the
      *  same is true of the parameters (ValDefs).
      */
-    def apply(status: Option[VarianceError], tp: Type): Option[VarianceError] = ctx.traceIndented(s"variance checking $tp of $base at $variance") {
+    def apply(status: Option[VarianceError], tp: Type): Option[VarianceError] = ctx.traceIndented(s"variance checking $tp of $base at $variance", variances) {
       if (status.isDefined) status
       else tp match {
         case tp: TypeRef =>