Rename WrappedArray to ArraySeq

Author: lrytz

spec/12-the-scala-standard-library.md

@@ -427,13 +427,13 @@ operations on an array `xs`:
 
 Two implicit conversions exist in `Predef` that are frequently applied to arrays:
 a conversion to `scala.collection.mutable.ArrayOps` and a conversion to
-`scala.collection.mutable.WrappedArray` (a subtype of `scala.collection.Seq`).
+`scala.collection.mutable.ArraySeq` (a subtype of `scala.collection.Seq`).
 
 Both types make many of the standard operations found in the Scala
 collections API available. The conversion to `ArrayOps` is temporary, as all operations
-defined on `ArrayOps` return a value of type `Array`, while the conversion to `WrappedArray`
-is permanent as all operations return a value of type `WrappedArray`.
-The conversion to `ArrayOps` takes priority over the conversion to `WrappedArray`.
+defined on `ArrayOps` return a value of type `Array`, while the conversion to `ArraySeq`
+is permanent as all operations return a value of type `ArraySeq`.
+The conversion to `ArrayOps` takes priority over the conversion to `ArraySeq`.
 
 Because of the tension between parametrized types in Scala and the ad-hoc
 implementation of arrays in the host-languages, some subtle points
@@ -739,9 +739,9 @@ The available low-priority implicits include definitions falling into the follow
     can be implicitly converted to instances of class `runtime.RichInt`.
 
 1.  For every array type with elements of primitive type, a wrapper that
-    takes the arrays of that type to instances of a `runtime.WrappedArray` class. For instance, values of type `Array[Float]` can be implicitly converted to instances of class `runtime.WrappedArray[Float]`.
+    takes the arrays of that type to instances of a `ArraySeq` class. For instance, values of type `Array[Float]` can be implicitly converted to instances of class `ArraySeq[Float]`.
     There are also generic array wrappers that take elements
-    of type `Array[T]` for arbitrary `T` to `WrappedArray`s.
+    of type `Array[T]` for arbitrary `T` to `ArraySeq`s.
 
 1.  An implicit conversion from `String` to `WrappedString`.
 

src/compiler/scala/tools/nsc/ast/TreeGen.scala

