Rename underlyingIfRepeated(isJava) to translateFromRepeated(toArray)

The previous name was slightly misleading: we can pass Array sequence arguments
to Scala methods and Seq sequence argument to Java methods, so we may
want to translate a repeated parameter type to either an Array or a Seq
irrespective of what it erases to (we don't right now but we will in
the next commit).

Author: smarter

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

@@ -388,16 +388,16 @@ class TypeApplications(val self: Type) extends AnyVal {
       else self
   }
 
-  /** If this is repeated parameter type, its underlying Seq type,
-   *  or, if isJava is true, Array type, else the type itself.
+  /** If this is a repeated parameter `*T`, translate it to either `Seq[T]` or
+   *  `Array[? <: T]` depending on the value of `toArray`, keep other types as
+   *  they are.
    */
-  def underlyingIfRepeated(isJava: Boolean)(implicit ctx: Context): Type =
-    if (self.isRepeatedParam) {
-      val seqClass = if (isJava) defn.ArrayClass else defn.SeqClass
-      // If `isJava` is set, then we want to turn `RepeatedParam[T]` into `Array[? <: T]`,
-      // since arrays aren't covariant until after erasure. See `tests/pos/i5140`.
-      translateParameterized(defn.RepeatedParamClass, seqClass, wildcardArg = isJava)
-    }
+  def translateFromRepeated(toArray: Boolean)(using Context): Type =
+    if self.isRepeatedParam then
+      val seqClass = if (toArray) defn.ArrayClass else defn.SeqClass
+      // We want `Array[? <: T]` because arrays aren't covariant until after
+      // erasure. See `tests/pos/i5140`.
+      translateParameterized(defn.RepeatedParamClass, seqClass, wildcardArg = toArray)
     else self
 
   /** If this is an encoding of a (partially) applied type, return its arguments,

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

@@ -155,7 +155,7 @@ object TypeErasure {
       case etp => etp
 
   def sigName(tp: Type, isJava: Boolean)(implicit ctx: Context): TypeName = {
-    val normTp = tp.underlyingIfRepeated(isJava)
+    val normTp = tp.translateFromRepeated(toArray = isJava)
     val erase = erasureFn(isJava, semiEraseVCs = false, isConstructor = false, wildcardOK = true)
     erase.sigName(normTp)(preErasureCtx)
   }
@@ -448,7 +448,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
       val tycon = tp.tycon
       if (tycon.isRef(defn.ArrayClass)) eraseArray(tp)
       else if (tycon.isRef(defn.PairClass)) erasePair(tp)
-      else if (tp.isRepeatedParam) apply(tp.underlyingIfRepeated(isJava))
+      else if (tp.isRepeatedParam) apply(tp.translateFromRepeated(toArray = isJava))
       else apply(tp.translucentSuperType)
     case _: TermRef | _: ThisType =>
       this(tp.widen)
@@ -540,7 +540,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
             // See doc comment for ElimByName for speculation how we could improve this.
         else
           MethodType(Nil, Nil,
-            eraseResult(sym.info.finalResultType.underlyingIfRepeated(isJava)))
+            eraseResult(sym.info.finalResultType.translateFromRepeated(toArray = isJava)))
       case tp1: PolyType =>
         eraseResult(tp1.resultType) match
           case rt: MethodType => rt

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

@@ -1607,7 +1607,7 @@ object Types {
           case res => res
         }
         val funType = defn.FunctionOf(
-          formals1 mapConserve (_.underlyingIfRepeated(mt.isJavaMethod)),
+          formals1 mapConserve (_.translateFromRepeated(toArray = mt.isJavaMethod)),
           result1, isContextual, isErased)
         if (mt.isResultDependent) RefinedType(funType, nme.apply, mt)
         else funType

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

@@ -593,7 +593,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
               if (tag == ALIASsym) TypeAlias(tp1)
               else if (denot.isType) checkNonCyclic(denot.symbol, tp1, reportErrors = false)
                 // we need the checkNonCyclic call to insert LazyRefs for F-bounded cycles
-              else if (!denot.is(Param)) tp1.underlyingIfRepeated(isJava = false)
+              else if (!denot.is(Param)) tp1.translateFromRepeated(toArray = false)
               else tp1
             if (denot.isConstructor) addConstructorTypeParams(denot)
             if (atEnd)

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

@@ -52,7 +52,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
       val resultType1 = elimRepeated(resultType)
       val paramTypes1 =
         if (paramTypes.nonEmpty && paramTypes.last.isRepeatedParam) {
-          val last = paramTypes.last.underlyingIfRepeated(tp.isJavaMethod)
+          val last = paramTypes.last.translateFromRepeated(toArray = tp.isJavaMethod)
           paramTypes.init :+ last
         }
         else paramTypes
@@ -159,7 +159,7 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
       tp.derivedLambdaType(tp.paramNames, tp.paramInfos, toJavaVarArgs(tp.resultType))
     case tp: MethodType =>
       val inits :+ last = tp.paramInfos
-      val last1 = last.underlyingIfRepeated(isJava = true)
+      val last1 = last.translateFromRepeated(toArray = true)
       tp.derivedLambdaType(tp.paramNames, inits :+ last1, tp.resultType)
   }
 }

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

@@ -420,7 +420,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
           for ((formal, idx) <- methTpe.paramInfos.zipWithIndex) yield {
             val elem =
               param.select(defn.Product_productElement).appliedTo(Literal(Constant(idx)))
-                .ensureConforms(formal.underlyingIfRepeated(isJava = false))
+                .ensureConforms(formal.translateFromRepeated(toArray = false))
             if (formal.isRepeatedParam) ctx.typer.seqToRepeated(elem) else elem
           }
         New(classRef, elems)

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

@@ -207,7 +207,7 @@ trait QuotesAndSplices {
           try ref(defn.InternalQuoted_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
           finally {
             val patType = pat.tpe.widen
-            val patType1 = patType.underlyingIfRepeated(isJava = false)
+            val patType1 = patType.translateFromRepeated(toArray = false)
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
             patBuf += pat1
           }

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

@@ -729,7 +729,7 @@ class Typer extends Namer
     if (untpd.isWildcardStarArg(tree)) {
       def typedWildcardStarArgExpr = {
         val ptArg =
-          if (ctx.mode.is(Mode.QuotedPattern)) pt.underlyingIfRepeated(isJava = false)
+          if (ctx.mode.is(Mode.QuotedPattern)) pt.translateFromRepeated(toArray = false)
           else WildcardType
         val tpdExpr = typedExpr(tree.expr, ptArg)
         tpdExpr.tpe.widenDealias match {
@@ -1158,7 +1158,7 @@ class Typer extends Namer
             if (!param.tpt.isEmpty) param
             else cpy.ValDef(param)(
               tpt = untpd.TypeTree(
-                inferredParamType(param, protoFormal(i)).underlyingIfRepeated(isJava = false)))
+                inferredParamType(param, protoFormal(i)).translateFromRepeated(toArray = false)))
         desugar.makeClosure(inferredParams, fnBody, resultTpt, isContextual)
       }
     typed(desugared, pt)