Merge pull request #2934 from dotty-staging/change-variances

Change variances in TypeMaps and Accumulators

Author: odersky

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

@@ -3713,8 +3713,19 @@ object Types {
       tp match {
         case tp: NamedType =>
           if (stopAtStatic && tp.symbol.isStatic) tp
-          else derivedSelect(tp, this(tp.prefix))
-
+          else {
+            val saved = variance
+            variance = variance max 0
+              // A prefix is never contravariant. Even if say `p.A` is used in a contravariant
+              // context, we cannot assume contravariance for `p` because `p`'s lower
+              // bound might not have a binding for `A` (e.g. the lower bound could be `Nothing`).
+              // By contrast, covariance does translate to the prefix, since we have that
+              // if `p <: q` then `p.A <: q.A`, and well-formedness requires that `A` is a member
+              // of `p`'s upper bound.
+            val prefix1 = this(tp.prefix)
+            variance = saved
+            derivedSelect(tp, prefix1)
+          }
         case _: ThisType
           | _: BoundType
           | NoPrefix => tp
@@ -3913,9 +3924,9 @@ object Types {
 
     protected var variance = 1
 
-    protected def applyToPrefix(x: T, tp: NamedType) = {
+    protected final def applyToPrefix(x: T, tp: NamedType) = {
       val saved = variance
-      variance = 0
+      variance = variance max 0 // see remark on NamedType case in TypeMap
       val result = this(x, tp.prefix)
       variance = saved
       result

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

@@ -319,8 +319,6 @@ object Inferencing {
         case _ =>
           foldOver(vmap, t)
       }
-      override def applyToPrefix(vmap: VarianceMap, t: NamedType) =
-        apply(vmap, t.prefix)
     }
 
     /** Include in `vmap` type variables occurring in the constraints of type variables

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

@@ -268,7 +268,20 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
             if (qualifies(defDenot)) {
               val found =
                 if (isSelfDenot(defDenot)) curOwner.enclosingClass.thisType
-                else curOwner.thisType.select(name, defDenot)
+                else {
+                  val effectiveOwner =
+                    if (curOwner.isTerm && defDenot.symbol.isType)
+                      // Don't mix NoPrefix and thisType prefixes, since type comparer
+                      // would not detect types to be compatible. Note: If we replace the
+                      // 2nd condition by `defDenot.symbol.maybeOwner.isType` we get lots
+                      // of failures in the `tastyBootstrap` test. Trying to compile these
+                      // files in isolation works though.
+                      // TODO: Investigate why that happens.
+                      defDenot.symbol.owner
+                    else
+                      curOwner
+                  effectiveOwner.thisType.select(name, defDenot)
+                }
               if (!(curOwner is Package) || isDefinedInCurrentUnit(defDenot))
                 result = checkNewOrShadowed(found, definition) // no need to go further out, we found highest prec entry
               else {