Fix method calls on a Java annotation

In the compiler we pretend that Java annotations are classes, but
they're really interfaces from the JVM point of view, so we need to
treat them as such in the backend when calling a method on them,
otherwise we'll emit invalid bytecode.

Needed to get tests/run/i2760 to pass after the backend changes in this
PR.

Author: smarter

compiler/src/dotty/tools/backend/jvm/BackendInterface.scala

@@ -460,10 +460,11 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     /** Does this symbol actually correspond to an interface that will be emitted?
      *  In the backend, this should be preferred over `isInterface` because it
      *  also returns true for the symbols of the fake companion objects we
-     *  create for Java-defined classes.
+     *  create for Java-defined classes as well as for Java annotations
+     *  which we represent as classes.
      */
     final def isEmittedInterface: Boolean = isInterface ||
-      isJavaDefined && isModuleClass && companionClass.isInterface
+      isJavaDefined && (isAnnotation || isModuleClass && companionClass.isInterface)
 
     // tests
     def isClass: Boolean
@@ -509,6 +510,7 @@ abstract class BackendInterface extends BackendInterfaceDefinitions {
     def shouldEmitForwarders: Boolean
     def isJavaDefaultMethod: Boolean
     def isClassConstructor: Boolean
+    def isAnnotation: Boolean
     def isSerializable: Boolean
     def isEnum: Boolean
 

compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala

@@ -702,6 +702,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def isEnum = sym.is(Flags.Enum)
 
     def isClassConstructor: Boolean = toDenot(sym).isClassConstructor
+    def isAnnotation: Boolean = toDenot(sym).isAnnotation
     def isSerializable: Boolean = toDenot(sym).isSerializable
 
     /**

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

@@ -787,6 +787,10 @@ object SymDenotations {
      */
     def derivesFrom(base: Symbol)(implicit ctx: Context): Boolean = false
 
+    /** Is this a Scala or Java annotation ? */
+    def isAnnotation(implicit ctx: Context): Boolean =
+      isClass && derivesFrom(defn.AnnotationClass)
+
     /** Is this symbol a class that extends `java.io.Serializable` ? */
     def isSerializable(implicit ctx: Context): Boolean =
       isClass && derivesFrom(defn.JavaSerializableClass)

compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala

@@ -123,9 +123,6 @@ object Scala3:
     def isSyntheticWithIdent(using Context): Boolean =
       sym.is(Synthetic) && !sym.isAnonymous && !sym.name.isEmptyNumbered
 
-    def isAnnotation(using Context): Boolean =
-      sym.derivesFrom(defn.AnnotationClass)
-
   // end SymbolOps
 
   object LocalSymbol: