New scheme for handling defaults of Java annotations

Previously, we made up default getters that were then recognized by the
backend, this has at least two downsides:
- Creating the default getters requires forcing the info of all the
methods in the annotation class, this might lead to cycles.
- This scheme leaks into Tasty, and therefore becomes part of the Tasty
specification, this is inelegant at best.

In the new scheme, no default getters are created, instead we
special-case the typing of annotation constructors: when an argument for
the annotation constructor is missing, we replace it with a typed
wildcard Ident if the corresponding parameter is known to have a default
value. The Tasty spec and the backend need to be aware of this usage of
wildcard, but that's easier to specify and to implement than default
getters.

Author: smarter

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

@@ -255,16 +255,15 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
         }
       case t: TypeApply if (t.fun.symbol == Predef_classOf) =>
         av.visit(name, t.args.head.tpe.classSymbol.denot.info.toTypeKind(bcodeStore)(innerClasesStore).toASMType)
+      case Ident(nme.WILDCARD) =>
+        // An underscore argument indicates that we want to use the default value for this parameter, so do not emit anything
       case t: tpd.RefTree =>
-        if (t.symbol.denot.owner.isAllOf(Flags.JavaEnumTrait)) {
-          val edesc = innerClasesStore.typeDescriptor(t.tpe.asInstanceOf[bcodeStore.int.Type]) // the class descriptor of the enumeration class.
-          val evalue = t.symbol.name.mangledString // value the actual enumeration value.
-          av.visitEnum(name, edesc, evalue)
-        } else {
-            // println(i"not an enum: ${t.symbol} / ${t.symbol.denot.owner} / ${t.symbol.denot.owner.isTerm} / ${t.symbol.denot.owner.flagsString}")
-            assert(toDenot(t.symbol).name.is(DefaultGetterName),
-              s"${toDenot(t.symbol).name.debugString}") // this should be default getter. do not emit.
-        }
+        assert(t.symbol.denot.owner.isAllOf(Flags.JavaEnumTrait),
+          i"not an enum: $t / ${t.symbol} / ${t.symbol.denot.owner} / ${t.symbol.denot.owner.isTerm} / ${t.symbol.denot.owner.flagsString}")
+
+        val edesc = innerClasesStore.typeDescriptor(t.tpe.asInstanceOf[bcodeStore.int.Type]) // the class descriptor of the enumeration class.
+        val evalue = t.symbol.name.mangledString // value the actual enumeration value.
+        av.visitEnum(name, edesc, evalue)
       case t: SeqLiteral =>
         val arrAnnotV: AnnotationVisitor = av.visitArray(name)
         for (arg <- t.elems) { emitArgument(arrAnnotV, null, arg, bcodeStore)(innerClasesStore) }

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

@@ -635,21 +635,10 @@ class ClassfileParser(
     cook.apply(newType)
   }
 
-  /** Add synthetic constructor(s) and potentially also default getters which
-   *  reflects the fields of the annotation with given `classInfo`.
-   *  Annotations in Scala are assumed to get all their arguments as constructor
+  /** 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.
-   *  Note that default getters have type Nothing. That's OK because we need
-   *  them only to signal that the corresponding parameter is optional.
    */
   def addAnnotationConstructor(classInfo: TempClassInfoType)(implicit ctx: Context): Unit = {
-    def addDefaultGetter(attr: Symbol, n: Int) =
-      ctx.newSymbol(
-        owner = moduleRoot.symbol,
-        name = DefaultGetterName(nme.CONSTRUCTOR, n),
-        flags = attr.flags & Flags.AccessFlags,
-        info = defn.NothingType).entered
-
     val attrs = classInfo.decls.toList.filter(_.isTerm)
     val paramNames = attrs.map(_.name.asTermName)
     val paramTypes = attrs.map(_.info.resultType)
@@ -662,11 +651,6 @@ class ClassfileParser(
         flags = Flags.Synthetic | Flags.JavaDefined | Flags.Method,
         info = mtype
       ).entered
-      for ((attr, i) <- attrs.zipWithIndex)
-        if (attr.hasAnnotation(defn.AnnotationDefaultAnnot)) {
-          constr.setFlag(Flags.DefaultParameterized)
-          addDefaultGetter(attr, i)
-        }
     }
 
     addConstr(paramTypes)

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

