[Proof of Concept] Code generation via rewriting errors in macro annotations

This commit prototypes the proposal in
https://contributors.scala-lang.org/t/scala-3-macro-annotations-and-code-generation/6035
to use a macro annotation to do code generation. Since the -rewrite mechanism
isn't currently accessible to macros, we just print an error indicating what
part of the source code needs to be rewritten.

We implement support for a subset of `@data`: only the `withField` methods are
added (note that equals/hashCode/toString wouldn't need to be code-generated
since they are already defined in `AnyRef`, so a macro annotation can override
them as demonstrated in the existing `tests/run-macros/annot-mod-class-data`
test).

This is only one possible path forward. Alternatively, we could recommend using
scalafix for this usecase, and then the compiler itself wouldn't have to grow
code generation abilities, but libraries defining macro annotation might not
like to be tied to an external tool.

Author: smarter

tests/neg-macros/annot-codegen.check

@@ -0,0 +1,13 @@
+
+-- Error: tests/neg-macros/annot-codegen/Test_2.scala:9:4 --------------------------------------------------------------
+9 |    new Bar("", two, 1, 1.0) // error: body needs to be replaced
+  |    ^^^^^^^^^^^^^^^^^^^^^^^^
+  |    Replace the underline code by:
+  |    data.generated[Bar]()
+-- Error: tests/neg-macros/annot-codegen/Test_2.scala:3:80 -------------------------------------------------------------
+3 |@data class Bar(val one: String, val two: Int, val three: Int, val four: Double): // error: additional methods needed
+  |                                                                                ^
+  |                                                     @data requires the following additional method(s):
+  |
+  |                                                     def withThree(three: scala.Int): Bar = data.generated[Bar]()
+  |                                                     def withFour(four: scala.Double): Bar = data.generated[Bar]()

tests/neg-macros/annot-codegen/Macro_1.scala

@@ -0,0 +1,83 @@
+import scala.annotation.{experimental, MacroAnnotation}
+import scala.quoted.*
+import scala.collection.mutable.ArrayBuffer
+
+@experimental
+class data extends MacroAnnotation:
+  import data.*
+  def transform(using Quotes)(tree: quotes.reflect.Definition): List[quotes.reflect.Definition] =
+    import quotes.reflect.*
+    tree match
+      case cdef: ClassDef =>
+        val classPatches = ArrayBuffer[String]()
+
+        val cls = tree.symbol
+        val expectedBody = s"data.generated[${cls.name}]()" // FIXME: handle type parameters
+
+        val params = paramNames(cls)
+        for param <- params do
+          val withParam = With(param)
+          val paramType = cls.declaredField(param).info
+          val existingOpt =
+            cls.declaredMethod(withParam).find(o =>
+              val paramss = o.paramSymss
+              paramss.size == 1 && paramss(0).size == 1
+              && paramss(0)(0).name == param // FIXME: if the parameter name is incorrect, propose rewriting it
+              && paramss(0)(0).info == paramType // FIXME: if the parameter type changed, propose rewriting it
+            )
+          existingOpt match
+            case Some(existing) => existing.tree match
+              case tree: DefDef =>
+                tree.rhs match
+                case Some(rhs) => rhs.asExpr match
+                  case '{data.generated[t]()} =>
+                    // The correct method is already present, nothing to do
+                  case _ =>
+                    report.error(s"Replace the underline code by:\n$expectedBody", rhs.pos)
+                case _ =>
+                  report.error("FIXME: Passing -Yretain-trees is currently needed for this macro to work")
+              case _ =>
+            case _ =>
+              // The method is not present
+              classPatches +=
+                s"def $withParam($param: ${paramType.show}): ${cls.name} = $expectedBody"
+
+
+        val ctr = cdef.constructor
+        val endPos = Position(ctr.pos.sourceFile, ctr.pos.end, ctr.pos.end)
+        // TODO: if the class has no existing body, we also need to add braces or ':'
+        if classPatches.nonEmpty then
+          report.error("@data requires the following additional method(s):\n\n" +
+            classPatches.mkString("\n"), endPos)
+      case _ =>
+        report.error("Annotation only supports `class`")
+    List(tree)
+
+object data:
+  inline def generated[T](): T = ${generatedImpl[T]}
+  private def generatedImpl[T: Type](using Quotes): Expr[T] =
+    import quotes.reflect.*
+    val meth = Symbol.spliceOwner.owner
+    val cls = meth.owner
+    val params = paramNames(cls)
+    meth.name match
+      case With(paramName) =>
+        val localParam = meth.paramSymss(0)(0)
+        val body =
+          Apply(Select(New(TypeIdent(cls)), cls.primaryConstructor),
+            params.map(p => if p == paramName then Ref(localParam) else Ref(cls.declaredField(p))))
+        body.asExprOf[T]
+      case _ =>
+        report.errorAndAbort("@data.generated used in invalid context")
+
+  def paramNames(using Quotes)(cls: quotes.reflect.Symbol): List[String] =
+    cls.primaryConstructor.paramSymss.head.map(_.name)
+
+private object With:
+  def apply(paramName: String): String =
+    s"with${paramName.head.toUpper}${paramName.tail}"
+  def unapply(methodName: String): Option[String] = methodName match
+      case s"with$rest" =>
+        Some(s"${rest.head.toLower}${rest.tail}")
+      case _ =>
+        None

tests/neg-macros/annot-codegen/Test_2.scala

@@ -0,0 +1,9 @@
+// scalac: -Yretain-trees
+
+@data class Bar(val one: String, val two: Int, val three: Int, val four: Double): // error: additional methods needed
+  // This definition is OK and will be left as is
+  def withOne(one: String): Bar =
+    data.generated[Bar]()
+
+  def withTwo(two: Int): Bar =
+    new Bar("", two, 1, 1.0) // error: body needs to be replaced