Push copyAndKeepAnnotationsCarrying into SymDenotation

Author: dwijnand

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

@@ -88,18 +88,20 @@ object Annotations {
     def sameAnnotation(that: Annotation)(using Context): Boolean =
       symbol == that.symbol && tree.sameTree(that.tree)
 
-    def hasOneOfMetaAnnotation(metaSyms: Symbol*)(using Context): Boolean = atPhaseNoLater(erasurePhase) {
-      def recTp(tp: Type): Boolean = tp.dealiasKeepAnnots match
-        case AnnotatedType(parent, metaAnnot) => metaSyms.exists(metaAnnot.matches) || recTp(parent)
-        case _ => false
-      def rec(tree: Tree): Boolean = methPart(tree) match
-        case New(tpt) => rec(tpt)
-        case Select(qual, _) => rec(qual)
-        case Annotated(arg, metaAnnot) => metaSyms.exists(metaAnnot.tpe.classSymbol.derivesFrom) || rec(arg)
-        case t @ Ident(_) => recTp(t.tpe)
-        case Typed(expr, _) => rec(expr)
-        case _ => false
-      metaSyms.exists(symbol.hasAnnotation) || rec(tree)
+    def hasOneOfMetaAnnotation(metaSyms: Set[Symbol], orNoneOf: Set[Symbol] = Set.empty)(using Context): Boolean = atPhaseNoLater(erasurePhase) {
+      def go(metaSyms: Set[Symbol]) =
+        def recTp(tp: Type): Boolean = tp.dealiasKeepAnnots match
+          case AnnotatedType(parent, metaAnnot) => metaSyms.exists(metaAnnot.matches) || recTp(parent)
+          case _ => false
+        def rec(tree: Tree): Boolean = methPart(tree) match
+          case New(tpt) => rec(tpt)
+          case Select(qual, _) => rec(qual)
+          case Annotated(arg, metaAnnot) => metaSyms.exists(metaAnnot.tpe.classSymbol.derivesFrom) || rec(arg)
+          case t @ Ident(_) => recTp(t.tpe)
+          case Typed(expr, _) => rec(expr)
+          case _ => false
+        metaSyms.exists(symbol.hasAnnotation) || rec(tree)
+      go(metaSyms) || orNoneOf.nonEmpty && !go(orNoneOf)
     }
 
     /** Operations for hash-consing, can be overridden */

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

@@ -252,6 +252,15 @@ object SymDenotations {
     final def filterAnnotations(p: Annotation => Boolean)(using Context): Unit =
       annotations = annotations.filterConserve(p)
 
+    def annotationsCarrying(meta: Set[Symbol], orNoneOf: Set[Symbol] = Set.empty)(using Context): List[Annotation] =
+      annotations.filterConserve(_.hasOneOfMetaAnnotation(meta, orNoneOf = orNoneOf))
+
+    def copyAndKeepAnnotationsCarrying(phase: DenotTransformer, meta: Set[Symbol], orNoneOf: Set[Symbol] = Set.empty)(using Context): Unit =
+      if annotations.nonEmpty then
+        val cpy = copySymDenotation()
+        cpy.annotations = annotationsCarrying(meta, orNoneOf = orNoneOf)
+        cpy.installAfter(phase)
+
     /** Optionally, the annotation matching the given class symbol */
     final def getAnnotation(cls: Symbol)(using Context): Option[Annotation] =
       dropOtherAnnotations(annotations, cls) match {

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

@@ -5,7 +5,7 @@ import core._
 import ast.tpd._
 import Annotations._
 import Contexts._
-import Symbols.newSymbol
+import Symbols.*
 import SymUtils.*
 import Decorators._
 import Flags._
@@ -24,8 +24,6 @@ class BeanProperties(thisPhase: DenotTransformer):
     } ::: origBody)
 
   def generateAccessors(valDef: ValDef)(using Context): List[Tree] =
-    import Symbols.defn
-
     def generateGetter(valDef: ValDef, annot: Annotation)(using Context) : Tree =
       val prefix = if annot matches defn.BooleanBeanPropertyAnnot then "is" else "get"
       val meth = newSymbol(

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

@@ -108,27 +108,16 @@ class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
         if (sym.isGetter) sym.info.resultType
         else /*sym.isSetter*/ sym.info.firstParamTypes.head
 
-      val fieldSym = newSymbol(
+      newSymbol(
         owner = ctx.owner,
         name  = sym.name.asTermName.fieldName,
         flags = Private | (if (sym.is(StableRealizable)) EmptyFlags else Mutable),
         info  = fieldType,
         coord = tree.span
-      )
-      fieldSym.annotations = sym.annotations.filterConserve { annot =>
-        annot.hasOneOfMetaAnnotation(defn.FieldMetaAnnot)
-        || !annot.hasOneOfMetaAnnotation(defn.MetaAnnots.toList*)
-      }
-      fieldSym.enteredAfter(thisPhase)
+      ).withAnnotationsCarrying(sym, defn.FieldMetaAnnot, orNoneOf = defn.MetaAnnots)
+       .enteredAfter(thisPhase)
     }
 
-    def removeUnwantedAnnotations(denot: SymDenotation, metaAnnotSym: ClassSymbol): Unit =
-      if (sym.annotations.nonEmpty) {
-        val cpy = sym.copySymDenotation()
-        cpy.filterAnnotations(_.hasOneOfMetaAnnotation(metaAnnotSym))
-        cpy.installAfter(thisPhase)
-      }
-
     val NoFieldNeeded = Lazy | Deferred | JavaDefined | Inline
 
     def erasedBottomTree(sym: Symbol) =
@@ -178,7 +167,7 @@ class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
             if isErasableBottomField(field, rhsClass) then erasedBottomTree(rhsClass)
             else transformFollowingDeep(ref(field))(using ctx.withOwner(sym))
           val getterDef = cpy.DefDef(tree)(rhs = getterRhs)
-          removeUnwantedAnnotations(sym, defn.GetterMetaAnnot)
+          sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.GetterMetaAnnot))
           Thicket(fieldDef, getterDef)
       else if sym.isSetter then
         if (!sym.is(ParamAccessor)) { val Literal(Constant(())) = tree.rhs: @unchecked } // This is intended as an assertion
