ArrayBuilder, ArrayOps, WrappedArray are added/updated for arrays of value classes

Author: VladimirNik

src/dotty/DottyPredef.scala

@@ -2,9 +2,7 @@ package dotty
 
 import scala.reflect.runtime.universe.TypeTag
 import scala.reflect.ClassTag
-import scala.collection.mutable.ArrayOps
-import scala.runtime.ScalaRunTime.arrayElementClass
-import scala.collection.mutable.WrappedArray
+import scala.collection.mutable.{ArrayOps, WrappedArray}
 import dotty.runtime.vc._
 import scala.Predef.???
 
@@ -15,17 +13,8 @@ object DottyPredef {
   implicit def arrayTag[T](implicit ctag: ClassTag[T]): ClassTag[Array[T]] =
     ctag.wrap
 
-  def wrapVCArray[T](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
-      }
-    }
-  }
+  def wrapVCArray[T](xs: Array[T]): WrappedArray[T] =
+    new VCWrappedArray[T](xs)
 
   //def to substitute scala.Predef.genericWrapArray
   def genericWrapArray2[T](xs: Array[T]): WrappedArray[T] = {
@@ -39,19 +28,8 @@ object DottyPredef {
     }
   }
 
-  def refVCArray[T /*<: AnyVal*/](xs: Array[T]): ArrayOps[T] = {
-    new ArrayOps[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
-      }
-      //TODO - add the implementation for newBuilder
-      def newBuilder = ???
-    }
-  }
+  def refVCArray[T /*<: AnyVal*/](xs: Array[T]): ArrayOps[T] =
+    new VCArrayOps[T](xs)
 
   //def to substitute scala.Predef.genericArrayOps
   def genericArrayOps2[T](xs: Array[T]): ArrayOps[T] = (xs match {

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
+  }
+
+  override def ++=(xs: TraversableOnce[T]): this.type = (xs.asInstanceOf[AnyRef]) match {
+    case xs: VCWrappedArray[_] =>
+      ensureSize(this.size + xs.length)
+      //TODO: check correctness
+      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,32 @@
+package dotty.runtime.vc
+
+import scala.collection.mutable.{WrappedArray, ArrayBuilder, ArrayOps}
+import scala.reflect.ClassTag
+import dotty.DottyPredef._
+
+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 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)
+}

src/dotty/runtime/vc/VCWrappedArray.scala

@@ -0,0 +1,26 @@
+package dotty.runtime.vc
+
+import scala.collection.mutable.WrappedArray
+import scala.reflect.ClassTag
+
+class VCWrappedArray[T](xs: Array[T]) extends WrappedArray[T] {
+  val array = xs
+  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]]
+  }
+  //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
+  }
+}

tests/run/valueclasses-array-functions.check

@@ -5,3 +5,6 @@ X-7
 X-9
 X-11
 X-32
+List(X-11)
+r6: Set(X-7, X-9, X-11)
+r7: List(X-7, X-9, X-11)

tests/run/valueclasses-array-functions.scala

@@ -10,7 +10,14 @@ object Test {
     val r1 = for (y <- test) { println(y) }
     val r2 = test foreach ( x => println(x.toString) )
     val r3 = test.foldLeft(new X(5))((x, y) => new X(x.a + y.a))
+    val r4 = test filter ( x => x.toString.contains("1") )
+    val r5 = r4.toList
     println(r3)
+    println(r5)
+    val r6 = test.toSet
+    println(s"r6: $r6")
+    val r7 = test.toList
+    println(s"r7: $r7")
 
     val t1: ArrayOps[X] = Array(new X(7))
   }