Move getter/setter annotation to the underlying field

This is nessary for interactiong with java libraries such as JMH. Matches scalac's behavior.

Author: OlivierBlanvillain

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

@@ -277,7 +277,7 @@ object SymDenotations {
     }
 
     /** Update the annotations of this denotation */
-    private[core] final def annotations_=(annots: List[Annotation]): Unit =
+    final def annotations_=(annots: List[Annotation]): Unit =
       myAnnotations = annots
 
     /** Does this denotation have an annotation matching the given class symbol? */

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

@@ -6,6 +6,7 @@ import DenotTransformers._
 import Phases.Phase
 import Contexts.Context
 import SymDenotations.SymDenotation
+import Denotations._
 import Types._
 import Symbols._
 import SymUtils._
@@ -84,12 +85,21 @@ import Decorators._
        .enteredAfter(thisTransform)
     }
 
-    /** Can be used to filter annotations on getters and setters; not used yet */
-    def keepAnnotations(denot: SymDenotation, meta: ClassSymbol) = {
-      val cpy = sym.copySymDenotation()
-      cpy.filterAnnotations(_.symbol.derivesFrom(meta))
-      if (cpy.annotations ne denot.annotations) cpy.installAfter(thisTransform)
-    }
+    def addAnnotations(denot: Denotation): Unit =
+      denot match {
+        case fieldDenot: SymDenotation if sym.annotations.nonEmpty =>
+          val cpy = fieldDenot.copySymDenotation()
+          cpy.annotations = sym.annotations
+          cpy.installAfter(thisTransform)
+        case _ => ()
+      }
+
+    def removeAnnotations(denot: SymDenotation): Unit =
+      if (sym.annotations.nonEmpty) {
+        val cpy = sym.copySymDenotation()
+        cpy.annotations = Nil
+        cpy.installAfter(thisTransform)
+      }
 
     lazy val field = sym.field.orElse(newField).asTerm
 
@@ -125,14 +135,18 @@ import Decorators._
           if (isErasableBottomField(rhsClass)) erasedBottomTree(rhsClass)
           else transformFollowingDeep(ref(field))(ctx.withOwner(sym), info)
         val getterDef = cpy.DefDef(tree)(rhs = getterRhs)
+        addAnnotations(fieldDef.denot)
+        removeAnnotations(sym)
         Thicket(fieldDef, getterDef)
       } else if (sym.isSetter) {
         if (!sym.is(ParamAccessor)) { val Literal(Constant(())) = tree.rhs } // This is intended as an assertion
         field.setFlag(Mutable) // Necessary for vals mixed in from Scala2 traits
         if (isErasableBottomField(tree.vparamss.head.head.tpt.tpe.classSymbol)) tree
         else {
           val initializer = Assign(ref(field), adaptToField(ref(tree.vparamss.head.head.symbol)))
-          cpy.DefDef(tree)(rhs = transformFollowingDeep(initializer)(ctx.withOwner(sym), info))
+          val setterDef = cpy.DefDef(tree)(rhs = transformFollowingDeep(initializer)(ctx.withOwner(sym), info))
+          removeAnnotations(sym)
+          setterDef
         }
       }
       else tree // curiously, some accessors from Scala2 have ' ' suffixes. They count as