Improve mapping TypeMaps over annotations

Remove hardwired references to ConcreteAnnotation and simplify
the logic in TypeMap.

# Conflicts:
#	compiler/src/dotty/tools/dotc/core/Annotations.scala
#	compiler/src/dotty/tools/dotc/core/Types.scala

Author: odersky

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

@@ -7,14 +7,17 @@ import StdNames._
 import dotty.tools.dotc.ast.tpd
 import scala.util.Try
 import util.Spans.Span
+import printing.{Showable, Printer, Texts}
+import Texts.{Text, Str}
+import annotation.internal.sharable
 
 object Annotations {
 
   def annotClass(tree: Tree)(using Context) =
     if (tree.symbol.isConstructor) tree.symbol.owner
     else tree.tpe.typeSymbol
 
-  abstract class Annotation {
+  abstract class Annotation extends Showable {
     def tree(using Context): Tree
 
     def symbol(using Context): Symbol = annotClass(tree)
@@ -44,6 +47,34 @@ object Annotations {
     /** The tree evaluation has finished. */
     def isEvaluated: Boolean = true
 
+    /** The annotation should be part of mappings?
+     *  Currently overridden only in ConcreteAnnotation, which simulates the previous behavior.
+     */
+    def isMappable: Boolean = false
+
+    /** Normally, map type map over all tree nodes of this annotation, but can
+     *  be overridden. Returns EmptyAnnotation if type type map produces a range
+     *  type, since ranges cannot be types of trees.
+     */
+    def mapWith(tm: TypeMap)(using Context) =
+      val findDiff = new TreeAccumulator[Type]:
+        def apply(x: Type, tree: Tree)(using Context): Type =
+          if tm.isRange(x) then x
+          else
+            val tp1 = tm(tree.tpe)
+            foldOver(if tp1 =:= tree.tpe then x else tp1, tree)
+      val diff = findDiff(NoType, tree)
+      if tm.isRange(diff) then EmptyAnnotation
+      else if diff.exists then derivedAnnotation(tm.mapOver(tree))
+      else this
+
+    /** A string representation of the annotation.
+     */
+    final def toText(printer: Printer): Text = printer.toText(this)
+
+    /** A text representing thge arguments of this annotation. Overridden in ConcreteAnnotation */
+    def argsText(printer: Printer): Text = ""
+
     def ensureCompleted(using Context): Unit = tree
 
     def sameAnnotation(that: Annotation)(using Context): Boolean =
@@ -52,6 +83,20 @@ object Annotations {
 
   case class ConcreteAnnotation(t: Tree) extends Annotation {
     def tree(using Context): Tree = t
+    override def isMappable = true
+    override def argsText(printer: Printer): Text =
+      def toTextArg(arg: Tree): Text = arg match
+        case Typed(SeqLiteral(elems, _), _) => printer.toTextGlobal(elems, ", ")
+        case _ => printer.toText(arg)
+      def recur(tree: Tree): Text = tree match
+        case TypeApply(fn, args) =>
+          recur(fn) ~ "[" ~ printer.toTextGlobal(args, ", ") ~ "]"
+        case Apply(fn, args) =>
+          recur(fn)
+          ~ (Str("(") ~ Text(args.map(toTextArg), ", ") ~ ")" provided args.nonEmpty)
+        case _ =>
+          ""
+      recur(t)
   }
 
   abstract class LazyAnnotation extends Annotation {
@@ -194,6 +239,8 @@ object Annotations {
       apply(defn.SourceFileAnnot, Literal(Constant(path)))
   }
 
+  @sharable val EmptyAnnotation = Annotation(EmptyTree)
+
   def ThrowsAnnotation(cls: ClassSymbol)(using Context): Annotation = {
     val tref = cls.typeRef
     Annotation(defn.ThrowsAnnot.typeRef.appliedTo(tref), Ident(tref))

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

@@ -3579,13 +3579,15 @@ object Types {
     private var myDependencyStatus: DependencyStatus = Unknown
     private var myParamDependencyStatus: DependencyStatus = Unknown
 
-    private def refersToParam(tree: Tree)(using Context): Boolean =
-      tree.existsSubTree {
-        case id: Ident => id.tpe match
-          case TermParamRef(`thisLambdaType`, _) => true
+    private def refersToParam(ann: Annotation)(using Context): Boolean = ann match
+      case ConcreteAnnotation(tree) =>
+        tree.existsSubTree {
+          case id: Ident => id.tpe match
+            case TermParamRef(`thisLambdaType`, _) => true
+            case _ => false
           case _ => false
-        case _ => false
-      }
+        }
+      case _ => false
 
     private def depStatus(initial: DependencyStatus, tp: Type)(using Context): DependencyStatus =
       class DepAcc extends TypeAccumulator[DependencyStatus]:
@@ -3612,7 +3614,7 @@ object Types {
           case tp: AppliedType => tp.fold(status, compute(_, _, theAcc))
           case tp: TypeVar if !tp.isInstantiated => combine(status, Provisional)
           case tp: TermParamRef if tp.binder eq thisLambdaType => TrueDeps
-          case AnnotatedType(parent, ConcreteAnnotation(ann)) =>
+          case AnnotatedType(parent, ann) =>
             if refersToParam(ann) then TrueDeps else compute(status, parent, theAcc)
           case _: ThisType | _: BoundType | NoPrefix => status
           case _ =>
@@ -3668,7 +3670,7 @@ object Types {
           def apply(tp: Type) = tp match {
             case tp @ TermParamRef(`thisLambdaType`, _) =>
               range(defn.NothingType, atVariance(1)(apply(tp.underlying)))
-            case AnnotatedType(parent, ConcreteAnnotation(ann)) if refersToParam(ann) =>
+            case AnnotatedType(parent, ann) if refersToParam(ann) =>
               mapOver(parent)
             case _ => mapOver(tp)
           }
@@ -5392,16 +5394,7 @@ object Types {
       variance = saved
       derivedLambdaType(tp)(ptypes1, this(restpe))
 
-    protected def isRange(tp: Type): Boolean = tp.isInstanceOf[Range]
-
-    private def diffType(ann: Tree): Type =
-      val acc = new TreeAccumulator[Type]:
-        def apply(x: Type, tree: Tree)(using Context): Type =
-          if isRange(x) then x
-          else
-            val tp1 = thisMap(tree.tpe)
-            foldOver(if tp1 =:= tree.tpe then x else tp1, tree)
-      acc(NoType, ann)
+    def isRange(tp: Type): Boolean = tp.isInstanceOf[Range]
 
     /** Map this function over given type */
     def mapOver(tp: Type): Type = {
@@ -5446,16 +5439,12 @@ object Types {
 
         case tp @ AnnotatedType(underlying, annot) =>
           val underlying1 = this(underlying)
-          if (underlying1 ne underlying) || annot.isInstanceOf[ConcreteAnnotation] then
-            val diff = diffType(annot.tree)
-            if isRange(diff) then
-              // Can't map a tree type to a Range, drop annotation instead
-              underlying1
-            else
-              val annot1 = if diff.exists then mapOver(annot) else annot
-              derivedAnnotatedType(tp, underlying1, annot1)
-          else
-            derivedAnnotatedType(tp, underlying1, annot)
+          val annot1 =
+            if (underlying1 ne underlying) || annot.isMappable
+            then annot.mapWith(this)
+            else annot
+          if annot1 eq EmptyAnnotation then underlying1
+          else derivedAnnotatedType(tp, underlying1, annot1)
 
         case _: ThisType
           | _: BoundType
@@ -5527,9 +5516,6 @@ object Types {
       else newScopeWith(elems1: _*)
     }
 
-    def mapOver(annot: Annotation): Annotation =
-      annot.derivedAnnotation(mapOver(annot.tree))
-
     def mapOver(tree: Tree): Tree = treeTypeMap(tree)
 
     /** Can be overridden. By default, only the prefix is mapped. */