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.

Author: smarter

src/dotty/DottyPredef.scala

@@ -10,4 +10,15 @@ object DottyPredef {
 
   implicit def arrayTag[T](implicit ctag: ClassTag[T]): ClassTag[Array[T]] =
     ctag.wrap
+
+  // 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/runtime/vc/VCPrototype.scala

@@ -51,6 +51,7 @@ class Compiler {
            new ElimRepeated,        // Rewrite vararg parameters and arguments
            new NormalizeFlags,      // Rewrite some definition flags
            new ExtensionMethods,    // Expand methods of value classes with extension methods
+           new VCParents,
            new ExpandSAMs,          // Expand single abstract method closures to anonymous classes
            new TailRec,             // Rewrite tail recursion to loops
            new LiftTry,             // Put try expressions that might execute on non-empty stacks into their own methods
@@ -68,6 +69,7 @@ class Compiler {
            new AugmentScala2Traits, // Expand traits defined in Scala 2.11 to simulate old-style rewritings
            new ResolveSuper),       // Implement super accessors and add forwarders to trait methods
       List(new Erasure),            // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.
+      List(new VCArrays),
       List(new ElimErasedValueType, // Expand erased value types to their underlying implmementation types
            new VCElideAllocations,  // Peep-hole optimization to eliminate unnecessary value class allocations
            new Mixin,               // Expand trait fields and trait initializers

src/dotty/tools/dotc/Compiler.scala

@@ -752,6 +752,34 @@ class Definitions {
   /** The type of the boxed class corresponding to primitive value type `tp`. */
   def boxedType(tp: Type)(implicit ctx: Context): TypeRef = boxedTypes(scalaClassName(tp))
 
+  lazy val vcPrototype: Map[Symbol, Symbol] =
+    refClasses.map(vc => vc -> ctx.requiredClass(s"dotty.runtime.vc.VC${vc.name}Prototype")).toMap
+  lazy val vcPrototypeValues = vcPrototype.values.toSet
+  lazy val vcCompanion: Map[Symbol, Symbol] =
+    refClasses.map(vc => vc -> ctx.requiredClass(s"dotty.runtime.vc.VC${vc.name}Companion")).toMap
+  lazy val vcArray: Map[Symbol, Symbol] =
+    refClasses.map(vc => vc -> ctx.requiredClass(s"dotty.runtime.vc.VC${vc.name}Array")).toMap
+
+  lazy val VCPrototypeClass = ctx.requiredClass(s"dotty.runtime.vc.VCPrototype")
+  def VCPrototypeType = VCPrototypeClass.typeRef
+  lazy val VCArrayPrototypeClass = ctx.requiredClass(s"dotty.runtime.vc.VCArrayPrototype")
+  def VCArrayPrototypeType = VCArrayPrototypeClass.typeRef
+
+  def vcPrototypeOf(vc: ClassDenotation) = {
+    val underlying = ValueClasses.valueClassUnbox(vc).info.classSymbol
+    vcPrototype.getOrElse(underlying, vcPrototype(defn.ObjectClass))
+  }
+  def vcCompanionOf(vc: ClassDenotation) = {
+    val underlying = ValueClasses.valueClassUnbox(vc).info.classSymbol
+    vcCompanion.getOrElse(underlying, vcCompanion(defn.ObjectClass))
+  }
+  def vcArrayOf(vc: ClassDenotation) = {
+    val underlying = ValueClasses.valueClassUnbox(vc).info.classSymbol
+    vcArray.getOrElse(underlying, vcArray(defn.ObjectClass))
+  }
+
+
+
   def wrapArrayMethodName(elemtp: Type): TermName = {
     val cls = elemtp.classSymbol
     if (cls.isPrimitiveValueClass) nme.wrapXArray(cls.name)

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

@@ -228,6 +228,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/StdNames.scala

@@ -386,8 +386,10 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
 
   private def eraseArray(tp: RefinedType)(implicit ctx: Context) = {
     val defn.ArrayOf(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/core/TypeErasure.scala

@@ -76,27 +76,12 @@ class ExtensionMethods extends MiniPhaseTransform with DenotTransformer with Ful
             val evt2uSym = ctx.newSymbol(moduleSym, nme.EVT2U, Synthetic | Method,
               MethodType(List(nme.x_0), List(evt), underlying))
 
-            val defn = ctx.definitions
-
-            val underlyingCls = underlying.classSymbol
-            val underlyingClsName =
-              if (underlyingCls.isNumericValueClass || underlyingCls == defn.BooleanClass) underlyingCls.name
-              else nme.Object
-
-            val syp = ctx.requiredClass(s"dotty.runtime.vc.VC${underlyingClsName}Companion").asClass
-
-            newSuperClass = tpd.ref(syp).select(nme.CONSTRUCTOR).appliedToType(valueClass.typeRef).tpe.resultType
-
             decls1.enter(u2evtSym)
             decls1.enter(evt2uSym)
           }
 
-          // Add the extension methods, the cast methods u2evt$ and evt2u$, and a VC*Companion superclass
-          moduleClassSym.copySymDenotation(info =
-            cinfo.derivedClassInfo(
-              // FIXME: use of VC*Companion superclasses is disabled until the conflicts with SyntheticMethods are solved.
-              //classParents = ctx.normalizeToClassRefs(List(newSuperClass), moduleSym, decls1),
-              decls = decls1))
+          // Add the extension methods, the cast methods u2evt$ and evt2u$
+          moduleClassSym.copySymDenotation(info = cinfo.derivedClassInfo(decls = decls1))
         case _ =>
           moduleClassSym
       }

src/dotty/tools/dotc/transform/ExtensionMethods.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 = tree.elemtpt.tpe
       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)
+      }
   }
 }

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

@@ -31,7 +31,6 @@ import scala.language.postfixOps
  *  implementation already exists:
  *
  *    def equals(other: Any): Boolean
- *    def hashCode(): Int
  */
 class SyntheticMethods(thisTransformer: DenotTransformer) {
   import ast.tpd._
@@ -41,7 +40,7 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
 
   private def initSymbols(implicit ctx: Context) =
     if (myValueSymbols.isEmpty) {
-      myValueSymbols = List(defn.Any_hashCode, defn.Any_equals)
+      myValueSymbols = List(defn.Any_equals)
       myCaseSymbols = myValueSymbols ++ List(defn.Any_toString, defn.Product_canEqual,
         defn.Product_productArity, defn.Product_productPrefix)
     }

src/dotty/tools/dotc/transform/SyntheticMethods.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
+    }
+  }
+}