vcArrays: fix for arrays of value classes with array as underlying type

Author: VladimirNik

src/dotty/tools/dotc/transform/VCArrays.scala

@@ -25,12 +25,18 @@ class VCArrays extends MiniPhaseTransform with InfoTransformer {
 
   private def eraseVCArrays(tp: Type)(implicit ctx: Context): Type = {
     val transform = new TypeMap {
-      //TODO: rewrite, don't create TypeMap for each invocation of eraseVCArrays
+      //TODO: rewrite, don't create new TypeMap for each invocation of eraseVCArrays
       def apply(tp: Type) = mapOver {
         tp match {
-          case JavaArrayType(ErasedValueType(tr, _)) =>
+          case JavaArrayType(ErasedValueType(tr, eund)) =>
             val cls = tr.symbol.asClass
             defn.vcArrayOf(cls).typeRef
+          //case tp: MethodType =>
+          //val paramTypes = tp.paramTypes.mapConserve(eraseVCArrays)
+          //val retType = eraseVCArrays(tp.resultType)
+          //tp.derivedMethodType(tp.paramNames, paramTypes, retType)
+          case ErasedValueType(tr, und) =>
+            ErasedValueType(tr, eraseVCArrays(und))
           case _ =>
             tp
         }
@@ -121,12 +127,14 @@ class VCArrays extends MiniPhaseTransform with InfoTransformer {
           if (fun.symbol == defn.newArrayMethod) =>
         val Literal(Constant(ins)) = retTpt
         ins match {
-          case JavaArrayType(ErasedValueType(tr, underlying)) =>
+          case jat@JavaArrayType(ErasedValueType(tr, underlying)) =>
             val cls = tr.symbol.asClass
             val mod = cls.companionModule
-            val arTpe = JavaArrayType(underlying)
+            //TODO: und1 should be processed in case of EVT
+            val und1 = eraseVCArrays(underlying)
+            val arTpe = jat.derivedJavaArrayType(und1)
             New(defn.vcArrayOf(cls).typeRef,
-              List(newArray(underlying, arTpe, tree.pos, dims.asInstanceOf[JavaSeqLiteral]).ensureConforms(arTpe),
+              List(newArray(und1, arTpe, tree.pos, dims.asInstanceOf[JavaSeqLiteral]).ensureConforms(arTpe),
                 ref(mod)))
           case _: Type =>
             val evtOpt = isArrayWithEVT(ins)
@@ -138,7 +146,8 @@ class VCArrays extends MiniPhaseTransform with InfoTransformer {
                 val Literal(Constant(compTptType)) = compTpt
                 val compTpt2 = eraseVCArrays((compTptType.asInstanceOf[Type]))
                 newArray(compTpt2, retTpt2, tree.pos, dims.asInstanceOf[JavaSeqLiteral])
-              case _ => tree
+              case _ =>
+                transformTypeOfTree(tree)
             }
         }
       // array.[]update(idx, elem) => array.arr().[]update(idx, elem)

test/dotc/tests.scala

@@ -117,6 +117,7 @@ class tests extends CompilerTest {
   @Test def pos_vc_array_caseclasses = compileFile(runDir, "valueclasses-array-caseclasses", args = "-Ycheck:all" :: Nil)
   @Test def pos_vc_array_arrayops = compileFile(runDir, "valueclasses-array-arrayops", args = "-Ycheck:all" :: Nil)
   @Test def pos_vc_array_array = compileFile(runDir, "valueclasses-array-array", args = "-Ycheck:all" :: Nil)
+  @Test def pos_vc_array_und_array = compileFile(runDir, "valueclasses-array-und-array", args = "-Ycheck:all" :: Nil)
 
   @Test def pos_all = compileFiles(posDir) // twice omitted to make tests run faster
 

tests/run/valueclasses-array-und-array.check

@@ -0,0 +1,2 @@
+1
+1

tests/run/valueclasses-array-und-array.scala

@@ -0,0 +1,56 @@
+import scala.collection.mutable._
+class X(val x: Array[Y]) extends AnyVal
+class X0(val x: Array[Y0]) extends AnyVal
+class X00(val x: Array[Array[Y0]]) extends AnyVal
+class X2(val x: Array[Y2]) extends AnyVal
+class X3(val x: Array[Y3]) extends AnyVal
+class Y3(val x: Int) extends AnyVal
+class Y0(val a: Int) extends AnyVal
+class Y(val a: Array[X])
+class Y2(val a: Int) extends AnyVal
+class Z(val y: Y) extends AnyVal
+
+object Test {
+  def main(args: Array[String]) = {
+    val ar0 = new Array[X](3)
+    ar0(0) = new X(Array(new Y(Array(new X(Array())))))
+    ar0(1) = new X(new Array[Y](4))
+    val ar01 = new Array[X00](5)
+    val ar011: Array[X00] = null
+    val ar02 = Array(new X00(Array(Array(new Y0(7)))))
+
+    val y1 = Array(new Y(Array(new X(Array(new Y(new Array[X](2)), new Y(Array(new X(new Array[Y](4)))))))))
+    val y2 = y1(0)
+
+    val z1 = Array(Array(new Y(Array(new X(Array(new Y(new Array[X](2)), new Y(Array(new X(new Array[Y](4))))))))))
+    val z2 = z1(0)
+    val z3 = z1(0)(0)
+    val z4 = z2(0)
+    println(z1.size)
+    println(z2.size)
+
+    val y10 = Array(new X0(Array(new Y0(4), new Y0(3))))
+    val y11 = Array(new X0(new Array[Y0](5)))
+    val y20 = y10(0)
+
+    val z10 = Array(Array(new X0(Array(new Y0(4), new Y0(3)))))
+    val z11 = Array(Array(new X0(new Array[Y0](5))))
+    val z20 = z10(0)
+    val z30 = z10(0)(0)
+    val z40 = z20(0)
+
+    z10 map (x => Array(x(0)))
+    y10 map (x => x)
+
+    val ar = Array(new X0(Array(new Y0(1))))
+
+    val ar2 = Array(new X(Array(new Y(Array[X](new X( new Array[Y](5)))))))
+
+    val t = new X3(Array(new Y3(1)))
+    t.toString
+    val t2 = new X3(new Array[Y3](4))
+
+    val ar3 = Array(new X2(new Array[Y2](3)))
+    val ar4 = Array(new X2(Array(new Y2(3))))
+  }
+}