Normalize tuple types in var args seq literals and classOf instances

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

@@ -152,6 +152,17 @@ class TypeUtils:
     def namedTupleElementTypes(derived: Boolean)(using Context): List[(TermName, Type)] =
       namedTupleElementTypesUpTo(Int.MaxValue, derived)
 
+    /** If this is a generic tuple type with arity <= MaxTupleArity, return the
+     *  corresponding TupleN type, otherwise return this.
+     */
+    def normalizedTupleType(using Context): Type =
+      if self.isGenericTuple then
+        self.tupleElementTypes match
+          case Some(elems) if elems.size <= Definitions.MaxTupleArity => defn.tupleType(elems)
+          case _ => self
+      else
+        self
+
     def isNamedTupleType(using Context): Boolean = self match
       case defn.NamedTuple(_, _) => true
       case _ => false

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

@@ -942,7 +942,7 @@ trait Applications extends Compatibility {
     def makeVarArg(n: Int, elemFormal: Type): Unit = {
       val args = typedArgBuf.takeRight(n).toList
       typedArgBuf.dropRightInPlace(n)
-      val elemtpt = TypeTree(elemFormal, inferred = true)
+      val elemtpt = TypeTree(elemFormal.normalizedTupleType, inferred = true)
       typedArgBuf += seqToRepeated(SeqLiteral(args, elemtpt))
     }
 

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

@@ -53,7 +53,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             if defn.SpecialClassTagClasses.contains(sym) then
               classTagModul.select(sym.name.toTermName).withSpan(span)
             else
-              val ctype = escapeJavaArray(erasure(tp))
+              val ctype = escapeJavaArray(erasure(tp.normalizedTupleType))
               if ctype.exists then
                 classTagModul.select(nme.apply)
                   .appliedToType(tp)

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

@@ -847,10 +847,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     // Otherwise, map combinations of A *: B *: .... EmptyTuple with nesting levels <= 22
     // to the Tuple class of the right arity and select from that one
     def trySmallGenericTuple(qual: Tree, withCast: Boolean) =
-      if qual.tpe.isSmallGenericTuple then
+      val tp = qual.tpe.widenTermRefExpr
+      val tpNormalized = tp.normalizedTupleType
+      if tp ne tpNormalized then
         if withCast then
-          val elems = qual.tpe.widenTermRefExpr.tupleElementTypes.getOrElse(Nil)
-          typedSelectWithAdapt(tree, pt, qual.cast(defn.tupleType(elems)))
+          typedSelectWithAdapt(tree, pt, qual.cast(tpNormalized))
         else
           typedSelectWithAdapt(tree, pt, qual)
       else EmptyTree

tests/run/i22345.scala

@@ -0,0 +1,2 @@
+@main def Test: Unit =
+  val a: Array[(Int, String)] = Array[Int *: String *: EmptyTuple]()

tests/run/i22345b.scala

@@ -0,0 +1,2 @@
+@main def Test: Unit =
+  val a: Array[(Int, String)] = Array[Int *: String *: EmptyTuple]((1, "hello"))

tests/run/i22345c.scala

@@ -0,0 +1,4 @@
+def makeSeq[T](args: T*): Seq[T] = args
+
+@main def Test: Unit =
+  val a: Array[(Int, String)] = makeSeq[Int *: String *: EmptyTuple]().toArray