@@ -122,9 +122,9 @@ abstract class TreeGen extends scala.reflect.internal.TreeGen with TreeDSL {
   def mkForwarder(target: Tree, vparamss: List[List[Symbol]]) =
     (target /: vparamss)((fn, vparams) => Apply(fn, vparams map paramToArg))
 
-  /** Applies a wrapArray call to an array, making it a WrappedArray or ArraySeq suitable for Scala varargs.
-   *  Don't let a reference type parameter be inferred, in case it's a singleton:
-   *  apply the element type directly.
+  /** Applies a wrapArray call to an array, making it a mutable (old collections) or immutable
+   * (new collections) ArraySeq suitable for Scala varargs. Don't let a reference type parameter be
+   * inferred, in case it's a singleton: apply the element type directly.
    */
   def mkWrapVarargsArray(tree: Tree, elemtp: Type) = {
     mkMethodCall(

src/library/scala/Array.scala

@@ -498,7 +498,7 @@ object Array {
     // !!! the null check should to be necessary, but without it 2241 fails. Seems to be a bug
     // in pattern matcher.  @PP: I noted in #4364 I think the behavior is correct.
     // Is ArraySeq safe here? In 2.12 we used to call .toIndexedSeq which copied the array
-    // instead of wrapping it in a WrappedArray but it appears unnecessary.
+    // instead of wrapping it in a ArraySeq but it appears unnecessary.
 }
 
 /** Arrays are mutable, indexed collections of values. `Array[T]` is Scala's representation
@@ -518,12 +518,12 @@ object Array {
  *
  *  Two implicit conversions exist in [[scala.Predef]] that are frequently applied to arrays: a conversion
  *  to [[scala.collection.mutable.ArrayOps]] (shown on line 4 of the example above) and a conversion
- *  to [[scala.collection.mutable.WrappedArray]] (a subtype of [[scala.collection.Seq]]).
+ *  to [[scala.collection.mutable.ArraySeq]] (a subtype of [[scala.collection.Seq]]).
  *  Both types make available many of the standard operations found in the Scala collections API.
  *  The conversion to `ArrayOps` is temporary, as all operations defined on `ArrayOps` return an `Array`,
- *  while the conversion to `WrappedArray` is permanent as all operations return a `WrappedArray`.
+ *  while the conversion to `ArraySeq` is permanent as all operations return a `ArraySeq`.
  *
- *  The conversion to `ArrayOps` takes priority over the conversion to `WrappedArray`. For instance,
+ *  The conversion to `ArrayOps` takes priority over the conversion to `ArraySeq`. For instance,
  *  consider the following code:
  *
  *  {{{
@@ -534,8 +534,8 @@ object Array {
  *
  *  Value `arrReversed` will be of type `Array[Int]`, with an implicit conversion to `ArrayOps` occurring
  *  to perform the `reverse` operation. The value of `seqReversed`, on the other hand, will be computed
- *  by converting to `WrappedArray` first and invoking the variant of `reverse` that returns another
- *  `WrappedArray`.
+ *  by converting to `ArraySeq` first and invoking the variant of `reverse` that returns another
+ *  `ArraySeq`.
  *
  *  @author Martin Odersky
  *  @version 1.0

src/library/scala/Predef.scala

@@ -103,9 +103,9 @@ import scala.annotation.elidable.ASSERTION
  * @groupprio conversions-anyval-to-java 100
  * @groupdesc conversions-anyval-to-java Implicit conversion from Scala AnyVals to Java primitive wrapper types equivalents.
  *
- * @groupname conversions-array-to-wrapped-array Array to WrappedArray
+ * @groupname conversions-array-to-wrapped-array Array to ArraySeq
  * @groupprio conversions-array-to-wrapped-array 110
- * @groupdesc conversions-array-to-wrapped-array Conversions from Arrays to WrappedArrays.
+ * @groupdesc conversions-array-to-wrapped-array Conversions from Arrays to ArraySeqs.
  */
 object Predef extends LowPriorityImplicits {
   /**
@@ -745,7 +745,7 @@ object Predef extends LowPriorityImplicits {
 // cyclic reference errors compiling the standard library *without* a previously
 // compiled copy on the classpath.
 private[scala] abstract class LowPriorityImplicits extends LowPriorityImplicits2 {
-  import mutable.WrappedArray
+  import mutable.ArraySeq
   //import immutable.WrappedString
 
   /** We prefer the java.lang.* boxed types to these wrappers in
@@ -768,38 +768,38 @@ private[scala] abstract class LowPriorityImplicits extends LowPriorityImplicits2
   @inline implicit def booleanWrapper(x: Boolean) = new runtime.RichBoolean(x)
 
   /** @group conversions-array-to-wrapped-array */
-  implicit def genericWrapArray[T](xs: Array[T]): WrappedArray[T] =
+  implicit def genericWrapArray[T](xs: Array[T]): ArraySeq[T] =
     if (xs eq null) null
-    else WrappedArray.make(xs)
+    else ArraySeq.make(xs)
 
   // Since the JVM thinks arrays are covariant, one 0-length Array[AnyRef]
   // is as good as another for all T <: AnyRef.  Instead of creating 100,000,000
   // unique ones by way of this implicit, let's share one.
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapRefArray[T <: AnyRef](xs: Array[T]): WrappedArray.ofRef[T] = {
+  implicit def wrapRefArray[T <: AnyRef](xs: Array[T]): ArraySeq.ofRef[T] = {
     if (xs eq null) null
-    else if (xs.length == 0) WrappedArray.empty[AnyRef].asInstanceOf[WrappedArray.ofRef[T]]
-    else new WrappedArray.ofRef[T](xs)
+    else if (xs.length == 0) ArraySeq.empty[AnyRef].asInstanceOf[ArraySeq.ofRef[T]]
+    else new ArraySeq.ofRef[T](xs)
   }
 
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapIntArray(xs: Array[Int]): WrappedArray.ofInt = if (xs ne null) new WrappedArray.ofInt(xs) else null
+  implicit def wrapIntArray(xs: Array[Int]): ArraySeq.ofInt = if (xs ne null) new ArraySeq.ofInt(xs) else null
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapDoubleArray(xs: Array[Double]): WrappedArray.ofDouble = if (xs ne null) new WrappedArray.ofDouble(xs) else null
+  implicit def wrapDoubleArray(xs: Array[Double]): ArraySeq.ofDouble = if (xs ne null) new ArraySeq.ofDouble(xs) else null
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapLongArray(xs: Array[Long]): WrappedArray.ofLong = if (xs ne null) new WrappedArray.ofLong(xs) else null
+  implicit def wrapLongArray(xs: Array[Long]): ArraySeq.ofLong = if (xs ne null) new ArraySeq.ofLong(xs) else null
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapFloatArray(xs: Array[Float]): WrappedArray.ofFloat = if (xs ne null) new WrappedArray.ofFloat(xs) else null
+  implicit def wrapFloatArray(xs: Array[Float]): ArraySeq.ofFloat = if (xs ne null) new ArraySeq.ofFloat(xs) else null
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapCharArray(xs: Array[Char]): WrappedArray.ofChar = if (xs ne null) new WrappedArray.ofChar(xs) else null
+  implicit def wrapCharArray(xs: Array[Char]): ArraySeq.ofChar = if (xs ne null) new ArraySeq.ofChar(xs) else null
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapByteArray(xs: Array[Byte]): WrappedArray.ofByte = if (xs ne null) new WrappedArray.ofByte(xs) else null
+  implicit def wrapByteArray(xs: Array[Byte]): ArraySeq.ofByte = if (xs ne null) new ArraySeq.ofByte(xs) else null
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapShortArray(xs: Array[Short]): WrappedArray.ofShort = if (xs ne null) new WrappedArray.ofShort(xs) else null
+  implicit def wrapShortArray(xs: Array[Short]): ArraySeq.ofShort = if (xs ne null) new ArraySeq.ofShort(xs) else null
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapBooleanArray(xs: Array[Boolean]): WrappedArray.ofBoolean = if (xs ne null) new WrappedArray.ofBoolean(xs) else null
+  implicit def wrapBooleanArray(xs: Array[Boolean]): ArraySeq.ofBoolean = if (xs ne null) new ArraySeq.ofBoolean(xs) else null
   /** @group conversions-array-to-wrapped-array */
-  implicit def wrapUnitArray(xs: Array[Unit]): WrappedArray.ofUnit = if (xs ne null) new WrappedArray.ofUnit(xs) else null
+  implicit def wrapUnitArray(xs: Array[Unit]): ArraySeq.ofUnit = if (xs ne null) new ArraySeq.ofUnit(xs) else null
 
   /** @group conversions-string */
   implicit def wrapString(s: String): WrappedString = if (s ne null) new WrappedString(s) else null

src/library/scala/collection/ArrayOps.scala

@@ -1,9 +1,8 @@
 package scala
 package collection
 
-import java.lang.{String, Class}
-import mutable.{ArrayBuilder, WrappedArray}
-import immutable.{ArraySeq, Range}
+import mutable.ArrayBuilder
+import immutable.Range
 import scala.reflect.ClassTag
 import scala.math.{max, min, Ordering}
 
@@ -111,13 +110,12 @@ object ArrayOps {
   *  the implicit conversion to `ArrayOps` when calling a method (which does not actually
   *  allocate an instance of `ArrayOps` because it is a value class).
   *
-  *  Neither Array` nor `ArrayOps` are proper collection types
-  *  (i.e. they do not extend `Iterable` or even `IterableOnce`). `WrappedArray` and
-  *  `ArraySeq` serve this purpose.
+  *  Neither `Array` nor `ArrayOps` are proper collection types
+  *  (i.e. they do not extend `Iterable` or even `IterableOnce`). `mutable.ArraySeq` and
+  *  `immutable.ArraySeq` serve this purpose.
   *
-  *  The difference between this class and `WrappedArray` and `ArraySeq` is that calling
-  *  transformer methods such as `filter` and `map` will yield an array, whereas a `WrappedArray`
-  *  will remain a `WrappedArray`.
+  *  The difference between this class and `ArraySeq`s is that calling transformer methods such as
+ *   `filter` and `map` will yield an array, whereas an `ArraySeq` will remain an `ArraySeq`.
   *
   *  @since 2.8
   *
@@ -974,7 +972,7 @@ final class ArrayOps[A](val xs: Array[A]) extends AnyVal {
     *                ''n'' times in `that`, then the first ''n'' occurrences of `x` will not form
     *                part of the result, but any following occurrences will.
     */
-  def diff(that: Seq[_ >: A]): Array[A] = WrappedArray.make(xs).diff(that).array
+  def diff(that: Seq[_ >: A]): Array[A] = mutable.ArraySeq.make(xs).diff(that).array
 
   /** Computes the multiset intersection between this array and another sequence.
     *
@@ -985,7 +983,7 @@ final class ArrayOps[A](val xs: Array[A]) extends AnyVal {
     *                ''n'' times in `that`, then the first ''n'' occurrences of `x` will be retained
     *                in the result, but any following occurrences will be omitted.
     */
-  def intersect(that: Seq[_ >: A]): Array[A] = WrappedArray.make(xs).intersect(that).array
+  def intersect(that: Seq[_ >: A]): Array[A] = mutable.ArraySeq.make(xs).intersect(that).array
 
   /** Partitions this array into a map of arrays according to some discriminator function.
     *
@@ -1015,5 +1013,5 @@ final class ArrayOps[A](val xs: Array[A]) extends AnyVal {
   @`inline` final def toSeq: immutable.Seq[A] = toIndexedSeq
 
   def toIndexedSeq: immutable.IndexedSeq[A] =
-    ArraySeq.unsafeWrapArray(Array.copyOf(xs, xs.length))
+    immutable.ArraySeq.unsafeWrapArray(Array.copyOf(xs, xs.length))
 }

src/library/scala/collection/Factory.scala

@@ -588,7 +588,7 @@ object ClassTagIterableFactory {
 }
 
 /**
-  * @tparam CC Collection type constructor (e.g. `WrappedArray`)
+  * @tparam CC Collection type constructor (e.g. `ArraySeq`)
   */
 trait ClassTagSeqFactory[+CC[_]] extends ClassTagIterableFactory[CC] {
   def unapplySeq[A](x: CC[A] @uncheckedVariance): Some[CC[A]] = Some(x) //TODO is uncheckedVariance sound here?

src/library/scala/collection/generic/IsIterableLike.scala

@@ -117,7 +117,7 @@ object IsIterableLike {
     new IsIterableLike[Array[A0]] {
       type A = A0
       val conversion: Array[A] => IterableOps[A, Iterable, Array[A]] = a => new IterableOps[A, Iterable, Array[A]] {
-        def toIterable: Iterable[A] = mutable.WrappedArray.make(a)
+        def toIterable: Iterable[A] = mutable.ArraySeq.make(a)
         protected def coll: Array[A] = a
         protected def fromSpecificIterable(coll: Iterable[A]): Array[A] = Array.from(coll)
         def iterableFactory: IterableFactory[Iterable] = Iterable