Make applications inside ranges respect variance

A Range, if it survives, will always lead to a situation
where the upper bound appears in a covariant position
in the result, and the lower bound appears in a contravariant
position. Hence, when we apply a type map to the
argument in a range we should take this into account.
Fixes a previous failure in t2435.scala and dependent-extractors.scala.

Author: odersky

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

@@ -132,9 +132,11 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
 
   /** Approximate a type `tp` with a type that does not contain skolem types. */
   object deskolemize extends ApproximatingTypeMap {
-    def apply(tp: Type) = tp match {
-      case tp: SkolemType => range(hi = apply(tp.info))
-      case _ => mapOver(tp)
+    def apply(tp: Type) = /*ctx.traceIndented(i"deskolemize($tp) at $variance", show = true)*/ {
+      tp match {
+        case tp: SkolemType => range(hi = atVariance(1)(apply(tp.info)))
+        case _ => mapOver(tp)
+      }
     }
   }
 

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

@@ -3888,6 +3888,9 @@ object Types {
   case class Range(lo: Type, hi: Type) extends UncachedGroundType {
     assert(!lo.isInstanceOf[Range])
     assert(!hi.isInstanceOf[Range])
+
+    override def toText(printer: Printer): Text =
+      lo.toText(printer) ~ ".." ~ hi.toText(printer)
   }
 
   /** A type map that approximates TypeBounds types depending on
@@ -3922,14 +3925,23 @@ object Types {
       case _ => tp
     }
 
+    def atVariance[T](v: Int)(op: => T): T = {
+      val saved = variance
+      variance = v
+      try op finally variance = saved
+    }
+
     override protected def derivedSelect(tp: NamedType, pre: Type) =
       if (pre eq tp.prefix) tp
       else pre match {
         case Range(preLo, preHi) =>
           tp.info match {
-            case TypeAlias(alias) => apply(alias)
-            case TypeBounds(lo, hi) => range(apply(lo), apply(hi))
-            case _ => range(tp.derivedSelect(preLo), tp.derivedSelect(preHi))
+            case TypeAlias(alias) =>
+              apply(alias)
+            case TypeBounds(lo, hi) =>
+              range(atVariance(-1)(apply(lo)), atVariance(1)(apply(hi)))
+            case _ =>
+              range(tp.derivedSelect(preLo), tp.derivedSelect(preHi))
           }
         case _ => tp.derivedSelect(pre)
       }
@@ -3947,23 +3959,27 @@ object Types {
               tp.derivedRefinedType(parent, tp.refinedName, rangeToBounds(info))
           }
       }
+
     override protected def derivedRecType(tp: RecType, parent: Type) =
       parent match {
         case Range(lo, hi) => range(tp.rebind(lo), tp.rebind(hi))
         case _ => tp.rebind(parent)
       }
+
     override protected def derivedTypeAlias(tp: TypeAlias, alias: Type) =
       alias match {
         case Range(lo, hi) =>
           if (variance > 0) TypeBounds(lo, hi)
           else range(TypeAlias(lo), TypeAlias(hi))
         case _ => tp.derivedTypeAlias(alias)
       }
+
     override protected def derivedTypeBounds(tp: TypeBounds, lo: Type, hi: Type) =
       if (isRange(lo) || isRange(hi))
         if (variance > 0) TypeBounds(loBound(lo), hiBound(hi))
         else range(TypeBounds(hiBound(lo), loBound(hi)), TypeBounds(loBound(lo), hiBound(hi)))
       else tp.derivedTypeBounds(lo, hi)
+
     override protected def derivedSuperType(tp: SuperType, thistp: Type, supertp: Type) =
       if (isRange(thistp) || isRange(supertp)) range()
       else tp.derivedSuperType(thistp, supertp)
@@ -4003,6 +4019,7 @@ object Types {
         if (tp.isAnd) range(loBound(tp1) & loBound(tp2), hiBound(tp1) & hiBound(tp2))
         else range(loBound(tp1) | loBound(tp2), hiBound(tp1) | hiBound(tp2))
       else tp.derivedAndOrType(tp1, tp2)
+
     override protected def derivedAnnotatedType(tp: AnnotatedType, underlying: Type, annot: Annotation) =
       underlying match {
         case Range(lo, hi) =>
@@ -4014,6 +4031,7 @@ object Types {
     override protected def derivedWildcardType(tp: WildcardType, bounds: Type) = {
       tp.derivedWildcardType(rangeToBounds(bounds))
     }
+
     override protected def derivedClassInfo(tp: ClassInfo, pre: Type): Type = {
       assert(!pre.isInstanceOf[Range])
       tp.derivedClassInfo(pre)

tests/pos/dependent-extractors.scala

@@ -10,5 +10,5 @@ object Test {
   val y1: Int = y
 
   val z = (c: Any)  match { case X(y) => y }
-  // val z1: C#T = z  // error: z has type Any TODO: find out why
+  val z1: C#T = z  // error: z has type Any TODO: find out why
 }

tests/pos/t2435.scala

@@ -23,5 +23,6 @@ object Test {
   val a2 = a1.chain("a")
 
   println("\nDoesn't compile:")
-  val a = FNil.chain("a").chain("a").chain("a")
+  val a3 = FNil.chain("a").chain("a").chain("a")
+  val a4: FConstant[_ <: FConstant[_ <: FConstant[FNil.type]]] = a3
 }