Represent Java annotations as interfaces so they can be extended

Previously we treated Java annotations as if they were classes, like Scala
annotations. For example, given

    @interface Ann { int foo(); }

we pretended it was defined as:

    abstract class Ann(foo: Int) extends java.lang.annotation.Annotation { def foo(): Int }

We take advantage of this to type annotation trees as if they were
new calls, for example `@Ann(1)` is typed as `new Ann(1)`.

Pretending that annotations are classes is fine most of the time and matches
what Scala 2.12 did, but it's problematic because the JVM treats annotations as
interfaces. In practice this was only an issue with code trying to extend
Java annotations, which would either be rejected at compile-time or miscompiled
before this commit.

This commit switches our representation of annotations to be trait-based
instead:

    trait Ann(foo: Int) extends java.lang.annotation.Annotation { def foo(): Int }

Classes are then free to extend annotations using the same pattern as in Scala 2.13:

    class Foo extends Ann {val annotationType = classOf[Retention]; def foo(): Int = 1}

Notice that we still pretend these traits have constructors, this lets us type
annotation trees in much the same way as before, and crucially it means that
macros that depended on the exact tree shape of annotation trees can continue to
work, as demonstrated by the annot-java-tree test extracted from wartremover.
To prevent miscompilation issues, we disallow passing arguments to the
annotation constructor in `extends` clause.

This change is not fully backwards source compatible: this is illustrated
by the diffs in tests/run/repeatable/Test_1.scala:

    -@FirstLevel_0(Array(Plain_0(4), Plain_0(5)))
    +@FirstLevel_0(Array(new Plain_0(4), new Plain_0(5)))

Here, FirstLevel_0 takes an array of `Plain_0` annotations as arguments, and in
previous releases of Scala 3 we could put `Plain_0(4)` in this array without
`new`. This is because the compiler generates a "constructor proxy" apply method
for classes, but this no longer works since `Plain_0` is now a trait. While we
could potentially tweak the constructor proxy logic to handle this case, it
seems simpler to require a `new` here, both because Scala 2 does it too and
because it ensures that user code that inspects the annotation tree does not
have to deal with constructor proxies.

The treatment of default arguments to annotations stays unchanged from 85cd1cf.

Fixes #5690. Fixes #12840. Fixes #14199.

Author: smarter

compiler/src/dotty/tools/dotc/core/classfile/ClassfileConstants.scala