@@ -127,8 +127,8 @@ object JavaParsers {
 
     def makeSyntheticParam(count: Int, tpt: Tree): ValDef =
       makeParam(nme.syntheticParamName(count), tpt)
-    def makeParam(name: TermName, tpt: Tree, defaultValue: Tree = EmptyTree): ValDef =
-      ValDef(name, tpt, defaultValue).withMods(Modifiers(Flags.JavaDefined | Flags.Param))
+    def makeParam(name: TermName, tpt: Tree): ValDef =
+      ValDef(name, tpt, EmptyTree).withMods(Modifiers(Flags.JavaDefined | Flags.Param))
 
     def makeConstructor(formals: List[Tree], tparams: List[TypeDef], flags: FlagSet = Flags.JavaDefined): DefDef = {
       val vparams = formals.zipWithIndex.map { case (p, i) => makeSyntheticParam(i + 1, p) }
@@ -768,17 +768,7 @@ object JavaParsers {
       val (statics, body) = typeBody(AT, name, List())
       val constructorParams = body.collect {
         case dd: DefDef =>
-          val hasDefault =
-            dd.mods.annotations.exists {
-              case Apply(Select(New(Select(_, tpnme.AnnotationDefaultATTR)), nme.CONSTRUCTOR), Nil) =>
-                true
-              case _ =>
-                false
-            }
-          // If the annotation has a default value we don't need to parse it, providing
-          // any value at all is enough to typecheck usages of annotations correctly.
-          val defaultParam = if (hasDefault) unimplementedExpr else EmptyTree
-          makeParam(dd.name, dd.tpt, defaultParam)
+          makeParam(dd.name, dd.tpt)
       }
       val constr = DefDef(nme.CONSTRUCTOR,
         List(), List(constructorParams), TypeTree(), EmptyTree).withMods(Modifiers(Flags.JavaDefined))

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

@@ -543,17 +543,39 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           }
 
           def tryDefault(n: Int, args1: List[Arg]): Unit = {
-            val getter =
-              // `methRef.symbol` doesn't exist for structural calls
-              if (methRef.symbol.exists) findDefaultGetter(n + numArgs(normalizedFun))
-              else EmptyTree
-            if (getter.isEmpty) missingArg(n)
-            else {
-              val substParam = addTyped(
-                  treeToArg(spliceMeth(getter.withSpan(normalizedFun.span), normalizedFun)),
-                  formal)
+            val sym = methRef.symbol
+
+            val defaultExpr =
+              if (isJavaAnnotConstr(sym)) {
+                val cinfo = sym.owner.asClass.classInfo
+                val pname = methodType.paramNames(n)
+                val hasDefault = cinfo.member(pname)
+                  .suchThat(d => d.is(Method) && d.hasAnnotation(defn.AnnotationDefaultAnnot)).exists
+
+                // Use `_` as a placeholder for the default value of an
+                // annotation parameter, this will be recognized by the backend.
+                if (hasDefault)
+                  tpd.Underscore(formal)
+                else
+                  EmptyTree
+              } else {
+                val getter =
+                  if (sym.exists) // `sym` doesn't exist for structural calls
+                    findDefaultGetter(n + numArgs(normalizedFun))
+                  else
+                    EmptyTree
+
+                if (!getter.isEmpty)
+                  spliceMeth(getter.withSpan(normalizedFun.span), normalizedFun)
+                else
+                  EmptyTree
+              }
+
+            if (!defaultExpr.isEmpty) {
+              val substParam = addTyped(treeToArg(defaultExpr), formal)
               matchArgs(args1, formals1.mapconserve(substParam), n + 1)
-            }
+            } else
+              missingArg(n)
           }
 
           if (formal.isRepeatedParam)