New representation for arrays of value classes

For a value class V whose underlying type is U, instead of representing
an array of V as V[] on the JVM, we use our own class VCXArray where X
is "U" if U is a primitive type and is "Object" otherwise.

This avoids boxing when creating arrays but we still need to box and
unbox when using such an array in a generic position, this also breaks
reflection and makes it pretty hard to use an array of a value class
from Java or Scala 2.

See also the FIXMEs in tests/run/valueclasses-array.scala for the
current implementation restrictions.

Author: smarter

src/dotty/tools/dotc/Compiler.scala

@@ -62,6 +62,7 @@ class Compiler {
            new AugmentScala2Traits,
            new ResolveSuper),
       List(new Erasure),
+      List(new VCArrays), // Separate group for easier debugging for now
       List(new ElimErasedValueType,
            new VCInline,
            new Mixin,

src/dotty/tools/dotc/core/StdNames.scala

@@ -227,6 +227,7 @@ object StdNames {
 
     // Compiler-internal
     val ANYname: N                  = "<anyname>"
+    val ARR: N                      = "arr"
     val CONSTRUCTOR: N              = Names.CONSTRUCTOR.toString
     val DEFAULT_CASE: N             = "defaultCase$"
     val EVT2U: N                    = "evt2u$"

src/dotty/tools/dotc/core/TypeErasure.scala

@@ -372,8 +372,10 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
 
   private def eraseArray(tp: RefinedType)(implicit ctx: Context) = {
     val defn.ArrayType(elemtp) = tp
+    // Arrays are semi-erased to ErasedValueType(V, U)[] and fully erased in
+    // VCArrays
     def arrayErasure(tpToErase: Type) =
-      erasureFn(isJava, semiEraseVCs = false, isConstructor, wildcardOK)(tpToErase)
+      erasureFn(isJava, semiEraseVCs = true, isConstructor, wildcardOK)(tpToErase)
     if (elemtp derivesFrom defn.NullClass) JavaArrayType(defn.ObjectType)
     else if (isUnboundedGeneric(elemtp)) defn.ObjectType
     else JavaArrayType(arrayErasure(elemtp))

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

@@ -0,0 +1,112 @@
+package dotty.tools.dotc
+package transform
+
+import ast.{Trees, tpd}
+import core._, core.Decorators._
+import Contexts._, Trees._, Types._, StdNames._, Symbols._
+import DenotTransformers._, TreeTransforms._, Phases.Phase
+import TypeErasure.ErasedValueType, ValueClasses._
+
+/** This phase erases arrays of value classes to their runtime representation.
+ *
+ *  For a value class V whose erased underlying type is U, an array of V has type
+ *  Array[V] before Erasure and Array[ErasedValueType(V, U)] afterwards. This phase
+ *  replaces this type by VCXArray where X is "U" if U is a primitive type and is "Object"
+ *  otherwise.
+ */
+class VCArrays extends MiniPhaseTransform with InfoTransformer {
+  import tpd._
+
+  override def phaseName: String = "vcArrays"
+
+  override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type =
+    eraseVCArrays(tp)
+
+  private def eraseVCArrays(tp: Type)(implicit ctx: Context): Type = tp match {
+    case JavaArrayType(ErasedValueType(cls, _)) =>
+      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 _ =>
+      tp
+  }
+
+  private def transformTypeOfTree(tree: Tree)(implicit ctx: Context): Tree =
+    tree.withType(eraseVCArrays(tree.tpe))
+
+  override def transformValDef(tree: ValDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val tpt1 = transformTypeOfTree(tree.tpt)
+    cpy.ValDef(tree)(tpt = tpt1)
+  }
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val tpt1 = transformTypeOfTree(tree.tpt)
+    cpy.DefDef(tree)(tpt = tpt1)
+  }
+
+  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context, info: TransformerInfo): Tree =
+    tree match {
+      case TypeApply(sel @ Select(_, _), _) if (sel.symbol == defn.newRefArrayMethod) =>
+        // Preserve the semi-erased type of the array so that we can properly transform
+        // it in transformApply
+        tree
+      case TypeApply(fun, args) =>
+        val tree1 = cpy.TypeApply(tree)(fun, args.map(transformTypeOfTree(_)))
+        transformTypeOfTree(tree1)
+    }
+
+  override def transformSeqLiteral(tree: SeqLiteral)(implicit ctx: Context, info: TransformerInfo): Tree =
+    tree.tpe match {
+      // [arg1, arg2,  ...] => new VCXArray([V.evt2u$(arg1), V.evt2u$(arg2), ...])
+      case JavaArrayType(ErasedValueType(cls, _)) =>
+        val evt2uMethod = ref(evt2u(cls))
+        val underlyingArray = JavaSeqLiteral(tree.elems.map(evt2uMethod.appliedTo(_)))
+        val mod = cls.companionModule
+        New(defn.vcArrayOf(cls).typeRef, List(underlyingArray, ref(mod)))
+      case _ =>
+        tree
+    }
+
+  override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    tree match {
+      // newRefArray[ErasedValueType(V, U)[]](args) => New VCXArray(newXArray(args), V)
+      case Apply(ta @ TypeApply(sel @ Select(_,_), List(targ)), args)
+          if (sel.symbol == defn.newRefArrayMethod) =>
+        targ.tpe match {
+          case JavaArrayType(ErasedValueType(cls, underlying)) =>
+            val mod = cls.companionModule
+            New(defn.vcArrayOf(cls).typeRef,
+              List(newArray(TypeTree(underlying), tree.pos).appliedToArgs(args),
+                ref(mod)))
+          case _ =>
+            tree
+        }
+      // array.[]update(idx, elem) => array.arr().[]update(idx, elem)
+      case Apply(Select(array, nme.primitive.arrayUpdate), List(idx, elem)) =>
+        elem.tpe.widen match {
+          case ErasedValueType(cls, _) =>
+            array.select(nme.ARR).appliedToNone
+              .select(nme.primitive.arrayUpdate).appliedTo(idx, ref(evt2u(cls)).appliedTo(elem))
+          case _ =>
+            tree
+        }
+      // array.[]apply(idx) => array.arr().[]apply(idx)
+      case Apply(Select(array, nme.primitive.arrayApply), List(idx)) =>
+        tree.tpe.widen match {
+          case ErasedValueType(cls, _) =>
+            ref(u2evt(cls)).appliedTo(array.select(nme.ARR).appliedToNone
+              .select(nme.primitive.arrayApply).appliedTo(idx))
+          case _ =>
+            tree
+        }
+      // array.[]length() => array.arr().[]length()
+      case Apply(Select(array, nme.primitive.arrayLength), Nil)
+      if (array.tpe <:< defn.VCArrayPrototypeType) =>
+        array.select(nme.ARR).appliedToNone
+          .select(nme.primitive.arrayLength).appliedToNone
+      case _ =>
+        tree
+    }
+  }
+}

