Parse varargs in a more direct manner

In bytecode, vararg parameters are encoded as arrays with the
ACC_VARARGS flag set on the method. Previously we first parsed them as
arrays then translated the array into a repeated param. With this commit
we directly parse them as array, this isn't really any simpler since we
need to keep track of the fact that we're in a varargs method, but it
will become useful in the next commit where we start treating arrays
differently from varargs (`T[]` will still be translated as `Array[T &
Object]` whereas `T...` will be translated as `T*` and handled specially
in ElimRepeated to preserve soundness).

Similarly for joint compilation, we now directly desugar varargs as
`RepeatedParam[T]` instead of `Array[T] @Repeated`, this doesn't change
anything currently because:
- When giving a type to the method, we call `annotatedToRepeated` on
  each parameter type
- `typedAppliedTypeTree` takes care of adding `& Object` for both
  `Array[T]` and `RepeatedParam[T]` coming From Java (this is what
  the next commit will change).

Author: smarter

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1684,10 +1684,12 @@ object desugar {
         Apply(Select(Apply(scalaDot(nme.StringContext), strs), id).withSpan(tree.span), elems)
       case PostfixOp(t, op) =>
         if ((ctx.mode is Mode.Type) && !isBackquoted(op) && op.name == tpnme.raw.STAR) {
-          val seqType = if (ctx.compilationUnit.isJava) defn.ArrayType else defn.SeqType
-          Annotated(
-            AppliedTypeTree(ref(seqType), t),
-            New(ref(defn.RepeatedAnnot.typeRef), Nil :: Nil))
+          if ctx.compilationUnit.isJava then
+            AppliedTypeTree(ref(defn.RepeatedParamType), t)
+          else
+            Annotated(
+              AppliedTypeTree(ref(defn.SeqType), t),
+              New(ref(defn.RepeatedAnnot.typeRef), Nil :: Nil))
         }
         else {
           assert(ctx.mode.isExpr || ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), ctx.mode)

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

@@ -280,15 +280,13 @@ class ClassfileParser(
           addConstructorTypeParams(denot)
         }
 
-        denot.info = pool.getType(in.nextChar)
+        val isVarargs = denot.is(Flags.Method) && (jflags & JAVA_ACC_VARARGS) != 0
+        denot.info = pool.getType(in.nextChar, isVarargs)
         if (isEnum) denot.info = ConstantType(Constant(sym))
         if (isConstructor) normalizeConstructorParams()
-        denot.info = translateTempPoly(parseAttributes(sym, denot.info))
+        denot.info = translateTempPoly(parseAttributes(sym, denot.info, isVarargs))
         if (isConstructor) normalizeConstructorInfo()
 
-        if (denot.is(Flags.Method) && (jflags & JAVA_ACC_VARARGS) != 0)
-          denot.info = arrayToRepeated(denot.info)
-
         if (ctx.explicitNulls) denot.info = JavaNullInterop.nullifyMember(denot.symbol, denot.info, isEnum)
 
         // seal java enums
@@ -324,7 +322,7 @@ class ClassfileParser(
       case BOOL_TAG   => defn.BooleanType
     }
 
-  private def sigToType(sig: SimpleName, owner: Symbol = null)(using Context): Type = {
+  private def sigToType(sig: SimpleName, owner: Symbol = null, isVarargs: Boolean = false)(using Context): Type = {
     var index = 0
     val end = sig.length
     def accept(ch: Char): Unit = {
@@ -395,13 +393,41 @@ class ClassfileParser(
           val elemtp = sig2type(tparams, skiptvs)
           defn.ArrayOf(elemtp.translateJavaArrayElementType)
         case '(' =>
-          // we need a method symbol. given in line 486 by calling getType(methodSym, ..)
+          def isMethodEnd(i: Int) = sig(i) == ')'
+          def isArray(i: Int) = sig(i) == '['
+
+          /** Is this a repeated parameter type?
+           *  This is true if we're in a vararg method and this is the last parameter.
+           */
+          def isRepeatedParam(i: Int): Boolean =
+            if !isVarargs then return false
+            var cur = i
+            // Repeated parameters are represented as arrays
+            if !isArray(cur) then return false
+            // Handle nested arrays: int[]...
+            while isArray(cur) do
+              cur += 1
+            // Simple check to see if we're the last parameter: there should be no
+            // array in the signature until the method end.
+            while !isMethodEnd(cur) do
+              if isArray(cur) then return false
+              cur += 1
+            true
+          end isRepeatedParam
+
           val paramtypes = new ListBuffer[Type]()
           var paramnames = new ListBuffer[TermName]()
-          while (sig(index) != ')') {
+          while !isMethodEnd(index) do
             paramnames += nme.syntheticParamName(paramtypes.length)
-            paramtypes += objToAny(sig2type(tparams, skiptvs))
-          }
+            paramtypes += {
+              if isRepeatedParam(index) then
+                index += 1
+                val elemType = sig2type(tparams, skiptvs)
+                defn.RepeatedParamType.appliedTo(elemType.translateJavaArrayElementType)
+              else
+                objToAny(sig2type(tparams, skiptvs))
+            }
+
           index += 1
           val restype = sig2type(tparams, skiptvs)
           JavaMethodType(paramnames.toList, paramtypes.toList, restype)
@@ -574,7 +600,7 @@ class ClassfileParser(
       None // ignore malformed annotations
   }
 
-  def parseAttributes(sym: Symbol, symtype: Type)(using Context): Type = {
+  def parseAttributes(sym: Symbol, symtype: Type, isVarargs: Boolean = false)(using Context): Type = {
     var newType = symtype
 
     def parseAttribute(): Unit = {
@@ -584,7 +610,7 @@ class ClassfileParser(
       attrName match {
         case tpnme.SignatureATTR =>
           val sig = pool.getExternalName(in.nextChar)
-          newType = sigToType(sig, sym)
+          newType = sigToType(sig, sym, isVarargs)
           if (ctx.debug && ctx.verbose)
             println("" + sym + "; signature = " + sig + " type = " + newType)
         case tpnme.SyntheticATTR =>
@@ -1103,8 +1129,8 @@ class ClassfileParser(
       c
     }
 
-    def getType(index: Int)(using Context): Type =
-      sigToType(getExternalName(index))
+    def getType(index: Int, isVarargs: Boolean = false)(using Context): Type =
+      sigToType(getExternalName(index), isVarargs = isVarargs)
 
     def getSuperClass(index: Int)(using Context): Symbol = {
       assert(index != 0, "attempt to parse java.lang.Object from classfile")

compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -59,21 +59,6 @@ object Scala2Unpickler {
     denot.info = PolyType.fromParams(denot.owner.typeParams, denot.info)
   }
 
-  /** Convert array parameters denoting a repeated parameter of a Java method
-   *  to `RepeatedParamClass` types.
-   */
-  def arrayToRepeated(tp: Type)(using Context): Type = tp match {
-    case tp: MethodType =>
-      val lastArg = tp.paramInfos.last
-      assert(lastArg isRef defn.ArrayClass)
-      tp.derivedLambdaType(
-        tp.paramNames,
-        tp.paramInfos.init :+ lastArg.translateParameterized(defn.ArrayClass, defn.RepeatedParamClass),
-        tp.resultType)
-    case tp: PolyType =>
-      tp.derivedLambdaType(tp.paramNames, tp.paramInfos, arrayToRepeated(tp.resultType))
-  }
-
   def ensureConstructor(cls: ClassSymbol, scope: Scope)(using Context): Unit = {
     if (scope.lookup(nme.CONSTRUCTOR) == NoSymbol) {
       val constr = newDefaultConstructor(cls)