@@ -204,7 +193,7 @@ class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
             then Literal(Constant(()))
             else Assign(ref(field), adaptToField(field, ref(tree.termParamss.head.head.symbol)))
           val setterDef = cpy.DefDef(tree)(rhs = transformFollowingDeep(initializer)(using ctx.withOwner(sym)))
-          removeUnwantedAnnotations(sym, defn.SetterMetaAnnot)
+          sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.SetterMetaAnnot))
           setterDef
       else
         // Curiously, some accessors from Scala2 have ' ' suffixes.

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

@@ -157,12 +157,14 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           checkInferredWellFormed(tree.tpt)
           if sym.is(Method) then
             if sym.isSetter then
-              removeUnwantedAnnotations(sym, defn.SetterMetaAnnot, NoSymbol, keepIfNoRelevantAnnot = false)
+              sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.SetterMetaAnnot))
           else
             if sym.is(Param) then
-              removeUnwantedAnnotations(sym, defn.ParamMetaAnnot, NoSymbol, keepIfNoRelevantAnnot = true)
+              sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.ParamMetaAnnot), orNoneOf = defn.NonBeanMetaAnnots)
+            else if sym.is(ParamAccessor) then
+              sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.GetterMetaAnnot, defn.FieldMetaAnnot))
             else
-              removeUnwantedAnnotations(sym, defn.GetterMetaAnnot, defn.FieldMetaAnnot, keepIfNoRelevantAnnot = !sym.is(ParamAccessor))
+              sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.GetterMetaAnnot, defn.FieldMetaAnnot), orNoneOf = defn.NonBeanMetaAnnots)
           if sym.isScala2Macro && !ctx.settings.XignoreScala2Macros.value then
             if !sym.owner.unforcedDecls.exists(p => !p.isScala2Macro && p.name == sym.name && p.signature == sym.signature)
                // Allow scala.reflect.materializeClassTag to be able to compile scala/reflect/package.scala
@@ -184,13 +186,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         => Checking.checkAppliedTypesIn(tree)
       case _ =>
 
-    private def removeUnwantedAnnotations(sym: Symbol, metaAnnotSym: Symbol,
-        metaAnnotSymBackup: Symbol, keepIfNoRelevantAnnot: Boolean)(using Context): Unit =
-      def shouldKeep(annot: Annotation): Boolean =
-        annot.hasOneOfMetaAnnotation(metaAnnotSym, metaAnnotSymBackup)
-        || keepIfNoRelevantAnnot && !annot.hasOneOfMetaAnnotation(defn.NonBeanMetaAnnots.toList*)
-      if sym.annotations.nonEmpty then
-        sym.filterAnnotations(shouldKeep(_))
 
     private def transformSelect(tree: Select, targs: List[Tree])(using Context): Tree = {
       val qual = tree.qualifier

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

@@ -270,11 +270,8 @@ object SymUtils:
     def isEnumCase(using Context): Boolean =
       self.isAllOf(EnumCase, butNot = JavaDefined)
 
-    def annotationsCarrying(meta: ClassSymbol)(using Context): List[Annotation] =
-      self.annotations.filterConserve(_.hasOneOfMetaAnnotation(meta))
-
-    def withAnnotationsCarrying(from: Symbol, meta: ClassSymbol)(using Context): self.type = {
-      self.addAnnotations(from.annotationsCarrying(meta))
+    def withAnnotationsCarrying(from: Symbol, meta: Symbol, orNoneOf: Set[Symbol] = Set.empty)(using Context): self.type = {
+      self.addAnnotations(from.annotationsCarrying(Set(meta), orNoneOf))
       self
     }