Avoid another hardwired ConcreteAnnotation

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

Author: odersky

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

@@ -63,9 +63,14 @@ object Annotations {
       else if diff.exists then derivedAnnotation(tm.mapOver(tree))
       else this
 
+    /** Does this annotation refer to a parameter of `tl`?
+     *  Overridden in ConcreteAnnotation
+     */
+    def refersToParamOf(tl: TermLambda)(using Context): Boolean = false
+
     /** A string representation of the annotation.
      */
-    final def toText(printer: Printer): Text = printer.toText(this)
+    def toText(printer: Printer): Text = printer.toText(this)
 
     /** A text representing thge arguments of this annotation. Overridden in ConcreteAnnotation */
     def argsText(printer: Printer): Text = ""
@@ -77,7 +82,17 @@ object Annotations {
   }
 
   case class ConcreteAnnotation(t: Tree) extends Annotation {
+  
     def tree(using Context): Tree = t
+
+    override def refersToParamOf(tl: TermLambda)(using Context): Boolean =
+      tree.existsSubTree {
+        case id: Ident => id.tpe match
+          case TermParamRef(tl1, _) => tl eq tl1
+          case _ => false
+        case _ => false
+      }
+      
     override def argsText(printer: Printer): Text =
       def toTextArg(arg: Tree): Text = arg match
         case Typed(SeqLiteral(elems, _), _) => printer.toTextGlobal(elems, ", ")

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

@@ -3579,16 +3579,6 @@ object Types {
     private var myDependencyStatus: DependencyStatus = Unknown
     private var myParamDependencyStatus: DependencyStatus = Unknown
 
-    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
-
     private def depStatus(initial: DependencyStatus, tp: Type)(using Context): DependencyStatus =
       class DepAcc extends TypeAccumulator[DependencyStatus]:
         def apply(status: DependencyStatus, tp: Type) = compute(status, tp, this)
@@ -3615,7 +3605,7 @@ object Types {
           case tp: TypeVar if !tp.isInstantiated => combine(status, Provisional)
           case tp: TermParamRef if tp.binder eq thisLambdaType => TrueDeps
           case AnnotatedType(parent, ann) =>
-            if refersToParam(ann) then TrueDeps else compute(status, parent, theAcc)
+            if ann.refersToParamOf(thisLambdaType) then TrueDeps else compute(status, parent, theAcc)
           case _: ThisType | _: BoundType | NoPrefix => status
           case _ =>
             (if theAcc != null then theAcc else DepAcc()).foldOver(status, tp)
@@ -3670,7 +3660,7 @@ object Types {
           def apply(tp: Type) = tp match {
             case tp @ TermParamRef(`thisLambdaType`, _) =>
               range(defn.NothingType, atVariance(1)(apply(tp.underlying)))
-            case AnnotatedType(parent, ann) if refersToParam(ann) =>
+            case AnnotatedType(parent, ann) if ann.refersToParamOf(thisLambdaType) =>
               mapOver(parent)
             case _ => mapOver(tp)
           }