Instead of a cast, change RepeatedParam[T] into Array[_ <: T] in elimRepeated

Author: abeln

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

@@ -435,15 +435,19 @@ class TypeApplications(val self: Type) extends AnyVal {
     case _ => if (self.isMatch) MatchAlias(self) else TypeAlias(self)
   }
 
-  /** Translate a type of the form From[T] to To[T], keep other types as they are.
+  /** Translate a type of the form From[T] to either To[T] or To[_ <: T] (if `argIsUpper` is set). Keep other types as they are.
    *  `from` and `to` must be static classes, both with one type parameter, and the same variance.
    *  Do the same for by name types => From[T] and => To[T]
    */
-  def translateParameterized(from: ClassSymbol, to: ClassSymbol)(implicit ctx: Context): Type = self match {
+  def translateParameterized(from: ClassSymbol, to: ClassSymbol, argIsUpper: Boolean = false)(implicit ctx: Context): Type = self match {
     case self @ ExprType(tp) =>
       self.derivedExprType(tp.translateParameterized(from, to))
     case _ =>
-      if (self.derivesFrom(from)) to.typeRef.appliedTo(self.baseType(from).argInfos)
+      if (self.derivesFrom(from)) {
+        val arg = self.baseType(from).argInfos.head
+        val arg1 = if (argIsUpper) TypeBounds.upper(arg) else arg
+        to.typeRef.appliedTo(arg1)
+      }
       else self
   }
 
@@ -453,7 +457,9 @@ class TypeApplications(val self: Type) extends AnyVal {
   def underlyingIfRepeated(isJava: Boolean)(implicit ctx: Context): Type =
     if (self.isRepeatedParam) {
       val seqClass = if (isJava) defn.ArrayClass else defn.SeqClass
-      translateParameterized(defn.RepeatedParamClass, 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, argIsUpper=isJava)
     }
     else self
 

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

@@ -91,11 +91,8 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
   private def seqToArray(tree: Tree, pt: Type)(implicit ctx: Context): Tree = tree match {
     case SeqLiteral(elems, elemtpt) =>
       JavaSeqLiteral(elems, elemtpt)
-    case app@Apply(fun, args) if defn.WrapArrayMethods().contains(fun.symbol) =>
-      // Rewrite a call to `wrapXArray(arr)` to `arr`.
-      // Additionally, a cast might be necessary in some instances due to arrays being invariant before
-      // erasure. See `tests/pos/i5140`.
-      args.head.ensureConforms(pt)
+    case app@Apply(fun, args) if defn.WrapArrayMethods().contains(fun.symbol) => // rewrite a call to `wrapXArray(arr)` to `arr`
+      args.head
     case _ =>
       val elemType = tree.tpe.elemType
       var elemClass = elemType.classSymbol

tests/pos/i5140/S.scala

@@ -1,8 +1,9 @@
 class S {
   val j = new J()
   val x: Array[Dog] = ???
-  // Check that x is cast to an `Array[Animal]` after elimRepeated.
+  // Check that the java varargs for `foo` gets typed as `Array[_ <: Animal]`.
   // Otherwise, the call below would fail in -Ycheck:elimRepeated because arrays are invariant before erasure.
   // This is unsound but allowed.
   j.foo(x: _*)
+  j.foo(new Dog, new Dog)
 }