review feedback - use the ClassTag to hold the empty Arrays and WrappedArray

Author: mkeskells

library/src/scala/Array.scala

@@ -51,10 +51,6 @@ class FallbackArrayBuilding {
  *  @since  1.0
  */
 object Array extends FallbackArrayBuilding {
-  private val emptyArrays = new ClassValue[AnyRef] {
-    override def computeValue(cls: Class[_]): AnyRef =
-      java.lang.reflect.Array.newInstance(cls, 0)
-  }
 
   val emptyBooleanArray = empty[Boolean]
   val emptyByteArray    = empty[Byte]
@@ -188,8 +184,7 @@ object Array extends FallbackArrayBuilding {
 
   /** Returns an array of length 0 */
   def empty[T: ClassTag]: Array[T] =  {
-    val cls = implicitly[ClassTag[T]].runtimeClass.asInstanceOf[Class[T]]
-    emptyArrays.get(cls).asInstanceOf[Array[T]]
+    implicitly[ClassTag[T]].emptyArray
   }
   /** Creates an array with given elements.
    *

library/src/scala/collection/mutable/WrappedArrayBuilder.scala

@@ -35,7 +35,7 @@ class WrappedArrayBuilder[A](tag: ClassTag[A]) extends ReusableBuilder[A, Wrappe
   private var size: Int = 0
 
   private def mkArray(size: Int): WrappedArray[A] = {
-    if (size == 0) WrappedArrayBuilder.emptyWrappedArray(tag)
+    if (size == 0) tag.emptyWrappedArray
     else {
       import java.util.Arrays.copyOf
       val runtimeClass = tag.runtimeClass
@@ -111,25 +111,4 @@ class WrappedArrayBuilder[A](tag: ClassTag[A]) extends ReusableBuilder[A, Wrappe
   }
 
   // todo: add ++=
-}
-private [mutable] object WrappedArrayBuilder {
-  private def emptyWrappedArray[T](tag: ClassTag[T]): mutable.WrappedArray[T] =
-    emptyClass.get(tag.runtimeClass).asInstanceOf[WrappedArray[T]]
-  private[this] val emptyClass = new ClassValue[WrappedArray[_]] {
-    override def computeValue(cls: Class[_]): WrappedArray[_] = {
-      if (cls.isPrimitive)
-        cls match {
-          case java.lang.Integer.TYPE   => new WrappedArray.ofInt(Array.emptyIntArray)
-          case java.lang.Double.TYPE    => new WrappedArray.ofDouble(Array.emptyDoubleArray)
-          case java.lang.Long.TYPE      => new WrappedArray.ofLong(Array.emptyLongArray)
-          case java.lang.Float.TYPE     => new WrappedArray.ofFloat(Array.emptyFloatArray)
-          case java.lang.Character.TYPE => new WrappedArray.ofChar(Array.emptyCharArray)
-          case java.lang.Byte.TYPE      => new WrappedArray.ofByte(Array.emptyByteArray)
-          case java.lang.Short.TYPE     => new WrappedArray.ofShort(Array.emptyShortArray)
-          case java.lang.Boolean.TYPE   => new WrappedArray.ofBoolean(Array.emptyBooleanArray)
-          case java.lang.Void.TYPE      => new WrappedArray.ofUnit(Array.emptyUnitArray)
-        }
-      else new WrappedArray.ofRef(Array.empty[AnyRef])
-    }
-  }
-}
+}

library/src/scala/reflect/ClassTag.scala

@@ -15,6 +15,9 @@ package reflect
 
 import java.lang.{ Class => jClass }
 
+import scala.collection.mutable
+import scala.runtime.BoxedUnit
+
 /**
  *
  * A `ClassTag[T]` stores the erased class of a given type `T`, accessible via the `runtimeClass`
@@ -46,6 +49,15 @@ import java.lang.{ Class => jClass }
  */
 @scala.annotation.implicitNotFound(msg = "No ClassTag available for ${T}")
 trait ClassTag[T] extends ClassManifestDeprecatedApis[T] with Equals with Serializable {
+
+  @transient private[scala] lazy val emptyArray       : Array[T]                = {
+    val componentType =
+      if (runtimeClass eq classOf[Void]) classOf[BoxedUnit] else runtimeClass
+    java.lang.reflect.Array.newInstance(componentType, 0).asInstanceOf[Array[T]]
+  }
+  @transient private[scala] lazy val emptyWrappedArray: mutable.WrappedArray[T] =
+    mutable.WrappedArray.make[T](emptyArray)
+
   // please, don't add any APIs here, like it was with `newWrappedArray` and `newArrayBuilder`
   // class tags, and all tags in general, should be as minimalistic as possible
 
@@ -151,7 +163,8 @@ object ClassTag {
   @SerialVersionUID(1L)
   private class GenericClassTag[T](val runtimeClass: jClass[_]) extends ClassTag[T] {
     override def newArray(len: Int): Array[T] = {
-      java.lang.reflect.Array.newInstance(runtimeClass, len).asInstanceOf[Array[T]]
+      if (len == 0) emptyArray
+      else java.lang.reflect.Array.newInstance(runtimeClass, len).asInstanceOf[Array[T]]
     }
   }