[work in progress] Arrays of value classes

src/dotty/DottyPredef.scala

@@ -1,7 +1,10 @@
 package dotty
 
+import scala.collection.generic.CanBuildFrom
 import scala.reflect.runtime.universe.TypeTag
 import scala.reflect.ClassTag
+import scala.collection.mutable.{ArrayBuilder, ArrayOps, WrappedArray}
+import dotty.runtime.vc._
 import scala.Predef.???
 import scala.collection.Seq
 
@@ -42,4 +45,10 @@ object DottyPredef {
   implicit def eqNumFloat : Eq[Number, Float]  = Eq
   implicit def eqDoubleNum: Eq[Double, Number] = Eq
   implicit def eqNumDouble: Eq[Number, Double] = Eq
+
+  def wrapVCArray[T](xs: Array[T]): WrappedArray[T] =
+    new VCWrappedArray[T](xs)
+
+  def opsVCArray[T /*<: AnyVal*/](xs: Array[T]): ArrayOps[T] =
+    new VCArrayOps[T](xs)
 }

src/dotty/runtime/vc/VCArrayBuilder.scala

@@ -0,0 +1,69 @@
+package dotty.runtime.vc
+
+import scala.collection.TraversableOnce
+import scala.collection.mutable.ArrayBuilder
+import scala.reflect.ClassTag
+
+class VCArrayBuilder[T](implicit ct: ClassTag[T]) extends ArrayBuilder[T] {
+
+  private var elems: Array[T] = _
+  private var capacity: Int = 0
+  private var size: Int = 0
+
+  private def mkArray(size: Int): Array[T] = {
+    val newelems = new Array[T](size)
+    if (this.size > 0) Array.copy(elems, 0, newelems, 0, this.size)
+    newelems
+  }
+
+  private def resize(size: Int) = {
+    elems = mkArray(size)
+    capacity = size
+  }
+
+  override def sizeHint(size: Int) = {
+    if (capacity < size) resize(size)
+  }
+
+  private def ensureSize(size: Int) = {
+    if (capacity < size || capacity == 0) {
+      var newsize = if (capacity == 0) 16 else capacity * 2
+      while (newsize < size) newsize *= 2
+      resize(newsize)
+    }
+  }
+
+  def +=(elem: T): this.type = {
+    ensureSize(size + 1)
+    elems(size) = elem
+    size += 1
+    this
+  }
+
+  //use impl from Growable
+//  override def ++=(xs: TraversableOnce[T]): this.type = (xs.asInstanceOf[AnyRef]) match {
+//    case xs: VCWrappedArray[_] =>
+//      ensureSize(this.size + xs.length)
+//      Array.copy(xs.array, 0, elems, this.size, xs.length)
+//      size += xs.length
+//      this
+//    case _ =>
+//      super.++=(xs)
+//  }
+
+  def clear() = {
+    size = 0
+  }
+
+  def result() = {
+    if (capacity != 0 && capacity == size) elems
+    else mkArray(size)
+  }
+
+  override def equals(other: Any): Boolean = other match {
+    case x: VCArrayBuilder[_] => (size == x.size) && (elems == x.elems)
+    case _ => false
+  }
+
+  override def toString = "ArrayBuilder.ofVC"
+}

src/dotty/runtime/vc/VCArrayOps.scala

@@ -0,0 +1,46 @@
+package dotty.runtime.vc
+
+import scala.collection.mutable.{Builder, WrappedArray, ArrayBuilder, ArrayOps}
+import scala.reflect.ClassTag
+import dotty.DottyPredef._
+
+import scala.runtime.ScalaRunTime._
+
+class VCArrayOps[T](xs: Array[T]) extends ArrayOps[T] {
+  val array = xs
+  def length: Int = array.length
+  def apply(index: Int): T = array(index)
+  def update(index: Int, elem: T) = {
+    array(index) = elem
+  }
+
+  lazy val elemTag = (xs.asInstanceOf[Object]: @unchecked) match {
+    case vc: VCIntArray[_] => vc.ct.asInstanceOf[ClassTag[T]]
+    case vc: VCShortArray[_] => vc.ct.asInstanceOf[ClassTag[T]]
+    case vc: VCLongArray[_] => vc.ct.asInstanceOf[ClassTag[T]]
+    case vc: VCFloatArray[_] => vc.ct.asInstanceOf[ClassTag[T]]
+    case vc: VCDoubleArray[_] => vc.ct.asInstanceOf[ClassTag[T]]
+    case vc: VCByteArray[_] => vc.ct.asInstanceOf[ClassTag[T]]
+    case vc: VCBooleanArray[_] => vc.ct.asInstanceOf[ClassTag[T]]
+    case vc: VCCharArray[_] => vc.ct.asInstanceOf[ClassTag[T]]
+    case vc: VCObjectArray[_] => vc.ct.asInstanceOf[ClassTag[T]]
+  }
+
+  override def repr = xs
+
+  override protected[this] def newBuilder = new VCArrayBuilder[T]()(elemTag).asInstanceOf[ArrayBuilder[T]]
+  //override protected[this] def newBuilder = new ArrayBuilder.ofRef[T]()(ClassTag[T](arrayElementClass(repr.getClass)))
+
+  override protected[this] def thisCollection: WrappedArray[T] = wrapVCArray(xs)
+  override protected[this] def toCollection(repr: Array[T]): WrappedArray[T] = wrapVCArray(xs)
+
+  final def vcElementClass: Class[_] = arrayElementClass(elemTag)
+
+  override def toArray[U >: T : ClassTag]: Array[U] = {
+    val thatElementClass = arrayElementClass(implicitly[ClassTag[U]])
+    if (vcElementClass eq thatElementClass)
+      repr.asInstanceOf[Array[U]]
+    else
+      super.toArray[U]
+  }
+}