Merge pull request scala/scala#11063 from lrytz/listBufferLocate

Comment on private ListBuffer.locate [ci: last-only]

Author: som-snytt

library/src/scala/collection/mutable/ListBuffer.scala

@@ -51,7 +51,7 @@ class ListBuffer[A]
   private[this] var aliased = false
   private[this] var len = 0
 
-  private type Predecessor[A0] = ::[A0] /*| Null*/
+  private type Predecessor = ::[A] /*| Null*/
 
   def iterator: Iterator[A] = new MutationTracker.CheckedIterator(first.iterator, mutationCount)
 
@@ -186,7 +186,8 @@ class ListBuffer[A]
       last0 = null
   }
 
-  private def locate(i: Int): Predecessor[A] =
+  // returns the `::` at `i - 1` (such that its `next` at position `i` can be mutated), or `null` if `i == 0`.
+  private def predecessor(i: Int): Predecessor =
     if (i == 0) null
     else if (i == len) last0
     else {
@@ -196,10 +197,10 @@ class ListBuffer[A]
         p = p.tail
         j -= 1
       }
-      p.asInstanceOf[Predecessor[A]]
+      p.asInstanceOf[Predecessor]
     }
 
-  private def getNext(p: Predecessor[A]): List[A] =
+  private def getNext(p: Predecessor): List[A] =
     if (p == null) first else p.next
 
   def update(idx: Int, elem: A): Unit = {
@@ -213,7 +214,7 @@ class ListBuffer[A]
       first = newElem
     } else {
       // `p` can not be `null` because the case where `idx == 0` is handled above
-      val p = locate(idx)
+      val p = predecessor(idx)
       val newElem = new :: (elem, p.tail.tail)
       if (last0 eq p.tail) {
         last0 = newElem
@@ -227,7 +228,7 @@ class ListBuffer[A]
     if (idx < 0 || idx > len) throw CommonErrors.indexOutOfBounds(index = idx, max = len - 1)
     if (idx == len) addOne(elem)
     else {
-      val p = locate(idx)
+      val p = predecessor(idx)
       val nx = elem :: getNext(p)
       if(p eq null) first = nx else p.next = nx
       len += 1
@@ -240,7 +241,7 @@ class ListBuffer[A]
   }
 
   // `fresh` must be a `ListBuffer` that only we have access to
-  private def insertAfter(prev: Predecessor[A], fresh: ListBuffer[A]): Unit = {
+  private def insertAfter(prev: Predecessor, fresh: ListBuffer[A]): Unit = {
     if (!fresh.isEmpty) {
       val follow = getNext(prev)
       if (prev eq null) first = fresh.first else prev.next = fresh.first
@@ -258,15 +259,15 @@ class ListBuffer[A]
       else {
         val fresh = new ListBuffer[A].freshFrom(it)
         ensureUnaliased()
-        insertAfter(locate(idx), fresh)
+        insertAfter(predecessor(idx), fresh)
       }
     }
   }
 
   def remove(idx: Int): A = {
     ensureUnaliased()
     if (idx < 0 || idx >= len) throw CommonErrors.indexOutOfBounds(index = idx, max = len - 1)
-    val p = locate(idx)
+    val p = predecessor(idx)
     val nx = getNext(p)
     if(p eq null) {
       first = nx.tail
@@ -283,12 +284,12 @@ class ListBuffer[A]
     if (count > 0) {
       ensureUnaliased()
       if (idx < 0 || idx + count > len) throw new IndexOutOfBoundsException(s"$idx to ${idx + count} is out of bounds (min 0, max ${len - 1})")
-      removeAfter(locate(idx), count)
+      removeAfter(predecessor(idx), count)
     } else if (count < 0) {
       throw new IllegalArgumentException("removing negative number of elements: " + count)
     }
 
-  private def removeAfter(prev: Predecessor[A], n: Int) = {
+  private def removeAfter(prev: Predecessor, n: Int) = {
     @tailrec def ahead(p: List[A], n: Int): List[A] =
       if (n == 0) p else ahead(p.tail, n - 1)
     val nx = ahead(getNext(prev), n)
@@ -345,7 +346,7 @@ class ListBuffer[A]
    */
   def filterInPlace(p: A => Boolean): this.type = {
     ensureUnaliased()
-    var prev: Predecessor[A] = null
+    var prev: Predecessor = null
     var cur: List[A] = first
     while (!cur.isEmpty) {
       val follow = cur.tail
@@ -354,7 +355,7 @@ class ListBuffer[A]
         else prev.next = follow
         len -= 1
       } else {
-        prev = cur.asInstanceOf[Predecessor[A]]
+        prev = cur.asInstanceOf[Predecessor]
       }
       cur = follow
     }
@@ -378,7 +379,7 @@ class ListBuffer[A]
       ensureUnaliased()
       val i = math.min(_from, _len)
       val n = math.min(_replaced, _len)
-      val p = locate(i)
+      val p = predecessor(i)
       removeAfter(p, math.min(n, _len - i))
       insertAfter(p, fresh)
     }