Handle AnnotatedTypes transparently like their underlying type

In Erasure, all type annotations are dropped (AnnotatedTypes are
replaced with their underlying).

Author: olhotak

src/dotty/tools/dotc/TypeErasure.scala

@@ -38,7 +38,7 @@ object TypeErasure {
     case JavaArrayType(elem) =>
       isErasedType(elem)
     case AnnotatedType(_, tp) =>
-      isErasedType(tp)
+      false
     case ThisType(tref) =>
       isErasedType(tref)
     case tp: MethodType =>
@@ -105,7 +105,7 @@ object TypeErasure {
   /** The erasure of a top-level reference. Differs from normal erasure in that
    *  TermRefs are kept instead of being widened away.
    */
-  def erasedRef(tp: Type)(implicit ctx: Context): Type = tp match {
+  def erasedRef(tp: Type)(implicit ctx: Context): Type = tp.stripAnnots match {
     case tp: TermRef =>
       assert(tp.symbol.exists, tp)
       val tp1 = ctx.makePackageObjPrefixExplicit(tp)
@@ -160,7 +160,7 @@ object TypeErasure {
    *  as upper bound and that is not Java defined? Arrays of such types are
    *  erased to `Object` instead of `ObjectArray`.
    */
-  def isUnboundedGeneric(tp: Type)(implicit ctx: Context): Boolean = tp.dealias match {
+  def isUnboundedGeneric(tp: Type)(implicit ctx: Context): Boolean = tp.dealias.stripAnnots match {
     case tp: TypeRef =>
       !tp.symbol.isClass &&
       !tp.derivesFrom(defn.ObjectClass) &&
@@ -186,14 +186,14 @@ object TypeErasure {
    *                    come after S.
    *  (the reason to pick last is that we prefer classes over traits that way).
    */
-  def erasedLub(tp1: Type, tp2: Type)(implicit ctx: Context): Type = tp1 match {
+  def erasedLub(tp1: Type, tp2: Type)(implicit ctx: Context): Type = tp1.stripAnnots match {
     case JavaArrayType(elem1) =>
-      tp2 match {
+      tp2.stripAnnots match {
         case JavaArrayType(elem2) => JavaArrayType(erasedLub(elem1, elem2))
         case _ => defn.ObjectType
       }
     case _ =>
-      tp2 match {
+      tp2.stripAnnots match {
         case JavaArrayType(_) => defn.ObjectType
         case _ =>
           val cls2 = tp2.classSymbol
@@ -216,14 +216,14 @@ object TypeErasure {
    *  - subtypes over supertypes, unless isJava is set
    *  - real classes over traits
    */
-  def erasedGlb(tp1: Type, tp2: Type, isJava: Boolean)(implicit ctx: Context): Type = tp1 match {
+  def erasedGlb(tp1: Type, tp2: Type, isJava: Boolean)(implicit ctx: Context): Type = tp1.stripAnnots match {
     case JavaArrayType(elem1) =>
-      tp2 match {
+      tp2.stripAnnots match {
         case JavaArrayType(elem2) => JavaArrayType(erasedGlb(elem1, elem2, isJava))
         case _ => tp1
       }
     case _ =>
-      tp2 match {
+      tp2.stripAnnots match {
         case JavaArrayType(_) => tp2
         case _ =>
           val tsym1 = tp1.typeSymbol
@@ -346,7 +346,7 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
     else JavaArrayType(this(elemtp))
   }
 
-  def eraseInfo(tp: Type, sym: Symbol)(implicit ctx: Context) = tp match {
+  def eraseInfo(tp: Type, sym: Symbol)(implicit ctx: Context) = tp.stripAnnots match {
     case ExprType(rt) =>
       if (sym is Param) apply(tp)
         // Note that params with ExprTypes are eliminated by ElimByName,
@@ -365,7 +365,7 @@ class TypeErasure(isJava: Boolean, isSemi: Boolean, isConstructor: Boolean, wild
     (if (cls.owner is Package) normalizeClass(cls) else cls).typeRef
   }
 
-  private def eraseResult(tp: Type)(implicit ctx: Context): Type = tp match {
+  private def eraseResult(tp: Type)(implicit ctx: Context): Type = tp.stripAnnots match {
     case tp: TypeRef =>
       val sym = tp.typeSymbol
       if (sym eq defn.UnitClass) sym.typeRef

src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -359,7 +359,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   /** Is symbol potentially a getter of a mutable variable?
    */
   def mayBeVarGetter(sym: Symbol)(implicit ctx: Context): Boolean = {
-    def maybeGetterType(tpe: Type): Boolean = tpe match {
+    def maybeGetterType(tpe: Type): Boolean = tpe.stripAnnots match {
       case _: ExprType | _: ImplicitMethodType => true
       case tpe: PolyType => maybeGetterType(tpe.resultType)
       case _ => false

src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -89,7 +89,7 @@ final class TreeTypeMap(
     case tree1 =>
       tree1.withType(mapType(tree1.tpe)) match {
         case id: Ident if tpd.needsSelect(id.tpe) =>
-          ref(id.tpe.asInstanceOf[TermRef]).withPos(id.pos)
+          ref(id.tpe.stripAnnots.asInstanceOf[TermRef]).withPos(id.pos)
         case ddef @ DefDef(name, tparams, vparamss, tpt, rhs) =>
           val (tmap1, tparams1) = transformDefs(ddef.tparams)
           val (tmap2, vparamss1) = tmap1.transformVParamss(vparamss)

src/dotty/tools/dotc/ast/tpd.scala

@@ -177,14 +177,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     polyDefDef(sym, Function.const(rhsFn))
 
   def polyDefDef(sym: TermSymbol, rhsFn: List[Type] => List[List[Tree]] => Tree)(implicit ctx: Context): DefDef = {
-    val (tparams, mtp) = sym.info match {
+    val (tparams, mtp) = sym.info.stripAnnots match {
       case tp: PolyType =>
         val tparams = ctx.newTypeParams(sym, tp.paramNames, EmptyFlags, tp.instantiateBounds)
         (tparams, tp.instantiate(tparams map (_.typeRef)))
       case tp => (Nil, tp)
     }
 
-    def valueParamss(tp: Type): (List[List[TermSymbol]], Type) = tp match {
+    def valueParamss(tp: Type): (List[List[TermSymbol]], Type) = tp.stripAnnots match {
       case tp @ MethodType(paramNames, paramTypes) =>
         def valueParam(name: TermName, info: Type): TermSymbol =
           ctx.newSymbol(sym, name, TermParam, info)
@@ -256,7 +256,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   // ------ Making references ------------------------------------------------------
 
   def prefixIsElidable(tp: NamedType)(implicit ctx: Context) = {
-    def test(implicit ctx: Context) = tp.prefix match {
+    def test(implicit ctx: Context) = tp.prefix.stripAnnots match {
       case NoPrefix =>
         true
       case pre: ThisType =>
@@ -273,7 +273,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
-  def needsSelect(tp: Type)(implicit ctx: Context) = tp match {
+  def needsSelect(tp: Type)(implicit ctx: Context) = tp.stripAnnots match {
     case tp: TermRef => !prefixIsElidable(tp)
     case _ => false
   }
@@ -282,15 +282,15 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def ref(tp: NamedType)(implicit ctx: Context): Tree =
     if (tp.isType) TypeTree(tp)
     else if (prefixIsElidable(tp)) Ident(tp)
-    else tp.prefix match {
+    else tp.prefix.stripAnnots match {
       case pre: SingletonType => singleton(pre).select(tp)
       case pre => SelectFromTypeTree(TypeTree(pre), tp)
     } // no checks necessary
 
   def ref(sym: Symbol)(implicit ctx: Context): Tree =
     ref(NamedType(sym.owner.thisType, sym.name, sym.denot))
 
-  def singleton(tp: Type)(implicit ctx: Context): Tree = tp match {
+  def singleton(tp: Type)(implicit ctx: Context): Tree = tp.stripAnnots match {
     case tp: TermRef => ref(tp)
     case tp: ThisType => This(tp.cls)
     case SuperType(qual, _) => singleton(qual)

src/dotty/tools/dotc/core/Denotations.scala

@@ -382,7 +382,7 @@ object Denotations {
 
     final def signature(implicit ctx: Context): Signature = {
       if (isType) Signature.NotAMethod // don't force info if this is a type SymDenotation
-      else info match {
+      else info.stripAnnots match {
         case info: MethodicType =>
           try info.signature
           catch { // !!! DEBUG

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

@@ -510,7 +510,7 @@ object SymDenotations {
       /** Is `pre` the same as C.thisThis, where C is exactly the owner of this symbol,
        *  or, if this symbol is protected, a subclass of the owner?
        */
-      def isCorrectThisType(pre: Type): Boolean = pre match {
+      def isCorrectThisType(pre: Type): Boolean = pre.stripAnnots match {
         case pre: ThisType =>
           (pre.cls eq owner) || (this is Protected) && pre.cls.derivesFrom(owner)
         case pre: TermRef =>
@@ -573,7 +573,7 @@ object SymDenotations {
       !(  this.isTerm
        || this.isStaticOwner
        || ctx.erasedTypes
-       || (pre eq NoPrefix) || (pre eq thisType)
+       || (pre.stripAnnots eq NoPrefix) || (pre.stripAnnots eq thisType.stripAnnots)
        )
 
     /** Is this symbol concrete, or that symbol deferred? */
@@ -617,7 +617,7 @@ object SymDenotations {
     /** The class implementing this module, NoSymbol if not applicable. */
     final def moduleClass(implicit ctx: Context): Symbol =
       if (this is ModuleVal)
-        myInfo match {
+        myInfo.stripAnnots match {
           case info: TypeRef           => info.symbol
           case ExprType(info: TypeRef) => info.symbol // needed after uncurry, when module terms might be accessor defs
           case info: LazyType          => info.moduleClass
@@ -626,7 +626,7 @@ object SymDenotations {
       else NoSymbol
 
     /** The module implemented by this module class, NoSymbol if not applicable. */
-    final def sourceModule(implicit ctx: Context): Symbol = myInfo match {
+    final def sourceModule(implicit ctx: Context): Symbol = myInfo.stripAnnots match {
       case ClassInfo(_, _, _, _, selfType: TermRef) if this is ModuleClass =>
         selfType.symbol
       case info: LazyType =>
@@ -1363,6 +1363,7 @@ object SymDenotations {
         case tp: TypeVar => tp.inst.exists && inCache(tp.inst)
         case tp: TypeProxy => inCache(tp.underlying)
         case tp: AndOrType => inCache(tp.tp1) && inCache(tp.tp2)
+        case tp: AnnotatedType => isCachable(tp.tpe)
         case _ => true
       }
 

src/dotty/tools/dotc/core/TypeApplications.scala

@@ -250,9 +250,9 @@ class TypeApplications(val self: Type) extends AnyVal {
    */
   final def baseTypeWithArgs(base: Symbol)(implicit ctx: Context): Type = ctx.traceIndented(s"btwa ${self.show} wrt $base", core, show = true) {
     def default = self.baseTypeRef(base).appliedTo(baseArgInfos(base))
-    self match {
+    self.stripAnnots match {
       case tp: TypeRef =>
-        tp.info match {
+        tp.info.stripAnnots match {
           case TypeBounds(_, hi) => hi.baseTypeWithArgs(base)
           case _ => default
         }
@@ -297,7 +297,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    */
   final def argInfos(interpolate: Boolean)(implicit ctx: Context): List[Type] = {
     var tparams: List[TypeSymbol] = null
-    def recur(tp: Type, refineCount: Int): mutable.ListBuffer[Type] = tp.stripTypeVar match {
+    def recur(tp: Type, refineCount: Int): mutable.ListBuffer[Type] = tp.stripTypeVar.stripAnnots match {
       case tp @ RefinedType(tycon, name) =>
         val buf = recur(tycon, refineCount + 1)
         if (buf == null) null
@@ -352,7 +352,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *
    *                       for a contravariant type-parameter becomes L.
    */
-  final def argInfo(tparam: Symbol, interpolate: Boolean = true)(implicit ctx: Context): Type = self match {
+  final def argInfo(tparam: Symbol, interpolate: Boolean = true)(implicit ctx: Context): Type = self.stripAnnots match {
     case self: TypeAlias => self.alias
     case TypeBounds(lo, hi) =>
       if (interpolate) {
@@ -367,14 +367,14 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** The element type of a sequence or array */
-  def elemType(implicit ctx: Context): Type = self match {
+  def elemType(implicit ctx: Context): Type = self.stripAnnots match {
     case defn.ArrayType(elemtp) => elemtp
     case JavaArrayType(elemtp) => elemtp
     case _ => firstBaseArgInfo(defn.SeqClass)
   }
 
   def containsSkolemType(target: Type)(implicit ctx: Context): Boolean = {
-    def recur(tp: Type): Boolean = tp.stripTypeVar match {
+    def recur(tp: Type): Boolean = tp.stripTypeVar.stripAnnots match {
       case SkolemType(tp) =>
         tp eq target
       case tp: NamedType =>
@@ -434,7 +434,7 @@ class TypeApplications(val self: Type) extends AnyVal {
           for (sym <- boundSyms)
             yield TypeRef(SkolemType(rt), correspondingParamName(sym))
 
-        def rewrite(tp: Type): Type = tp match {
+        def rewrite(tp: Type): Type = tp.stripAnnots match {
           case tp @ RefinedType(parent, name: TypeName) =>
             if (correspondingNames contains name) rewrite(parent)
             else RefinedType(
@@ -482,7 +482,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       //println(i"lambda abstract $self wrt $boundSyms%, % --> $res")
       res
     }
-    self match {
+    self.stripAnnots match {
       case self @ TypeBounds(lo, hi) =>
         self.derivedTypeBounds(lo, expand(TypeBounds.upper(hi)))
       case _ =>

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

@@ -200,7 +200,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
     case tp2: LazyRef =>
       isSubType(tp1, tp2.ref)
     case tp2: AnnotatedType =>
-      isSubType(tp1, tp2.tpe) // todo: refine?
+      isSubType(tp1.stripAnnots, tp2.stripAnnots) // todo: refine?
     case tp2: ThisType =>
       def compareThis = {
         val cls2 = tp2.cls
@@ -282,7 +282,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
     case tp1: LazyRef =>
       isSubType(tp1.ref, tp2)
     case tp1: AnnotatedType =>
-      isSubType(tp1.tpe, tp2)
+      isSubType(tp1.stripAnnots, tp2.stripAnnots)
     case OrType(tp11, tp12) =>
       isSubType(tp11, tp2) && isSubType(tp12, tp2)
     case ErrorType =>
@@ -416,7 +416,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
           }
           isSubType(hi1, tp2) || compareGADT
         case _ =>
-          def isNullable(tp: Type): Boolean = tp.dealias match {
+          def isNullable(tp: Type): Boolean = tp.dealias.stripAnnots match {
             case tp: TypeRef => tp.symbol.isNullableClass
             case RefinedType(parent, _) => isNullable(parent)
             case AndType(tp1, tp2) => isNullable(tp1) && isNullable(tp2)
@@ -453,7 +453,9 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
         case JavaArrayType(elem2) => isSubType(elem1, elem2)
         case _ => tp2 isRef ObjectClass
       }
-      compareJavaArray 
+      compareJavaArray
+    case tp1: AnnotatedType =>
+      isSubType(tp1.stripAnnots, tp2.stripAnnots)
     case _ =>
       false
   }
@@ -599,7 +601,7 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
   }
 
   /** Defer constraining type variables when compared against prototypes */
-  def isMatchedByProto(proto: ProtoType, tp: Type) = tp.stripTypeVar match {
+  def isMatchedByProto(proto: ProtoType, tp: Type) = tp.stripTypeVar.stripAnnots match {
     case tp: PolyParam if constraint contains tp => true
     case _ => proto.isMatchedBy(tp)
   }
@@ -644,9 +646,9 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
   // Tests around `matches`
 
   /** A function implementing `tp1` matches `tp2`. */
-  final def matchesType(tp1: Type, tp2: Type, relaxed: Boolean): Boolean = tp1.widen match {
+  final def matchesType(tp1: Type, tp2: Type, relaxed: Boolean): Boolean = tp1.widen.stripAnnots match {
     case tp1: MethodType =>
-      tp2.widen match {
+      tp2.widen.stripAnnots match {
         case tp2: MethodType =>
           tp1.isImplicit == tp2.isImplicit &&
             matchingParams(tp1.paramTypes, tp2.paramTypes, tp1.isJava, tp2.isJava) &&
@@ -656,15 +658,15 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling wi
             matchesType(tp1.resultType, tp2, relaxed)
       }
     case tp1: PolyType =>
-      tp2.widen match {
+      tp2.widen.stripAnnots match {
         case tp2: PolyType =>
           sameLength(tp1.paramNames, tp2.paramNames) &&
             matchesType(tp1.resultType, tp2.resultType.subst(tp2, tp1), relaxed)
         case _ =>
           false
       }
     case _ =>
-      tp2.widen match {
+      tp2.widen.stripAnnots match {
         case _: PolyType =>
           false
         case tp2: MethodType =>