Fix #9492: Avoid forcing nested annotation

Java allows annotations inside arrays inside annotations, when parsing
the outer annotation, we need to produce an untyped tree for the array
and therefore the nested annotations. Previously this was done using
`Annotation#tree` which actually produces a typed tree, this works since
typed trees can be used as untyped tree but it requires forcing the
content of the nested annotation which can lead to cycles.

Instead, we now use a dedicated subclass of Annotation with an extra
`untpdTree` method we use for the purpose of generating a tree for the
nested annotation without forcing anything.

Author: smarter

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

@@ -163,12 +163,6 @@ object Annotations {
         protected var myTree: Tree | (Context ?=> Tree) = (using ctx) => treeFn(using ctx)
       }
 
-    def deferred(atp: Type, args: List[Tree])(using Context): Annotation =
-      deferred(atp.classSymbol)(New(atp, args))
-
-    def deferredResolve(atp: Type, args: List[ast.untpd.Tree])(using Context): Annotation =
-      deferred(atp.classSymbol)(ast.untpd.resolveConstructor(atp, args))
-
     /** Extractor for child annotations */
     object Child {
 

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

@@ -555,14 +555,24 @@ class ClassfileParser(
           Some(untpd.JavaSeqLiteral(elems, TypeTree()))
         }
       case ANNOTATION_TAG =>
-        parseAnnotation(index, skip) map (_.tree)
+        parseAnnotation(index, skip).map(_.untpdTree)
     }
   }
 
+  class ClassfileAnnotation(annotClass: Symbol, annotType: Type, args: List[untpd.Tree]) extends LazyAnnotation {
+    protected var mySym: Symbol | (Context ?=> Symbol) = annotClass
+
+    protected var myTree: Tree | (Context ?=> Tree) =
+      (using ctx: Context) => untpd.resolveConstructor(annotType, args)
+
+    def untpdTree(using Context): untpd.Tree =
+      untpd.New(untpd.TypeTree(annotType), List(args))
+  }
+
   /** Parse and return a single annotation.  If it is malformed,
    *  return None.
    */
-  def parseAnnotation(attrNameIndex: Char, skip: Boolean = false)(using Context): Option[Annotation] = try {
+  def parseAnnotation(attrNameIndex: Char, skip: Boolean = false)(using Context): Option[ClassfileAnnotation] = try {
     val attrType = pool.getType(attrNameIndex)
     attrType match
       case tp: TypeRef =>
@@ -584,7 +594,7 @@ class ClassfileParser(
       }
     }
     if (hasError || skip) None
-    else Some(Annotation.deferredResolve(attrType, argbuf.toList))
+    else Some(ClassfileAnnotation(attrType.classSymbol, attrType, argbuf.toList))
   }
   catch {
     case f: FatalError => throw f // don't eat fatal errors, they mean a class was not found

tests/pos-java-interop-separate/i9492/A_1.java

@@ -0,0 +1,15 @@
+import java.lang.annotation.*;
+
+@interface BaseClassAnn {
+    Type[] value();
+    @interface Type {
+        Class<?> value();
+    }
+}
+
+@BaseClassAnn({
+    @BaseClassAnn.Type(value=A_1.class)
+})
+abstract class BaseClass {}
+
+public class A_1 extends BaseClass {}

tests/pos-java-interop-separate/i9492/B_2.scala

@@ -0,0 +1,3 @@
+object Test {
+  def oops: A_1 = ???
+}