Address reviewers comments

Author: odersky

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

@@ -29,10 +29,9 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
 
     def apply(tp: Type): Type = {
 
-      /** Map a `C.this` type to the right prefix. If the prefix is unstable and
-      *  the `C.this` occurs in nonvariant or contravariant position, mark the map
-      *  to be unstable.
-      */
+      /** Map a `C.this` type to the right prefix. If the prefix is unstable, and
+       *  the current variance is <= 0, return a range.
+       */
       def toPrefix(pre: Type, cls: Symbol, thiscls: ClassSymbol): Type = /*>|>*/ ctx.conditionalTraceIndented(TypeOps.track, s"toPrefix($pre, $cls, $thiscls)") /*<|<*/ {
         if ((pre eq NoType) || (pre eq NoPrefix) || (cls is PackageClass))
           tp
@@ -50,16 +49,11 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       }
 
       /*>|>*/ ctx.conditionalTraceIndented(TypeOps.track, s"asSeen ${tp.show} from (${pre.show}, ${cls.show})", show = true) /*<|<*/ { // !!! DEBUG
+        // One `case ThisType` is specific to asSeenFrom, all other cases are inlined for performance
         tp match {
-          case tp: NamedType => // inlined for performance; TODO: factor out into inline method
+          case tp: NamedType =>
             if (tp.symbol.isStatic) tp
-            else {
-              val saved = variance
-              variance = variance max 0
-              val prefix1 = this(tp.prefix)
-              variance = saved
-              derivedSelect(tp, prefix1)
-            }
+            else derivedSelect(tp, atVariance(variance max 0)(this(tp.prefix)))
           case tp: ThisType =>
             toPrefix(pre, cls, tp.cls)
           case _: BoundType | NoPrefix =>

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

@@ -3946,6 +3946,9 @@ object Types {
               else if (v1 < 0 && v2 < 0) propagate(infoHi, infoLo)
               else if (!infoLo.isAlias && !infoHi.isAlias) propagate(infoLo, infoHi)
               else range(tp.bottomType, tp.topType)
+                // Using `parent` instead of `tp.topType` would be better for normal refinements,
+                // but it would also turn *-types to a hk-types, which is not what we want.
+                // We should revisit this point in case we represent applied types not as refinements anymore.
             case Range(infoLo, infoHi) =>
               propagate(infoLo, infoHi)
             case _ =>
@@ -4015,6 +4018,7 @@ object Types {
                 range(tp.derivedAppliedType(tycon, loBuf.toList),
                       tp.derivedAppliedType(tycon, hiBuf.toList))
               else range(tp.bottomType, tp.topType)
+                // TODO: can we give a better bound than `topType`?
             }
           }
           else tp.derivedAppliedType(tycon, args)

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

@@ -46,7 +46,7 @@ trait TypeAssigner {
     val parentType = info.parentsWithArgs.reduceLeft(ctx.typeComparer.andType(_, _))
     def addRefinement(parent: Type, decl: Symbol) = {
       val inherited =
-        parentType.findMember(decl.name, info.cls.thisType, Private)
+        parentType.findMember(decl.name, info.cls.thisType, excluded = Private)
           .suchThat(decl.matches(_))
       val inheritedInfo = inherited.info
       if (inheritedInfo.exists && decl.info <:< inheritedInfo && !(inheritedInfo <:< decl.info)) {
@@ -88,7 +88,7 @@ trait TypeAssigner {
             case info => range(tp.info.bottomType, apply(info))
           }
         case tp: TypeRef if toAvoid(tp.symbol) =>
-          val avoided = tp.info match {
+          tp.info match {
             case TypeAlias(alias) =>
               apply(alias)
             case TypeBounds(lo, hi) =>
@@ -98,7 +98,6 @@ trait TypeAssigner {
             case _ =>
               range(tp.bottomType, tp.topType) // should happen only in error cases
           }
-          avoided
         case tp: ThisType if toAvoid(tp.cls) =>
           range(tp.bottomType, apply(classBound(tp.cls.classInfo)))
         case tp: TypeVar if ctx.typerState.constraint.contains(tp) =>