@@ -353,18 +353,15 @@ object ClassfileConstants {
       if (jflag == 0) base else base | translateFlag(jflag)
 
     private def translateFlags(jflags: Int, baseFlags: FlagSet): FlagSet = {
-      val nflags =
-        if ((jflags & JAVA_ACC_ANNOTATION) == 0) jflags
-        else jflags & ~(JAVA_ACC_ABSTRACT | JAVA_ACC_INTERFACE) // annotations are neither abstract nor interfaces
       var res: FlagSet = baseFlags | JavaDefined
-      res = addFlag(res, nflags & JAVA_ACC_PRIVATE)
-      res = addFlag(res, nflags & JAVA_ACC_PROTECTED)
-      res = addFlag(res, nflags & JAVA_ACC_FINAL)
-      res = addFlag(res, nflags & JAVA_ACC_SYNTHETIC)
-      res = addFlag(res, nflags & JAVA_ACC_STATIC)
-      res = addFlag(res, nflags & JAVA_ACC_ENUM)
-      res = addFlag(res, nflags & JAVA_ACC_ABSTRACT)
-      res = addFlag(res, nflags & JAVA_ACC_INTERFACE)
+      res = addFlag(res, jflags & JAVA_ACC_PRIVATE)
+      res = addFlag(res, jflags & JAVA_ACC_PROTECTED)
+      res = addFlag(res, jflags & JAVA_ACC_FINAL)
+      res = addFlag(res, jflags & JAVA_ACC_SYNTHETIC)
+      res = addFlag(res, jflags & JAVA_ACC_STATIC)
+      res = addFlag(res, jflags & JAVA_ACC_ENUM)
+      res = addFlag(res, jflags & JAVA_ACC_ABSTRACT)
+      res = addFlag(res, jflags & JAVA_ACC_INTERFACE)
       res
     }
 

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -165,11 +165,7 @@ class ClassfileParser(
      *  Updates the read pointer of 'in'. */
     def parseParents: List[Type] = {
       val superType =
-        if (isAnnotation) {
-          in.nextChar
-          defn.ObjectType
-        }
-        else if (classRoot.symbol == defn.ComparableClass ||
+        if (classRoot.symbol == defn.ComparableClass ||
                  classRoot.symbol == defn.JavaCloneableClass ||
                  classRoot.symbol == defn.JavaSerializableClass) {
           // Treat these interfaces as universal traits
@@ -844,7 +840,7 @@ class ClassfileParser(
 
   class AnnotConstructorCompleter(classInfo: TempClassInfoType) extends LazyType {
     def complete(denot: SymDenotation)(using Context): Unit = {
-      val attrs = classInfo.decls.toList.filter(sym => sym.isTerm && sym != denot.symbol)
+      val attrs = classInfo.decls.toList.filter(sym => sym.isTerm && sym != denot.symbol && sym.name != nme.CONSTRUCTOR)
       val paramNames = attrs.map(_.name.asTermName)
       val paramTypes = attrs.map(_.info.resultType)
       denot.info = MethodType(paramNames, paramTypes, classRoot.typeRef)

compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala

@@ -876,7 +876,7 @@ object JavaParsers {
         List(constructorParams), TypeTree(), EmptyTree).withMods(Modifiers(Flags.JavaDefined))
       val templ = makeTemplate(annotationParents, constr :: body, List(), true)
       val annot = atSpan(start, nameOffset) {
-        TypeDef(name, templ).withMods(mods | Flags.Abstract)
+        TypeDef(name, templ).withMods(mods | Flags.JavaInterface)
       }
       addCompanionObject(statics, annot)
     }

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -1110,6 +1110,8 @@ trait Checking {
   def checkParentCall(call: Tree, caller: ClassSymbol)(using Context): Unit =
     if (!ctx.isAfterTyper) {
       val called = call.tpe.classSymbol
+      if (called.derivesFrom(defn.JavaAnnotationClass))
+        report.error(i"${called.name} must appear without any argument to be a valid class parent because it is a Java annotation", call.srcPos)
       if (caller.is(Trait))
         report.error(i"$caller may not call constructor of $called", call.srcPos)
       else if (called.is(Trait) && !caller.mixins.contains(called))

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2595,6 +2595,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    */
   def ensureConstrCall(cls: ClassSymbol, parent: Tree, psym: Symbol)(using Context): Tree =
     if parent.isType && !cls.is(Trait) && !cls.is(JavaDefined) && psym.isClass
+        // Annotations are represented as traits with constructors, but should
+        // never be called as such outside of annotation trees.
+        && !psym.derivesFrom(defn.JavaAnnotationClass)
         && (!psym.is(Trait)
             || psym.primaryConstructor.info.takesParams && !cls.superClass.isSubClass(psym))
     then typed(untpd.New(untpd.TypedSplice(parent), Nil))

tests/pending/neg/i5690.scala renamed to tests/neg/i5690.scala

@@ -0,0 +1,3 @@
+public @interface Ann {
+  int value();
+}

tests/neg/java-ann-super-class/Ann.java

@@ -0,0 +1,9 @@
+class Bar extends Ann(1) { // error
+  def value = 1
+  def annotationType = classOf[Ann]
+}
+
+def test =
+  // Typer errors
+  new Ann // error
+  new Ann(1) {} // error

tests/neg/java-ann-super-class/Test.scala

@@ -0,0 +1,3 @@
+public @interface Ann {
+  int value();
+}

tests/neg/java-ann-super-class2/Ann.java

@@ -0,0 +1,3 @@
+def test =
+  // Posttyper errors
+  new Ann(1) // error