Implement bean property generation

Author: Kordyjan

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

@@ -890,6 +890,8 @@ class Definitions {
 
   // Annotation classes
   @tu lazy val AnnotationDefaultAnnot: ClassSymbol = requiredClass("scala.annotation.internal.AnnotationDefault")
+  @tu lazy val BeanPropertyAnnot: ClassSymbol = requiredClass("scala.beans.BeanProperty")
+  @tu lazy val BooleanBeanPropertyAnnot: ClassSymbol = requiredClass("scala.beans.BooleanBeanProperty")
   @tu lazy val BodyAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Body")
   @tu lazy val ChildAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Child")
   @tu lazy val ContextResultCountAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ContextResultCount")

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

@@ -0,0 +1,61 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import ast.tpd._
+import Contexts.Context
+import SymDenotations._
+import Symbols.newSymbol
+import Decorators._
+import Flags._
+import Names._
+import Types._
+
+import DenotTransformers._
+
+class BeanProperties(thisPhase: DenotTransformer):
+  def addBeanMethods(impl: Template)(using Context): Template =
+    val origBody = impl.body
+    cpy.Template(impl)(body = impl.body.flatMap {
+      case v: ValDef => generateAccessors(v)
+      case _ => Nil
+    } ::: origBody)
+
+  def generateAccessors(valDef: ValDef)(using Context): List[Tree] =
+    import Symbols.defn
+
+    def generateGetter(valDef: ValDef)(using Context) : Tree =
+      val prefix = if valDef.symbol.denot.hasAnnotation(defn.BooleanBeanPropertyAnnot) then "is" else "get"
+      val meth = newSymbol(
+        owner = summon[Context].owner,
+        name = prefixedName(prefix, valDef.name),
+        flags = Method | Permanent | Synthetic,
+        info = MethodType(Nil, valDef.denot.info))
+        .enteredAfter(thisPhase).asTerm
+      meth.addAnnotations(valDef.symbol.annotations)
+      val body: Tree = ref(valDef.symbol)
+      DefDef(meth, body)
+
+    def maybeGenerateSetter(valDef: ValDef)(using Context): Option[Tree] =
+      Option.when(valDef.denot.asSymDenotation.flags.is(Mutable)) {
+        val owner = summon[Context].owner
+        val meth = newSymbol(
+          owner,
+          name = prefixedName("set", valDef.name),
+          flags = Method | Permanent | Synthetic,
+          info = MethodType(valDef.name :: Nil, valDef.denot.info :: Nil, defn.UnitType)
+        ).enteredAfter(thisPhase).asTerm
+        meth.addAnnotations(valDef.symbol.annotations)
+        def body(params: List[List[Tree]]): Tree = Assign(ref(valDef.symbol), params.head.head)
+        DefDef(meth, body)
+      }
+
+    def prefixedName(prefix: String, valName: Name) =
+      (prefix + valName.lastPart.toString.capitalize).toTermName
+
+    extension(a: SymDenotation) def isApplicable = a.hasAnnotation(defn.BeanPropertyAnnot) || a.hasAnnotation(defn.BooleanBeanPropertyAnnot)
+
+    if valDef.denot.symbol.isApplicable then
+      generateGetter(valDef) +: maybeGenerateSetter(valDef) ++: Nil
+    else Nil
+  end generateAccessors

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

@@ -75,6 +75,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
 
   val superAcc: SuperAccessors = new SuperAccessors(thisPhase)
   val synthMbr: SyntheticMembers = new SyntheticMembers(thisPhase)
+  val beanProps: BeanProperties = new BeanProperties(thisPhase)
 
   private def newPart(tree: Tree): Option[New] = methPart(tree) match {
     case Select(nu: New, _) => Some(nu)
@@ -322,8 +323,10 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           withNoCheckNews(templ.parents.flatMap(newPart)) {
             forwardParamAccessors(templ)
             synthMbr.addSyntheticMembers(
+              beanProps.addBeanMethods(
                 superAcc.wrapTemplate(templ)(
                   super.transform(_).asInstanceOf[Template]))
+            )
           }
         case tree: ValDef =>
           val tree1 = cpy.ValDef(tree)(rhs = normalizeErasedRhs(tree.rhs, tree.symbol))