Wrap SeqLiteral of value classes using custom wrapper instead of wrapRefArray

wrapRefArray is defined as:
  def wrapRefArray[T <: AnyRef](xs: Array[T]): WrappedArray[T]
After erasure this becomes:
  def wrapRefArray(xs: Object[]): WrappedArray
This is fine for value classes as long as arrays are boxed, but once we
change the representation this will result in ClassCastException.
Therefore we introduce a wrapper just for value classes:
  def wrapVCArray[T <: AnyVal](xs: Array[T]): WrappedArray[T]
Which is erased to:
  def wrapVCArray(xs: Object): WrappedArray
Which lets us represent arrays of value classes using any reference type.

Author: smarter

src/dotty/DottyPredef.scala

@@ -1,7 +1,9 @@
 package dotty
 
+import scala.collection.mutable.WrappedArray
 import scala.reflect.ClassTag
 import scala.reflect.runtime.universe.TypeTag
+import scala.runtime.ScalaRunTime.arrayElementClass
 import scala.Predef.???  // this is currently ineffective, because of #530
 
 abstract class I1 {
@@ -34,4 +36,15 @@ object DottyPredef extends I6 {
 
   /** ClassTags for final classes */
   implicit val NothingClassTag: ClassTag[Nothing] = ClassTag.Nothing
+
+  // This implicit will never be used for arrays of primitives because
+  // the wrap*Array in scala.Predef have a higher priority.
+  implicit def wrapVCArray[T <: AnyVal](xs: Array[T]): WrappedArray[T] =
+    new WrappedArray[T] {
+      val array = xs
+      lazy val elemTag = ClassTag[T](arrayElementClass(array.getClass))
+      def length: Int = array.length
+      def apply(index: Int): T = array(index)
+      def update(index: Int, elem: T) { array(index) = elem }
+    }
 }

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

@@ -7,7 +7,7 @@ import dotty.tools.dotc.transform.TreeTransforms._
 import Contexts.Context
 import Symbols._
 import Phases._
-import Decorators._
+import Decorators._, ValueClasses._
 
 /** A transformer that eliminates SeqLiteral's, transforming `SeqLiteral(elems)` to an operation
  *  equivalent to
@@ -36,13 +36,20 @@ class SeqLiterals extends MiniPhaseTransform {
       //println(i"trans seq $tree, arr = $arr: ${arr.tpe} ${arr.tpe.elemType}")
       val elemtp = arr.tpe.elemType.bounds.hi
       val elemCls = elemtp.classSymbol
-      val (wrapMethStr, targs) =
-        if (elemCls.isPrimitiveValueClass) (s"wrap${elemCls.name}Array", Nil)
-        else if (elemtp derivesFrom defn.ObjectClass) ("wrapRefArray", elemtp :: Nil)
-        else ("genericWrapArray", elemtp :: Nil)
-      ref(defn.ScalaPredefModule)
-        .select(wrapMethStr.toTermName)
-        .appliedToTypes(targs)
-        .appliedTo(arr)
+      if (isDerivedValueClass(elemCls)) {
+        ref(defn.DottyPredefModule)
+          .select("wrapVCArray".toTermName)
+          .appliedToTypes(List(elemtp))
+          .appliedTo(arr)
+      } else {
+        val (wrapMethStr, targs) =
+          if (elemCls.isPrimitiveValueClass) (s"wrap${elemCls.name}Array", Nil)
+          else if (elemtp derivesFrom defn.ObjectClass) ("wrapRefArray", elemtp :: Nil)
+          else ("genericWrapArray", elemtp :: Nil)
+        ref(defn.ScalaPredefModule)
+          .select(wrapMethStr.toTermName)
+          .appliedToTypes(targs)
+          .appliedTo(arr)
+      }
   }
 }