Fix #6868: Avoid cycles involving Java annotations

Compute the info of synthesized Java annotation constructors lazily,
just like the info of all the other members created by ClassfileParser.

Thanks to noti0na1 for the initial investigation and test case!

Author: smarter

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

@@ -638,42 +638,21 @@ class ClassfileParser(
   /** Annotations in Scala are assumed to get all their arguments as constructor
    *  parameters. For Java annotations we need to fake it by making up the constructor.
    */
-  def addAnnotationConstructor(classInfo: TempClassInfoType)(implicit ctx: Context): Unit = {
-    val attrs = classInfo.decls.toList.filter(_.isTerm)
-    val paramNames = attrs.map(_.name.asTermName)
-    val paramTypes = attrs.map(_.info.resultType)
-
-    def addConstr(ptypes: List[Type]) = {
-      val mtype = MethodType(paramNames, ptypes, classRoot.typeRef)
-      val constr = ctx.newSymbol(
-        owner = classRoot.symbol,
-        name = nme.CONSTRUCTOR,
-        flags = Flags.Synthetic | Flags.JavaDefined | Flags.Method,
-        info = mtype
-      ).entered
-    }
-
-    addConstr(paramTypes)
-
-    // The code below added an extra constructor to annotations where the
-    // last parameter of the constructor is an Array[X] for some X, the
-    // array was replaced by a vararg argument. Unfortunately this breaks
-    // inference when doing:
-    //   @Annot(Array())
-    // The constructor is overloaded so the expected type of `Array()` is
-    // WildcardType, and the type parameter of the Array apply method gets
-    // instantiated to `Nothing` instead of `X`.
-    // I'm leaving this commented out in case we improve inference to make this work.
-    // Note that if this is reenabled then JavaParser will also need to be modified
-    // to add the extra constructor (this was not implemented before).
-    /*
-    if (paramTypes.nonEmpty)
-      paramTypes.last match {
-        case defn.ArrayOf(elemtp) =>
-          addConstr(paramTypes.init :+ defn.RepeatedParamType.appliedTo(elemtp))
-        case _ =>
+  def addAnnotationConstructor(classInfo: TempClassInfoType)(implicit ctx: Context): Unit =
+    ctx.newSymbol(
+      owner = classRoot.symbol,
+      name = nme.CONSTRUCTOR,
+      flags = Flags.Synthetic | Flags.JavaDefined | Flags.Method,
+      info = new AnnotConstructorCompleter(classInfo)
+    ).entered
+
+  class AnnotConstructorCompleter(classInfo: TempClassInfoType) extends LazyType {
+    def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
+      val attrs = classInfo.decls.toList.filter(sym => sym.isTerm && sym != denot.symbol)
+      val paramNames = attrs.map(_.name.asTermName)
+      val paramTypes = attrs.map(_.info.resultType)
+      denot.info = MethodType(paramNames, paramTypes, classRoot.typeRef)
     }
-    */
   }
 
   /** Enter own inner classes in the right scope. It needs the scopes to be set up,

tests/pos-java-interop-separate/i6868/MyJava_1.java

@@ -0,0 +1,15 @@
+public @interface MyJava_1 {
+
+    public String value() default "MyJava";
+
+    public MyClassTypeA typeA();
+
+    public MyClassTypeB typeB() default @MyClassTypeB;
+
+    public enum MyClassTypeA {
+	A, B
+    }
+
+    public @interface MyClassTypeB {}
+}
+

tests/pos-java-interop-separate/i6868/MyScala_2.scala

@@ -0,0 +1,13 @@
+@MyJava_1("MyScala1", typeA = MyJava_1.MyClassTypeA.B)
+object MyScala {
+  def a(mj: MyJava_1): Unit = {
+    println("MyJava")
+  }
+
+  @MyJava_1(typeA = MyJava_1.MyClassTypeA.A)
+  def b(): Int = 1
+
+  @MyJava_1(value = "MyScala2", typeA = MyJava_1.MyClassTypeA.B)
+  def c(): Int = 2
+}
+