Address review comments

Author: odersky

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

@@ -1208,7 +1208,7 @@ object SymDenotations {
       case tp: LambdaType => tp.paramInfos.exists(hasSkolems) || hasSkolems(tp.resType)
       case tp: AndType => hasSkolems(tp.tp1) || hasSkolems(tp.tp2)
       case tp: OrType  => hasSkolems(tp.tp1) || hasSkolems(tp.tp2)
-      case tp: AnnotatedType => hasSkolems(tp.tpe)
+      case tp: AnnotatedType => hasSkolems(tp.parent)
       case _ => false
     }
 

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

@@ -237,7 +237,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
       case tp2: LazyRef =>
         !tp2.evaluating && recur(tp1, tp2.ref)
       case tp2: AnnotatedType if !tp2.isRefining =>
-        recur(tp1, tp2.tpe)
+        recur(tp1, tp2.parent)
       case tp2: ThisType =>
         def compareThis = {
           val cls2 = tp2.cls
@@ -346,7 +346,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         // See i859.scala for an example where we hit this case.
         !tp1.evaluating && recur(tp1.ref, tp2)
       case tp1: AnnotatedType if !tp1.isRefining =>
-        recur(tp1.tpe, tp2)
+        recur(tp1.parent, tp2)
       case AndType(tp11, tp12) =>
         if (tp11.stripTypeVar eq tp12.stripTypeVar) recur(tp11, tp2)
         else thirdTry
@@ -569,7 +569,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         compareTypeBounds
       case tp2: AnnotatedType if tp2.isRefining =>
         (tp1.derivesAnnotWith(tp2.annot.sameAnnotation) || defn.isBottomType(tp1)) &&
-        recur(tp1, tp2.tpe)
+        recur(tp1, tp2.parent)
       case ClassInfo(pre2, cls2, _, _, _) =>
         def compareClassInfo = tp1 match {
           case ClassInfo(pre1, cls1, _, _, _) =>
@@ -665,7 +665,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
         }
         either(recur(tp11, tp2), recur(tp12, tp2))
       case tp1: AnnotatedType if tp1.isRefining =>
-        isNewSubType(tp1.tpe)
+        isNewSubType(tp1.parent)
       case JavaArrayType(elem1) =>
         def compareJavaArray = tp2 match {
           case JavaArrayType(elem2) => isSubType(elem1, elem2)
@@ -705,7 +705,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
               }
             case tycon1: TypeVar =>
               isMatchingApply(tycon1.underlying)
-            case tycon1: AnnotatedType if !tycon1.isRefining =>
+            case tycon1: AnnotatedType =>
               isMatchingApply(tycon1.underlying)
             case _ =>
               false

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

@@ -152,7 +152,7 @@ object Types {
       case _: SingletonType | NoPrefix => true
       case tp: RefinedOrRecType => tp.parent.isStable
       case tp: ExprType => tp.resultType.isStable
-      case tp: AnnotatedType => tp.tpe.isStable
+      case tp: AnnotatedType => tp.parent.isStable
       case _ => false
     }
 
@@ -285,7 +285,7 @@ object Types {
 
     /** Does this type have a supertype with an annotation satisfying given predicate `p`? */
     def derivesAnnotWith(p: Annotation => Boolean)(implicit ctx: Context): Boolean = this match {
-      case tp: AnnotatedType => p(tp.annot) || tp.tpe.derivesAnnotWith(p)
+      case tp: AnnotatedType => p(tp.annot) || tp.parent.derivesAnnotWith(p)
       case tp: TypeProxy => tp.superType.derivesAnnotWith(p)
       case AndType(l, r) => l.derivesAnnotWith(p) || r.derivesAnnotWith(p)
       case OrType(l, r) => l.derivesAnnotWith(p) && r.derivesAnnotWith(p)
@@ -1037,7 +1037,7 @@ object Types {
         val tp1 = tp.instanceOpt
         if (tp1.exists) tp1.dealias1(keep): @tailrec else tp
       case tp: AnnotatedType =>
-        val tp1 = tp.tpe.dealias1(keep)
+        val tp1 = tp.parent.dealias1(keep)
         if (keep(tp)(ctx)) tp.derivedAnnotatedType(tp1, tp.annot) else tp1
       case tp: LazyRef =>
         tp.ref.dealias1(keep): @tailrec
@@ -3702,19 +3702,19 @@ object Types {
   // ----- Annotated and Import types -----------------------------------------------
 
   /** An annotated type tpe @ annot */
-  case class AnnotatedType(tpe: Type, annot: Annotation) extends UncachedProxyType with ValueType {
+  case class AnnotatedType(parent: Type, annot: Annotation) extends UncachedProxyType with ValueType {
     // todo: cache them? but this makes only sense if annotations and trees are also cached.
 
-    override def underlying(implicit ctx: Context): Type = tpe
+    override def underlying(implicit ctx: Context): Type = parent
 
     def derivedAnnotatedType(tpe: Type, annot: Annotation) =
-      if ((tpe eq this.tpe) && (annot eq this.annot)) this
+      if ((parent eq this.parent) && (annot eq this.annot)) this
       else AnnotatedType(tpe, annot)
 
     override def stripTypeVar(implicit ctx: Context): Type =
-      derivedAnnotatedType(tpe.stripTypeVar, annot)
+      derivedAnnotatedType(parent.stripTypeVar, annot)
 
-    override def stripAnnots(implicit ctx: Context): Type = tpe.stripAnnots
+    override def stripAnnots(implicit ctx: Context): Type = parent.stripAnnots
 
     private[this] var isRefiningKnown = false
     private[this] var isRefiningCache: Boolean = _
@@ -3728,7 +3728,7 @@ object Types {
     }
 
     override def iso(that: Any, bs: BinderPairs): Boolean = that match {
-      case that: AnnotatedType => tpe.equals(that.tpe, bs) && (annot `eq` that.annot)
+      case that: AnnotatedType => parent.equals(that.parent, bs) && (annot `eq` that.annot)
       case _ => false
     }
     // equals comes from case class; no matching override is needed

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -236,7 +236,7 @@ class TreePickler(pickler: TastyPickler) {
       withLength { pickleType(tpe.lo, richTypes); pickleType(tpe.hi, richTypes) }
     case tpe: AnnotatedType =>
       writeByte(ANNOTATEDtype)
-      withLength { pickleType(tpe.tpe, richTypes); pickleTree(tpe.annot.tree) }
+      withLength { pickleType(tpe.parent, richTypes); pickleTree(tpe.annot.tree) }
     case tpe: AndType =>
       writeByte(ANDtype)
       withLength { pickleType(tpe.tp1, richTypes); pickleType(tpe.tp2, richTypes) }

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

@@ -302,7 +302,7 @@ class TreeChecker extends Phase with SymTransformer {
 
     /** Check that all methods have MethodicType */
     def isMethodType(pt: Type)(implicit ctx: Context): Boolean = pt match {
-      case at: AnnotatedType => isMethodType(at.tpe)
+      case at: AnnotatedType => isMethodType(at.parent)
       case _: MethodicType => true  // MethodType, ExprType, PolyType
       case _ => false
     }

doc-tool/src/dotty/tools/dottydoc/model/factories.scala

@@ -183,7 +183,7 @@ object factories {
       paramLists(mp.underlying)
 
     case annot: AnnotatedType =>
-      paramLists(annot.tpe)
+      paramLists(annot.parent)
 
     case _ =>
       Nil // return types should not be in the paramlist