Refactor methods for converting to repeated

- For trees, get rid of arrayToRepeated/seqToRepeated in favor of a toRepeated.
- For types, add a translateToRepeated.
- In typedTyped, create the Typed node manually to preserve the span
  of the original type ascription as well as potential tree attachments.

Author: smarter

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

@@ -1352,7 +1352,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *  Used to make arguments for methods that accept varargs.
    */
   def repeated(trees: List[Tree], tpt: Tree)(using Context): Tree =
-    ctx.typeAssigner.arrayToRepeated(JavaSeqLiteral(trees, tpt))
+    ctx.typeAssigner.toRepeated(JavaSeqLiteral(trees, tpt))
 
   /** Create a tree representing a list containing all
    *  the elements of the argument list. A "list of tree to

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

@@ -402,6 +402,14 @@ class TypeApplications(val self: Type) extends AnyVal {
       translateParameterized(defn.RepeatedParamClass, seqClass, wildcardArg = toArray)
     else self
 
+  /** Translate a `Seq[T]` or `Array[T]` into a `*T`, keep other types as is. */
+  def translateToRepeated(using Context): Type =
+    val from = self.widenDealias.classSymbol
+    if (from eq defn.SeqClass) || (from eq defn.ArrayClass)
+      translateParameterized(from.asClass, defn.RepeatedParamClass)
+    else
+      self
+
   /** If this is an encoding of a (partially) applied type, return its arguments,
    *  otherwise return Nil.
    *  Existential types in arguments are returned as TypeBounds instances.

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

@@ -421,7 +421,7 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
             val elem =
               param.select(defn.Product_productElement).appliedTo(Literal(Constant(idx)))
                 .ensureConforms(formal.translateFromRepeated(toArray = false))
-            if (formal.isRepeatedParam) ctx.typer.seqToRepeated(elem) else elem
+            if (formal.isRepeatedParam) ctx.typeAssigner.toRepeated(elem) else elem
           }
         New(classRef, elems)
     }

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

@@ -697,7 +697,7 @@ trait Applications extends Compatibility {
       val args = typedArgBuf.takeRight(n).toList
       typedArgBuf.trimEnd(n)
       val elemtpt = TypeTree(elemFormal)
-      typedArgBuf += seqToRepeated(SeqLiteral(args, elemtpt))
+      typedArgBuf += ctx.typeAssigner.toRepeated(SeqLiteral(args, elemtpt))
     }
 
     def harmonizeArgs(args: List[TypedArg]): List[Tree] = harmonize(args)

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

@@ -165,12 +165,8 @@ trait TypeAssigner {
     then checkNoPrivateLeaks(sym)
     else sym.info
 
-  private def toRepeated(tree: Tree, from: ClassSymbol)(using Context): Tree =
-    Typed(tree, TypeTree(tree.tpe.widen.translateParameterized(from, defn.RepeatedParamClass)))
-
-  def seqToRepeated(tree: Tree)(using Context): Tree = toRepeated(tree, defn.SeqClass)
-
-  def arrayToRepeated(tree: Tree)(using Context): Tree = toRepeated(tree, defn.ArrayClass)
+  def toRepeated(tree: Tree)(using Context): Tree =
+    Typed(tree, TypeTree(tree.tpe.translateToRepeated))
 
   /** A denotation exists really if it exists and does not point to a stale symbol. */
   final def reallyExists(denot: Denotation)(using Context): Boolean = try

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

@@ -733,13 +733,9 @@ class Typer extends Namer
           // FIXME(#8680): Quoted patterns do not support Array repeated arguments
           if (ctx.mode.is(Mode.QuotedPattern)) pt.translateFromRepeated(toArray = false)
           else pt.translateFromRepeated(toArray = false) | pt.translateFromRepeated(toArray = true)
-        val tpdExpr = typedExpr(tree.expr, ptArg)
-        tpdExpr.tpe.widenDealias match {
-          case defn.ArrayOf(_) =>
-            arrayToRepeated(tpdExpr)
-          case _ =>
-            seqToRepeated(tpdExpr)
-        }
+        val expr1 = typedExpr(tree.expr, ptArg)
+        val tpt1 = TypeTree(expr1.tpe.translateToRepeated).withSpan(tree.tpt.span)
+        assignType(cpy.Typed(tree)(expr1, tpt1), tpt1)
       }
       cases(
         ifPat = ascription(TypeTree(defn.RepeatedParamType.appliedTo(pt)), isWildcard = true),