Fix #7212: Generate varargs bridge with the right flags on @VarArgs annotation

Author: TheElectronWill

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

@@ -15,6 +15,7 @@ import Denotations._, SymDenotations._
 import dotty.tools.dotc.ast.tpd
 import TypeErasure.erasure
 import DenotTransformers._
+import dotty.tools.backend.jvm.DottyBackendInterface.requiredClass
 
 object ElimRepeated {
   val name: String = "elimRepeated"
@@ -47,6 +48,8 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
 
   private def overridesJava(sym: Symbol)(implicit ctx: Context) = sym.allOverriddenSymbols.exists(_.is(JavaDefined))
 
+  private def hasVargsAnnotation(sym: Symbol)(using ctx: Context) = sym.hasAnnotation(requiredClass[scala.annotation.varargs])
+
   private def elimRepeated(tp: Type)(implicit ctx: Context): Type = tp.stripTypeVar match {
     case tp @ MethodTpe(paramNames, paramTypes, resultType) =>
       val resultType1 = elimRepeated(resultType)
@@ -109,35 +112,41 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
   override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree =
     transformTypeOfTree(tree)
 
-  /** If method overrides a Java varargs method, add a varargs bridge.
-   *  Also transform trees inside method annotation
+  /** If method overrides a Java varargs method or is annotated with @varargs, add a varargs bridge.
+   *  Also transform trees inside method annotation.
    */
   override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree =
     ctx.atPhase(thisPhase) {
-      if (tree.symbol.info.isVarArgsMethod && overridesJava(tree.symbol))
-        addVarArgsBridge(tree)
+      val isOverride = overridesJava(tree.symbol)
+      val hasAnnotation = hasVargsAnnotation(tree.symbol)
+      if tree.symbol.info.isVarArgsMethod && (isOverride || hasAnnotation) then
+        // java varargs can be overriden by synthetic methods with an Array param,
+        // but non-overrides need the varargs bytecode flag and cannot be synthetic
+        // otherwise javac refuses to call them.
+        addVarArgsBridge(tree, if hasAnnotation then JavaVarargs else Artifact)
       else
         tree
     }
 
   /** Add a Java varargs bridge
-   *  @param  ddef  the original method definition which is assumed to override
-   *                a Java varargs method JM up to this phase.
-   *  @return  a thicket consisting of `ddef` and a varargs bridge method
-   *           which overrides the Java varargs method JM from this phase on
-   *           and forwards to `ddef`.
+   *  @param  ddef   the original method definition which is assumed to override
+   *                 a Java varargs method JM up to this phase.
+   *  @param addFlag the flag to add to the method definition
+
+   *  @return a thicket consisting of `ddef` and a varargs bridge method
+   *          which forwards java varargs to `ddef`. It retains all the
+   *          flags of `ddef` except `Private`.
    *
    *  A bridge is necessary because the following hold
    *    - the varargs in `ddef` will change from `RepeatedParam[T]` to `Seq[T]` after this phase
-   *    - _but_ the callers of `ddef` expect its varargs to be changed to `Array[? <: T]`, since it overrides
-   *      a Java varargs
+   *    - _but_ the callers of `ddef` expect its varargs to be changed to `Array[? <: T]`
    *  The solution is to add a "bridge" method that converts its argument from `Array[? <: T]` to `Seq[T]` and
    *  forwards it to `ddef`.
    */
-  private def addVarArgsBridge(ddef: DefDef)(implicit ctx: Context): Tree = {
+  private def addVarArgsBridge(ddef: DefDef, addFlag: Flag)(implicit ctx: Context): Tree = {
     val original = ddef.symbol.asTerm
     val bridge = original.copy(
-      flags = ddef.symbol.flags &~ Private | Artifact,
+      flags = (ddef.symbol.flags | addFlag) &~ Private,
       info = toJavaVarArgs(ddef.symbol.info)).enteredAfter(thisPhase).asTerm
     val bridgeDef = polyDefDef(bridge, trefs => vrefss => {
       val (vrefs :+ varArgRef) :: vrefss1 = vrefss