Force cast, to avoid lubbing problems

Author: dwijnand

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

@@ -40,8 +40,9 @@ class ArrayApply extends MiniPhase {
         case StripAscription(Apply(wrapArrayMeth, List(StripAscription(rest: JavaSeqLiteral)))) :: Nil
           if defn.WrapArrayMethods().contains(wrapArrayMeth.symbol) &&
             rest.elems.lengthIs < transformListApplyLimit =>
-          rest.elems.foldRight(ref(defn.NilModule)): (elem, acc) =>
+          val consed = rest.elems.foldRight(ref(defn.NilModule)): (elem, acc) =>
             New(defn.ConsType, List(elem.ensureConforms(defn.ObjectType), acc))
+          consed.cast(tree.tpe)
 
         case _ =>
           tree

compiler/test/dotty/tools/backend/jvm/ArrayApplyOptTest.scala

@@ -213,6 +213,8 @@ class ArrayApplyOptTest extends DottyBytecodeTest {
       val meth2   = getMethod(clsNode, "meth2")
 
       val instructions1 = instructionsFromMethod(meth1) match
+        case instr :+ TypeOp(CHECKCAST, _) :+ TypeOp(CHECKCAST, _) :+ (ret @ Op(ARETURN)) =>
+          instr :+ ret
         case instr :+ TypeOp(CHECKCAST, _) :+ (ret @ Op(ARETURN)) =>
           // List.apply[?A] doesn't, strictly, return List[?A],
           // because it cascades to its definition on IterableFactory

tests/run/list-apply-eval.scala

@@ -6,7 +6,7 @@ object Test:
     counter += 1
     counter.toString
 
-  def main(args: Array[String]): Unit = 
+  def main(args: Array[String]): Unit =
     //List.apply is subject to an optimisation in cleanup
     //ensure that the arguments are evaluated in the currect order
     // Rewritten to:
@@ -26,3 +26,8 @@ object Test:
   // test for the cast instruction described in checkApplyAvoidsIntermediateArray
   def lub(b: Boolean): List[(String, String)] =
     if b then List(("foo", "bar")) else Nil
+
+  // from minimising CI failure in oslib
+  // again, the lub of :: and Nil is Product, which breaks ++ (which requires IterableOnce)
+  def lub2(b: Boolean): Unit =
+    Seq(1) ++ (if (b) Seq(2) else Nil)