Allow to annotate classes

Author: jchyb

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

@@ -639,6 +639,7 @@ object Symbols extends SymUtils {
       parentTypes: Symbol => List[Type],
       selfInfo: Type = NoType,
       privateWithin: Symbol = NoSymbol,
+      annotations: List[Tree] = Nil,
       coord: Coord = NoCoord,
       compUnitInfo: CompilationUnitInfo | Null = null)(using Context): ClassSymbol = {
     def completer = new LazyType {
@@ -648,6 +649,7 @@ object Symbols extends SymUtils {
         val parents = parentTypes(cls).map(_.dealias)
         assert(parents.nonEmpty && !parents.head.typeSymbol.is(dotc.core.Flags.Trait), "First parent must be a class")
         denot.info = ClassInfo(owner.thisType, cls, parents, decls, selfInfo)
+        denot.annotations = annotations.map(Annotations.Annotation(_))
       }
     }
     newClassSymbol(owner, name, flags, completer, privateWithin, coord, compUnitInfo)

compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala

@@ -2665,6 +2665,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           selfType,
           clsFlags,
           clsPrivateWithin,
+          Nil,
           conMethodType = res => MethodType(conParamNames)(_ => conParamTypes, _ => res),
           conFlags = Flags.EmptyFlags,
           conPrivateWithin = Symbol.noSymbol,
@@ -2679,6 +2680,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         selfType: Option[TypeRepr],
         clsFlags: Flags,
         clsPrivateWithin: Symbol,
+        clsAnnotations: List[Term],
         conMethodType: TypeRepr => MethodOrPoly,
         conFlags: Flags,
         conPrivateWithin: Symbol,
@@ -2694,7 +2696,9 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           clsFlags,
           parents,
           selfType.getOrElse(Types.NoType),
-          clsPrivateWithin)
+          clsPrivateWithin,
+          clsAnnotations
+        )
         val methodType: MethodOrPoly = conMethodType(cls.typeRef)
         def throwShapeException() = throw new Exception("Shapes of conMethodType and conParamFlags differ.")
         def checkMethodOrPolyShape(checkedMethodType: TypeRepr, clauseIdx: Int): Unit =

library/src/scala/quoted/Quotes.scala

@@ -3880,6 +3880,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
        * @param selfType The self type of the class if it has one
        * @param clsFlags extra flags with which the class symbol should be constructed
        * @param clsPrivateWithin the symbol within which this new class symbol should be private. May be noSymbol
+       * @param clsAnnotations annotations of the class
        * @param conMethodType Function returning MethodOrPoly type representing the type of the constructor.
        * Takes the result type as parameter which must be returned from the innermost MethodOrPoly.
        * PolyType may only represent the first clause of the constructor.
@@ -3903,6 +3904,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         selfType: Option[TypeRepr],
         clsFlags: Flags,
         clsPrivateWithin: Symbol,
+        clsAnnotations: List[Term],
         conMethodType: TypeRepr => MethodOrPoly,
         conFlags: Flags,
         conPrivateWithin: Symbol,

tests/run-macros/newClassAnnotation.check

@@ -0,0 +1,7 @@
+{
+  @JavaAnnot("string in a java annotation") @ScalaAnnotation("string in a scala annotation") class name() extends java.lang.Object
+
+  (new name(): scala.Any)
+}
+class Test_2$package$name$1
+string in a java annotation

tests/run-macros/newClassAnnotation/JavaAnnot.java

@@ -0,0 +1,5 @@
+import java.lang.annotation.*;
+public @Retention(RetentionPolicy.RUNTIME)
+@interface JavaAnnot {
+  public String value();
+}

tests/run-macros/newClassAnnotation/Macro_1.scala

@@ -0,0 +1,55 @@
+//> using options -experimental
+
+import scala.quoted.*
+import scala.annotation.StaticAnnotation
+
+class ScalaAnnotation(value: String) extends StaticAnnotation
+
+inline def makeClass(inline name: String): Any = ${ makeClassExpr('name) }
+private def makeClassExpr(nameExpr: Expr[String])(using Quotes): Expr[Any] = {
+  import quotes.reflect.*
+
+  val name = nameExpr.valueOrAbort
+  def decls(cls: Symbol): List[Symbol] = Nil
+  val conMethodType = (classType: TypeRepr) => MethodType(Nil)((_: MethodType) => Nil, (_: MethodType) => classType)
+
+  val javaAnnotSym = TypeRepr.of[JavaAnnot].typeSymbol
+  val scalaAnnotSym = TypeRepr.of[ScalaAnnotation].typeSymbol
+
+  val javaAnnotationDef = Apply(Select(New(TypeIdent(javaAnnotSym)), javaAnnotSym.primaryConstructor), List(Literal(StringConstant("string in a java annotation"))))
+  val scalaAnnotationDef = Apply(Select(New(TypeIdent(scalaAnnotSym)), scalaAnnotSym.primaryConstructor), List(Literal(StringConstant("string in a scala annotation"))))
+
+  val cls = Symbol.newClass(
+    Symbol.spliceOwner,
+    name,
+    parents = _ => List(TypeRepr.of[Object]),
+    decls,
+    selfType = None,
+    clsFlags = Flags.EmptyFlags,
+    clsPrivateWithin = Symbol.noSymbol,
+    clsAnnotations = List(javaAnnotationDef, scalaAnnotationDef),
+    conMethodType,
+    conFlags = Flags.EmptyFlags,
+    conPrivateWithin = Symbol.noSymbol,
+    conParamFlags = List(List())
+  )
+
+  val clsDef = ClassDef(cls, List(TypeTree.of[Object]), body = Nil)
+  val newCls =
+    Typed(
+      Apply(
+        Select(New(TypeIdent(cls)), cls.primaryConstructor),
+        Nil
+      ),
+      TypeTree.of[Any]
+    )
+
+  val res = Block(List(clsDef), newCls).asExpr
+
+  Expr.ofTuple(res, Expr(res.show))
+
+  // {
+  //   @JavaAnnot("string in a java annotation") @ScalaAnnotation("string in a scala annotation") class name() extends java.lang.Object
+  //   (new name(): scala.Any)
+  // }
+}

tests/run-macros/newClassAnnotation/Test_2.scala

@@ -0,0 +1,7 @@
+//> using options -experimental
+
+@main def Test =
+  val (cls, str) = makeClass("name")
+  println(str)
+  println(cls.getClass)
+  println(cls.getClass.getAnnotation(classOf[JavaAnnot]).value)