Soften anomaly when mapping annotations

A TypeMap mapped annotations only if the underlying types were different. There's no
fundamental reason why this should be so. We now map concrete annotations also if they contain
a subtree that gets a different type under the mapping.

Author: odersky

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

@@ -163,9 +163,13 @@ object TypeOps:
         // with Nulls (which have no base classes). Under -Yexplicit-nulls, we take
         // corrective steps, so no widening is wanted.
         simplify(l, theMap) | simplify(r, theMap)
-      case AnnotatedType(parent, annot)
-      if annot.symbol == defn.UncheckedVarianceAnnot && !ctx.mode.is(Mode.Type) && !theMap.isInstanceOf[SimplifyKeepUnchecked] =>
-        simplify(parent, theMap)
+      case tp @ AnnotatedType(parent, annot) =>
+        val parent1 = simplify(parent, theMap)
+        if annot.symbol == defn.UncheckedVarianceAnnot
+            && !ctx.mode.is(Mode.Type)
+            && !theMap.isInstanceOf[SimplifyKeepUnchecked]
+        then parent1
+        else tp.derivedAnnotatedType(parent1, annot)
       case _: MatchType =>
         val normed = tp.tryNormalize
         if (normed.exists) normed else mapOver

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

@@ -5566,8 +5566,17 @@ object Types {
 
         case tp @ AnnotatedType(underlying, annot) =>
           val underlying1 = this(underlying)
-          if (underlying1 eq underlying) tp
-          else derivedAnnotatedType(tp, underlying1, mapOver(annot))
+          val annot1 =
+            if underlying1 ne underlying then mapOver(annot)
+            else annot match
+              case ConcreteAnnotation(ann)
+              if ann.existsSubTree { t =>
+                  val tpe = t.typeOpt
+                  tpe.exists && !(this(tpe) =:= tpe)
+                } => mapOver(annot)
+              case _ => annot
+          if (underlying1 eq underlying) && (annot eq annot1) then tp
+          else derivedAnnotatedType(tp, underlying1, annot1)
 
         case tp @ CapturingType(parent, refs) =>
           derivedCapturingType(tp, this(parent), refs.flatMap(this(_).captureSet))