Address other reviewer comments

Author: odersky

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

@@ -61,7 +61,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
             toPrefix(pre, cls, tp.cls)
           case _: BoundType | NoPrefix =>
             tp
-          case tp: RefinedType =>  //@!!!
+          case tp: RefinedType =>  //@!!! todo: remove
             derivedRefinedType(tp, apply(tp.parent), apply(tp.refinedInfo))
           case _ =>
             mapOver(tp)

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

@@ -4025,11 +4025,7 @@ object Types {
             case Range(infoLo: TypeBounds, infoHi: TypeBounds) =>
               assert(variance == 0)
               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 into hk-types, which is not what we want.
-                // We should revisit this point in case we represent applied types not as refinements anymore.
-                // @!!! revisit
+              else range(tp.bottomType, tp.parent)
             case Range(infoLo, infoHi) =>
               propagate(infoLo, infoHi)
             case _ =>
@@ -4112,7 +4108,7 @@ object Types {
       else tp.derivedAndOrType(tp1, tp2)
 
     override protected def derivedTypeArgRef(tp: TypeArgRef, prefix: Type): Type =
-      if (isRange(prefix))
+      if (isRange(prefix)) // TODO: explain
         tp.underlying match {
           case TypeBounds(lo, hi) => range(atVariance(-variance)(reapply(lo)), reapply(hi))
           case _ => range(tp.bottomType, tp.topType)
@@ -4245,10 +4241,7 @@ object Types {
         this(x, tp.info)
 
       case tp @ TypeArgRef(prefix, _, _) =>
-        val saved = variance
-        variance = 0
-        try this(x, prefix)
-        finally variance = saved
+        atVariance(0)(this(x, prefix))
 
       case AnnotatedType(underlying, annot) =>
         this(applyToAnnot(x, annot), underlying)

compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -162,10 +162,10 @@ object ExplicitOuter {
    *  @param  flags  The flags of the outer accessor
    *
    * The type of the outer accessor is computed as follows:
-   * Let O[X1, .., Xn] be the class eclosing `cls`.
+   * Let O[X1, .., Xn] be the class enclosing `cls`.
    *  - if owner == cls, O[X1, ..., Xn]
    *  - otherwise, if the class P enclosing `owner` derives from O, the
-   *    base type of P.this of class O
+   *    base type of P.this wrt class O
    *  - otherwise O[_, ..., _]
    */
   private def newOuterSym(owner: ClassSymbol, cls: ClassSymbol, name: TermName, flags: FlagSet)(implicit ctx: Context) = {

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

@@ -158,7 +158,7 @@ object ErrorReporting {
       reported.setVariance(-1)
       val expected1 = reported(expected)
       val (found2, expected2) =
-        if (found1 <:< expected1) (found, expected) else (found1, expected1)
+        if (found1 frozen_<:< expected1) (found, expected) else (found1, expected1)
       TypeMismatch(found2, expected2, whyNoMatchStr(found, expected), postScript)
     }