Keep span and attachments when typing a sequence argument

I don't know of a case where this matters currently but it's more correct.

Author: smarter

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

@@ -378,7 +378,7 @@ class TypeApplications(val self: Type) extends AnyVal {
       self.derivedExprType(tp.translateParameterized(from, to))
     case _ =>
       if (self.derivesFrom(from)) {
-        def elemType(tp: Type): Type = tp match
+        def elemType(tp: Type): Type = tp.widenDealias match
           case tp: AndOrType => tp.derivedAndOrType(elemType(tp.tp1), elemType(tp.tp2))
           case _ => tp.baseType(from).argInfos.head
         val arg = elemType(self)
@@ -404,6 +404,10 @@ class TypeApplications(val self: Type) extends AnyVal {
       translateParameterized(defn.RepeatedParamClass, seqClass, wildcardArg = toArray)
     else self
 
+  /** Translate a `From[T]` into a `*T`. */
+  def translateToRepeated(from: ClassSymbol)(using Context): Type =
+    translateParameterized(from, defn.RepeatedParamClass)
+
   /** 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/typer/TypeAssigner.scala

@@ -166,7 +166,7 @@ trait TypeAssigner {
     else sym.info
 
   private def toRepeated(tree: Tree, from: ClassSymbol)(using Context): Tree =
-    Typed(tree, TypeTree(tree.tpe.widen.translateParameterized(from, defn.RepeatedParamClass)))
+    Typed(tree, TypeTree(tree.tpe.widen.translateToRepeated(from)))
 
   def seqToRepeated(tree: Tree)(using Context): Tree = toRepeated(tree, defn.SeqClass)
 

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

@@ -737,12 +737,10 @@ class Typer extends Namer
           else pt.translateFromRepeated(toArray = false, translateWildcard = true) |
                pt.translateFromRepeated(toArray = true,  translateWildcard = 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 fromCls = if expr1.tpe.derivesFrom(defn.ArrayClass) then defn.ArrayClass else defn.SeqClass
+        val tpt1 = TypeTree(expr1.tpe.widen.translateToRepeated(fromCls)).withSpan(tree.tpt.span)
+        assignType(cpy.Typed(tree)(expr1, tpt1), tpt1)
       }
       cases(
         ifPat = ascription(TypeTree(defn.RepeatedParamType.appliedTo(pt)), isWildcard = true),