Renames parameters in ArraySeq and ArrayBuffer

Author: Prithvirajbilla

src/library/scala/collection/mutable/ArrayBuffer.scala

@@ -26,7 +26,7 @@ import java.lang.{IndexOutOfBoundsException, IllegalArgumentException}
   *  @define mayNotTerminateInf
   *  @define willNotTerminateInf
   */
-class ArrayBuffer[A] private (initElems: Array[AnyRef], initSize: Int)
+class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int)
   extends AbstractBuffer[A]
     with IndexedSeq[A]
     with IndexedSeqOps[A, ArrayBuffer, ArrayBuffer[A]]
@@ -35,10 +35,10 @@ class ArrayBuffer[A] private (initElems: Array[AnyRef], initSize: Int)
 
   def this() = this(new Array[AnyRef](16), 0)
 
-  def this(initSize: Int) = this(new Array[AnyRef](initSize), 0)
+  def this(initialSize: Int) = this(new Array[AnyRef](initialSize), 0)
 
-  protected var array: Array[AnyRef] = initElems
-  protected var size0 = initSize
+  protected var array: Array[AnyRef] = initialElements
+  protected var size0 = initialSize
 
   /** Ensure that the internal array has at least `n` cells. */
   protected def ensureSize(n: Int): Unit =
@@ -63,9 +63,9 @@ class ArrayBuffer[A] private (initElems: Array[AnyRef], initSize: Int)
     array(n).asInstanceOf[A]
   }
 
