Adress comments

Author: TheElectronWill

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

@@ -829,6 +829,7 @@ class Definitions {
   @tu lazy val FunctionalInterfaceAnnot: ClassSymbol = ctx.requiredClass("java.lang.FunctionalInterface")
   @tu lazy val InfixAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.infix")
   @tu lazy val AlphaAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.alpha")
+  @tu lazy val VarargsAnnot: ClassSymbol = ctx.requiredClass("scala.annotation.varargs")
 
   // A list of annotations that are commonly used to indicate that a field/method argument or return
   // type is not null. These annotations are used by the nullification logic in JavaNullInterop to

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

@@ -26,9 +26,6 @@ object ElimRepeated {
 class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
   import ast.tpd._
 
-  private val varargsAnnot = new CtxLazy(
-    summon[Context].requiredClass("scala.annotation.varargs"))
-
   override def phaseName: String = ElimRepeated.name
 
   override def changesMembers: Boolean = true // the phase adds vararg bridges
@@ -49,7 +46,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
 
   private def overridesJava(sym: Symbol)(using Context) = sym.allOverriddenSymbols.exists(_.is(JavaDefined))
 
-  private def hasVargsAnnotation(sym: Symbol)(using ctx: Context) = sym.hasAnnotation(varargsAnnot())
+  private def hasVargsAnnotation(sym: Symbol)(using ctx: Context) = sym.hasAnnotation(defn.VarargsAnnot)
 
   /** Eliminate repeated parameters from method types. */
   private def elimRepeated(tp: Type)(using Context): Type = tp.stripTypeVar match
@@ -120,17 +117,15 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
       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
+        // 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)
+        addVarArgsBridge(tree, isOverride)
       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.
+   *  @param  ddef   the original method definition
    *  @param addFlag the flag to add to the method symbol
 
    *  @return a thicket consisting of `ddef` and a varargs bridge method
@@ -143,10 +138,12 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
    *  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, addFlag: Flag)(using Context): Tree =
+  private def addVarArgsBridge(ddef: DefDef, synthetic: Boolean)(using Context): Tree =
     val original = ddef.symbol.asTerm
+    // For simplicity we always set the varargs flag
+    val flags = ddef.symbol.flags | JavaVarargs &~ Private
     val bridge = original.copy(
-        flags = (ddef.symbol.flags | addFlag) &~ Private,
+        flags = if synthetic then flags | Artifact else flags,
         info = toJavaVarArgs(ddef.symbol.info)
       ).enteredAfter(thisPhase).asTerm
 

tests/pos-java-interop/i7212/C.scala

@@ -0,0 +1,9 @@
+public class Test {
+    public static void main(String[] args) {
+        C c = new C();
+        c.vargs("single");
+        c.vargs("a", "b");
+        c.vargs(new String[]{"a", "b"});
+        c.vargsFromScala();
+    }
+}

tests/pos-java-interop/i7212/UseFromJava.java

@@ -0,0 +1,12 @@
+import scala.annotation._
+
+class C {
+  @varargs
+  def vargs(args: String*): Unit = println(args)
+
+  def vargsFromScala(): Unit =
+    vargs("single")
+    vargs("a", "b")
+    vargs(Seq("a", "b"): _*)
+
+}