tests/run/valueclasses-array.check

@@ -0,0 +1,9 @@
+[Meter
+Meter(1)
+1
+Meter(2)
+2
+Meter(3)
+1
+Meter(4)
+2

tests/run/valueclasses-array.scala

@@ -0,0 +1,48 @@
+class Meter(val underlying: Int) extends AnyVal {
+  def plus(other: Meter): Meter =
+    new Meter(underlying + other.underlying)
+
+  override def toString = "Meter(" + underlying + ")"
+}
+
+object Meter {
+  // FIXME: generate these methods in VCParents
+  def box(underlying: Int) = new Meter(underlying)
+  def runtimeClass = classOf[Meter]
+}
+
+object Test {
+  def genAccess[T](genArray: Array[T]) = genArray(0)
+  def genUpdated[T](genArray: Array[T], elem: T) = genArray(0) = elem
+  def genLength[T](genArray: Array[T]) = genArray.length
+
+  def foo(myArray: Array[Meter], elem: Meter) = {
+    val update = myArray(0) = elem
+    val access = myArray(0)
+    val length: Int = myArray.length
+
+    println(access)
+    println(length)
+  }
+
+ def genFoo[T](genArray: Array[T], elem: T) = {
+    val update = genArray(0) = elem
+    val access = genArray(0)
+    val length: Int = genArray.length
+
+    println(access)
+    println(length)
+  }
+
+  def main(args: Array[String]) = {
+    val myArray = new Array[Meter](1)
+    val myArray2 = Array[Meter](new Meter(1), new Meter(2))
+    assert(myArray.getClass eq myArray2.getClass)
+
+    println(myArray.toString)
+    foo(myArray, new Meter(1))
+    foo(myArray2, new Meter(2))
+    genFoo(myArray, new Meter(3))
+    genFoo(myArray2, new Meter(4))
+  }
+}