-  def update(n: Int, elem: A): Unit = {
-    checkWithinBounds(n, n + 1)
-    array(n) = elem.asInstanceOf[AnyRef]
+  def update(@deprecatedName('n, "2.13.0") index: Int, elem: A): Unit = {
+    checkWithinBounds(index, index + 1)
+    array(index) = elem.asInstanceOf[AnyRef]
   }
 
   def length = size0
@@ -96,55 +96,55 @@ class ArrayBuffer[A] private (initElems: Array[AnyRef], initSize: Int)
     this
   }
 
-  def insert(idx: Int, elem: A): Unit = {
-    checkWithinBounds(idx, idx)
+  def insert(@deprecatedName('n, "2.13.0") index: Int, elem: A): Unit = {
+    checkWithinBounds(index, index)
     ensureSize(size0 + 1)
-    Array.copy(array, idx, array, idx + 1, size0 - idx)
+    Array.copy(array, index, array, index + 1, size0 - index)
     size0 += 1
-    this(idx) = elem
+    this(index) = elem
   }
 
   def prepend(elem: A): this.type = {
     insert(0, elem)
     this
   }
 
-  def insertAll(idx: Int, elems: IterableOnce[A]): Unit = {
-    checkWithinBounds(idx, idx)
+  def insertAll(@deprecatedName('n, "2.13.0") index: Int, elems: IterableOnce[A]): Unit = {
+    checkWithinBounds(index, index)
     elems match {
       case elems: collection.Iterable[A] =>
         val elemsLength = elems.size
         ensureSize(length + elemsLength)
-        Array.copy(array, idx, array, idx + elemsLength, size0 - idx)
+        Array.copy(array, index, array, index + elemsLength, size0 - index)
         size0 = size0 + elemsLength
         elems match {
           case elems: ArrayBuffer[_] =>
-            Array.copy(elems.array, 0, array, idx, elemsLength)
+            Array.copy(elems.array, 0, array, index, elemsLength)
           case _ =>
             var i = 0
             val it = elems.iterator
             while (i < elemsLength) {
-              this(idx + i) = it.next()
+              this(index + i) = it.next()
               i += 1
             }
         }
       case _ =>
-        insertAll(idx, ArrayBuffer.from(elems))
+        insertAll(index, ArrayBuffer.from(elems))
     }
   }
 
-  def remove(idx: Int): A = {
-    checkWithinBounds(idx, idx + 1)
-    val res = this(idx)
-    Array.copy(array, idx + 1, array, idx, size0 - (idx + 1))
+  def remove(@deprecatedName('n, "2.13.0") index: Int): A = {
+    checkWithinBounds(index, index + 1)
+    val res = this(index)
+    Array.copy(array, index + 1, array, index, size0 - (index + 1))
     reduceToSize(size0 - 1)
     res
   }
 
-  def remove(idx: Int, count: Int): Unit =
+  def remove(@deprecatedName('n, "2.13.0") index: Int, count: Int): Unit =
     if (count > 0) {
-      checkWithinBounds(idx, idx + count)
-      Array.copy(array, idx + count, array, idx, size0 - (idx + count))
+      checkWithinBounds(index, index + count)
+      Array.copy(array, index + count, array, index, size0 - (index + count))
       reduceToSize(size0 - count)
     } else if (count < 0) {
       throw new IllegalArgumentException("removing negative number of elements: " + count)

src/library/scala/collection/mutable/ArraySeq.scala

@@ -48,7 +48,7 @@ abstract class ArraySeq[T]
   def elemTag: ClassTag[_]
 
   /** Update element at given index */
-  def update(index: Int, elem: T): Unit
+  def update(@deprecatedName('idx, "2.13.0") index: Int, elem: T): Unit
 
   /** The underlying array. Its element type does not have to be equal to the element type of this ArraySeq. A primitive
     * ArraySeq can be backed by an array of boxed values and a reference ArraySeq can be backed by an array of a supertype

test/junit/scala/collection/mutable/ArrayBufferTest.scala

@@ -156,39 +156,39 @@ class ArrayBufferTest {
 
   @Test
   def testRemoveMany: Unit = {
-    def testRemoveMany(idx: Int, count: Int, expectation: ArrayBuffer[Int]): Unit = {
+    def testRemoveMany(index: Int, count: Int, expectation: ArrayBuffer[Int]): Unit = {
       val buffer = ArrayBuffer(0, 1, 2)
-      buffer.remove(idx, count)
+      buffer.remove(index, count)
       assertEquals(expectation, buffer)
     }
 
-    testRemoveMany(idx = 0, count = 0, expectation = ArrayBuffer(0, 1, 2))
-    testRemoveMany(idx = 0, count = 1, expectation = ArrayBuffer(1, 2))
-    testRemoveMany(idx = 0, count = 2, expectation = ArrayBuffer(2))
-    testRemoveMany(idx = 0, count = 3, expectation = ArrayBuffer())
-    testRemoveMany(idx = 1, count = 1, expectation = ArrayBuffer(0, 2))
-    testRemoveMany(idx = 1, count = 2, expectation = ArrayBuffer(0))
-    testRemoveMany(idx = 2, count = 1, expectation = ArrayBuffer(0, 1))
+    testRemoveMany(index = 0, count = 0, expectation = ArrayBuffer(0, 1, 2))
+    testRemoveMany(index = 0, count = 1, expectation = ArrayBuffer(1, 2))
+    testRemoveMany(index = 0, count = 2, expectation = ArrayBuffer(2))
+    testRemoveMany(index = 0, count = 3, expectation = ArrayBuffer())
+    testRemoveMany(index = 1, count = 1, expectation = ArrayBuffer(0, 2))
+    testRemoveMany(index = 1, count = 2, expectation = ArrayBuffer(0))
+    testRemoveMany(index = 2, count = 1, expectation = ArrayBuffer(0, 1))
   }
 
   @Test(expected = classOf[IndexOutOfBoundsException])
   def testRemoveManyWithNegativeIndex: Unit = {
-    ArrayBuffer(0, 1, 2).remove(idx = -1, count = 1)
+    ArrayBuffer(0, 1, 2).remove(index = -1, count = 1)
   }
 
   @Test(expected = classOf[IndexOutOfBoundsException])
   def testRemoveManyWithTooLargeIndex: Unit = {
-    ArrayBuffer(0).remove(idx = 1, count = 1)
+    ArrayBuffer(0).remove(index = 1, count = 1)
   }
 
   @Test(expected = classOf[IllegalArgumentException])
   def testRemoveManyWithNegativeCount: Unit = {
-    ArrayBuffer(0).remove(idx = 0, count = -1)
+    ArrayBuffer(0).remove(index = 0, count = -1)
   }
 
   @Test(expected = classOf[IndexOutOfBoundsException])
   def testRemoveManyWithTooLargeCount: Unit = {
-    ArrayBuffer(0).remove(idx = 0, count = 100)
+    ArrayBuffer(0).remove(index = 0, count = 100)
   }
 
   @Test