Java annotations should not extend scala.annotation.{ClassfileAnnotation,Annotation}

This compiler fiction isn't necessary to handle them as annotations and could
lead to runtime crashes when upcasting an annotation value.

Author: smarter

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

@@ -968,8 +968,8 @@ class Definitions {
     @tu lazy val Caps_unsafeBoxFunArg: Symbol = CapsUnsafeModule.requiredMethod("unsafeBoxFunArg")
 
   // Annotation base classes
+  @tu lazy val JavaAnnotationClass: ClassSymbol = requiredClass("java.lang.annotation.Annotation")
   @tu lazy val AnnotationClass: ClassSymbol = requiredClass("scala.annotation.Annotation")
-  @tu lazy val ClassfileAnnotationClass: ClassSymbol = requiredClass("scala.annotation.ClassfileAnnotation")
   @tu lazy val StaticAnnotationClass: ClassSymbol = requiredClass("scala.annotation.StaticAnnotation")
   @tu lazy val RefiningAnnotationClass: ClassSymbol = requiredClass("scala.annotation.RefiningAnnotation")
 

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

@@ -243,7 +243,6 @@ object StdNames {
     final val ToString: N             = "ToString"
     final val Xor: N                  = "^"
 
-    final val ClassfileAnnotation: N = "ClassfileAnnotation"
     final val ClassManifest: N       = "ClassManifest"
     final val Enum: N                = "Enum"
     final val Group: N               = "Group"

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

@@ -808,7 +808,7 @@ object SymDenotations {
 
     /** Is this a Scala or Java annotation ? */
     def isAnnotation(using Context): Boolean =
-      isClass && derivesFrom(defn.AnnotationClass)
+      isClass && (derivesFrom(defn.AnnotationClass) || derivesFrom(defn.JavaAnnotationClass))
 
     /** Is this symbol a class that extends `java.io.Serializable` ? */
     def isSerializable(using Context): Boolean =

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

@@ -167,7 +167,7 @@ class ClassfileParser(
       val superType =
         if (isAnnotation) {
           in.nextChar
-          defn.AnnotationClass.typeRef
+          defn.ObjectType
         }
         else if (classRoot.symbol == defn.ComparableClass ||
                  classRoot.symbol == defn.JavaCloneableClass ||
@@ -186,7 +186,6 @@ class ClassfileParser(
         // Consequently, no best implicit for the "Integral" evidence parameter of "range"
         // is found. Previously, this worked because of weak conformance, which has been dropped.
 
-      if (isAnnotation) ifaces = defn.ClassfileAnnotationClass.typeRef :: ifaces
       superType :: ifaces
     }
 

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

@@ -858,10 +858,9 @@ object JavaParsers {
       }
       (statics.toList, members.toList)
     }
-    def annotationParents: List[Select] = List(
-      scalaAnnotationDot(tpnme.Annotation),
-      Select(javaLangDot(nme.annotation), tpnme.Annotation),
-      scalaAnnotationDot(tpnme.ClassfileAnnotation)
+    def annotationParents: List[Tree] = List(
+      javaLangObject(),
+      Select(javaLangDot(nme.annotation), tpnme.Annotation)
     )
     def annotationDecl(start: Offset, mods: Modifiers): List[Tree] = {
       accept(AT)

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

@@ -10,6 +10,7 @@ import Symbols.defn
 import Constants._
 import Types._
 import Decorators._
+import Flags._
 
 import scala.collection.mutable
 
@@ -33,7 +34,7 @@ class RepeatableAnnotations extends MiniPhase:
     val annsByType = stableGroupBy(annotations, _.symbol)
     annsByType.flatMap {
       case (_, a :: Nil) => a :: Nil
-      case (sym, anns) if sym.derivesFrom(defn.ClassfileAnnotationClass) =>
+      case (sym, anns) if sym.is(JavaDefined) =>
         sym.getAnnotation(defn.JavaRepeatableAnnot).flatMap(_.argumentConstant(0)) match
           case Some(Constant(containerTpe: Type)) =>
             val clashingAnns = annsByType.getOrElse(containerTpe.classSymbol, Nil)

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

@@ -547,7 +547,7 @@ trait Applications extends Compatibility {
 
     /** Is `sym` a constructor of a Java-defined annotation? */
     def isJavaAnnotConstr(sym: Symbol): Boolean =
-      sym.is(JavaDefined) && sym.isConstructor && sym.owner.derivesFrom(defn.AnnotationClass)
+      sym.is(JavaDefined) && sym.isConstructor && sym.owner.derivesFrom(defn.JavaAnnotationClass)
 
     /** Match re-ordered arguments against formal parameters
      *  @param n   The position of the first parameter in formals in `methType`.

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

@@ -1619,7 +1619,7 @@ class Namer { typer: Typer =>
     typedAhead(tree, typer.typedExpr(_, pt))
 
   def typedAheadAnnotation(tree: Tree)(using Context): tpd.Tree =
-    typedAheadExpr(tree, defn.AnnotationClass.typeRef)
+    typedAheadExpr(tree, defn.AnnotationClass.typeRef | defn.JavaAnnotationClass.typeRef)
 
   def typedAheadAnnotationClass(tree: Tree)(using Context): Symbol = tree match {
     case Apply(fn, _) => typedAheadAnnotationClass(fn)

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

@@ -2259,7 +2259,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   def typedAnnotation(annot: untpd.Tree)(using Context): Tree =
-    checkAnnotArgs(typed(annot, defn.AnnotationClass.typeRef))
+    checkAnnotArgs(typed(annot, defn.AnnotationClass.typeRef | defn.JavaAnnotationClass.typeRef))
 
   def registerNowarn(tree: Tree, mdef: untpd.Tree)(using Context): Unit =
     val annot = Annotations.Annotation(tree)
@@ -2669,7 +2669,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   end typedPackageDef
 
   def typedAnnotated(tree: untpd.Annotated, pt: Type)(using Context): Tree = {
-    val annot1 = typedExpr(tree.annot, defn.AnnotationClass.typeRef)
+    val annot1 = typedExpr(tree.annot, defn.AnnotationClass.typeRef | defn.JavaAnnotationClass.typeRef)
     val annotCls = Annotations.annotClass(annot1)
     if annotCls == defn.NowarnAnnot then
       registerNowarn(annot1, tree)

tests/neg/java-ann-extends-separate/Ann_1.java

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

tests/neg/java-ann-extends-separate/Test_2.scala

@@ -0,0 +1,2 @@
+def test(x: Ann_1) =
+  val y: scala.annotation.Annotation = x // error

tests/neg/java-ann-extends/Ann.java

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

tests/neg/java-ann-extends/Test.scala

@@ -0,0 +1,2 @@
+def test(x: Ann) =
+  val y: scala.annotation.Annotation = x // error