Add ArrayBuffer and GrowableBuilder to stdlib

Author: odersky

tests/pos-custom-args/captures/sealed-lowerbound.scala

@@ -0,0 +1,12 @@
+def foo[sealed B](x: B): B = x
+
+def bar[B, sealed A >: B](x: A): A = foo[A](x)
+
+class C[sealed A]
+
+class CV[sealed A](x: Int):
+  def this() = this:
+    val x = new C[A]:
+      println("foo")
+    0
+

tests/pos-special/stdlib/collection/IterableOnce.scala

@@ -162,7 +162,7 @@ final class IterableOnceExtensionMethods[A](private val it: IterableOnce[A]) ext
   def to[C1](factory: Factory[A, C1]): C1 = factory.fromSpecific(it)
 
   @deprecated("Use .iterator.to(ArrayBuffer) instead", "2.13.0")
-  def toBuffer[B >: A]: mutable.Buffer[B] = mutable.ArrayBuffer.from(it)
+  def toBuffer[sealed B >: A]: mutable.Buffer[B] = mutable.ArrayBuffer.from(it)
 
   @deprecated("Use .iterator.toArray", "2.13.0")
   def toArray[B >: A: ClassTag]: Array[B] = it match {
@@ -272,7 +272,7 @@ object IterableOnce {
     math.max(math.min(math.min(len, srcLen), destLen - start), 0)
 
   /** Calls `copyToArray` on the given collection, regardless of whether or not it is an `Iterable`. */
-  @inline private[collection] def copyElemsToArray[A, B >: A](elems: IterableOnce[A],
+  @inline private[collection] def copyElemsToArray[A, B >: A](elems: IterableOnce[A]^,
                                                               xs: Array[B],
                                                               start: Int = 0,
                                                               len: Int = Int.MaxValue): Int =
@@ -1312,7 +1312,7 @@ trait IterableOnceOps[+A, +CC[_], +C] extends Any { this: IterableOnce[A]^ =>
   @deprecated("Use .to(LazyList) instead of .toStream", "2.13.0")
   @`inline` final def toStream: immutable.Stream[A] = to(immutable.Stream)
 
-  @`inline` final def toBuffer[B >: A]: mutable.Buffer[B] = mutable.Buffer.from(this)
+  @`inline` final def toBuffer[sealed B >: A]: mutable.Buffer[B] = mutable.Buffer.from(this)
 
   /** Convert collection to array.
     *

tests/pos-special/stdlib/collection/Iterator.scala

@@ -18,6 +18,7 @@ import scala.annotation.unchecked.{uncheckedVariance, uncheckedCaptures}
 import scala.runtime.Statics
 import language.experimental.captureChecking
 import caps.unsafe.unsafeAssumePure
+import annotation.unchecked.uncheckedCaptures
 
 
 /** Iterators are data structures that allow to iterate over a sequence
@@ -416,7 +417,9 @@ trait Iterator[+A] extends IterableOnce[A] with IterableOnceOps[A, Iterator, Ite
   }
 
   @deprecated("Call scanRight on an Iterable instead.", "2.13.0")
-  def scanRight[B](z: B)(op: (A, B) => B): Iterator[B]^{this} = ArrayBuffer.from(this).scanRight(z)(op).iterator
+  def scanRight[B](z: B)(op: (A, B) => B): Iterator[B]^{this} =
+    ArrayBuffer.from[A @uncheckedCaptures](this).scanRight(z)(op).iterator
+      // @uncheckedCaptures is safe since the ArrayBuffer is local temporrary storage
 
   def indexWhere(p: A => Boolean, from: Int = 0): Int = {
     var i = math.max(from, 0)

tests/pos-special/stdlib/collection/Seq.scala

@@ -18,6 +18,7 @@ import Searching.{Found, InsertionPoint, SearchResult}
 import scala.annotation.nowarn
 import language.experimental.captureChecking
 import caps.unsafe.unsafeAssumePure
+import scala.annotation.unchecked.uncheckedCaptures
 
 /** Base trait for sequence collections
   *
@@ -598,7 +599,8 @@ trait SeqOps[+A, +CC[_], +C] extends Any with SeqViewOps[A, CC, C] { self =>
       if (!hasNext)
         Iterator.empty.next()
 
-      val forcedElms = new mutable.ArrayBuffer[A](elms.size) ++= elms
+      val forcedElms = new mutable.ArrayBuffer[A @uncheckedCaptures](elms.size) ++= elms
+        // uncheckedCaptures OK since used only locally
       val result = (newSpecificBuilder ++= forcedElms).result()
       var i = idxs.length - 2
       while(i >= 0 && idxs(i) >= idxs(i+1))

tests/pos-special/stdlib/collection/View.scala

@@ -78,7 +78,7 @@ object View extends IterableFactory[View] {
 
   def empty[A]: View[A] = Empty
 
-  def newBuilder[A]: Builder[A, View[A]] = ArrayBuffer.newBuilder[A].mapResult(from)
+  def newBuilder[sealed A]: Builder[A, View[A]] = ArrayBuffer.newBuilder[A].mapResult(from)
 
   override def apply[A](xs: A*): View[A] = new Elems(xs: _*)
 

tests/pos-special/stdlib/collection/mutable/ArrayBuffer.scala

@@ -20,6 +20,8 @@ import scala.annotation.nowarn
 import scala.annotation.tailrec
 import scala.collection.Stepper.EfficientSplit
 import scala.collection.generic.DefaultSerializable
+import language.experimental.captureChecking
+import scala.annotation.unchecked.uncheckedCaptures
 
 /** An implementation of the `Buffer` class using an array to
   *  represent the assembled sequence internally. Append, update and random
@@ -40,7 +42,7 @@ import scala.collection.generic.DefaultSerializable
   *  @define willNotTerminateInf
   */
 @SerialVersionUID(-1582447879429021880L)
-class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int)
+class ArrayBuffer[sealed A] private (initialElements: Array[AnyRef], initialSize: Int)
   extends AbstractBuffer[A]
     with IndexedBuffer[A]
     with IndexedSeqOps[A, ArrayBuffer, ArrayBuffer[A]]
@@ -151,7 +153,7 @@ class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int)
   }
 
   // Overridden to use array copying for efficiency where possible.
-  override def addAll(elems: IterableOnce[A]): this.type = {
+  override def addAll(elems: IterableOnce[A]^): this.type = {
     elems match {
       case elems: ArrayBuffer[_] =>
         val elemsLength = elems.size0
@@ -180,7 +182,7 @@ class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int)
     this
   }
 
-  def insertAll(@deprecatedName("n", "2.13.0") index: Int, elems: IterableOnce[A]): Unit = {
+  def insertAll(@deprecatedName("n", "2.13.0") index: Int, elems: IterableOnce[A]^): Unit = {
     checkWithinBounds(index, index)
     elems match {
       case elems: collection.Iterable[A] =>
@@ -234,7 +236,7 @@ class ArrayBuffer[A] private (initialElements: Array[AnyRef], initialSize: Int)
 
   @deprecated("Use 'new GrowableBuilder(this).mapResult(f)' instead", "2.13.0")
   @deprecatedOverriding("ArrayBuffer[A] no longer extends Builder[A, ArrayBuffer[A]]", "2.13.0")
-  @inline def mapResult[NewTo](f: (ArrayBuffer[A]) => NewTo): Builder[A, NewTo] = new GrowableBuilder[A, ArrayBuffer[A]](this).mapResult(f)
+  @inline def mapResult[NewTo](f: (ArrayBuffer[A]) => NewTo): Builder[A, NewTo]^{f} = new GrowableBuilder[A, ArrayBuffer[A]](this).mapResult(f)
 
   @nowarn("""cat=deprecation&origin=scala\.collection\.Iterable\.stringPrefix""")
   override protected[this] def stringPrefix = "ArrayBuffer"
@@ -291,7 +293,7 @@ object ArrayBuffer extends StrictOptimizedSeqFactory[ArrayBuffer] {
   final val DefaultInitialSize = 16
   private[this] val emptyArray = new Array[AnyRef](0)
 
-  def from[B](coll: collection.IterableOnce[B]): ArrayBuffer[B] = {
+  def from[sealed B](coll: collection.IterableOnce[B]^): ArrayBuffer[B] = {
     val k = coll.knownSize
     if (k >= 0) {
       // Avoid reallocation of buffer if length is known
@@ -303,12 +305,12 @@ object ArrayBuffer extends StrictOptimizedSeqFactory[ArrayBuffer] {
     else new ArrayBuffer[B] ++= coll
   }
 
-  def newBuilder[A]: Builder[A, ArrayBuffer[A]] =
+  def newBuilder[sealed A]: Builder[A, ArrayBuffer[A]] =
     new GrowableBuilder[A, ArrayBuffer[A]](empty) {
       override def sizeHint(size: Int): Unit = elems.ensureSize(size)
     }
 
-  def empty[A]: ArrayBuffer[A] = new ArrayBuffer[A]()
+  def empty[sealed A]: ArrayBuffer[A] = new ArrayBuffer[A]()
 
   /**
    * @param arrayLen  the length of the backing array
@@ -357,22 +359,23 @@ object ArrayBuffer extends StrictOptimizedSeqFactory[ArrayBuffer] {
 }
 
 // TODO: use `CheckedIndexedSeqView.Id` once we can change the return type of `ArrayBuffer#view`
-final class ArrayBufferView[A] private[mutable](underlying: ArrayBuffer[A], mutationCount: () => Int)
-  extends AbstractIndexedSeqView[A] {
+final class ArrayBufferView[sealed A] private[mutable](underlying: ArrayBuffer[A], mutationCount: () -> Int)
+  extends AbstractIndexedSeqView[A], Pure {
+  /* Removed since it poses problems for capture checking
   @deprecated("never intended to be public; call ArrayBuffer#view instead", since = "2.13.7")
   def this(array: Array[AnyRef], length: Int) = {
     // this won't actually track mutation, but it would be a pain to have the implementation
     // check if we have a method to get the current mutation count or not on every method and
     // change what it does based on that. hopefully no one ever calls this.
     this({
-      val _array = array
+      val _array: Array[Object] = array
       val _length = length
       new ArrayBuffer[A](0) {
         this.array = _array
         this.size0 = _length
-      }
+      }: ArrayBuffer[A]
     }, () => 0)
-  }
+  }*/
 
   @deprecated("never intended to be public", since = "2.13.7")
   def array: Array[AnyRef] = underlying.toArray[Any].asInstanceOf[Array[AnyRef]]
@@ -392,10 +395,10 @@ final class ArrayBufferView[A] private[mutable](underlying: ArrayBuffer[A], muta
   override def takeRight(n: Int): IndexedSeqView[A] = new CheckedIndexedSeqView.TakeRight(this, n)(mutationCount)
   override def drop(n: Int): IndexedSeqView[A] = new CheckedIndexedSeqView.Drop(this, n)(mutationCount)
   override def dropRight(n: Int): IndexedSeqView[A] = new CheckedIndexedSeqView.DropRight(this, n)(mutationCount)
-  override def map[B](f: A => B): IndexedSeqView[B] = new CheckedIndexedSeqView.Map(this, f)(mutationCount)
+  override def map[B](f: A => B): IndexedSeqView[B]^{f} = new CheckedIndexedSeqView.Map(this, f)(mutationCount)
   override def reverse: IndexedSeqView[A] = new CheckedIndexedSeqView.Reverse(this)(mutationCount)
   override def slice(from: Int, until: Int): IndexedSeqView[A] = new CheckedIndexedSeqView.Slice(this, from, until)(mutationCount)
-  override def tapEach[U](f: A => U): IndexedSeqView[A] = new CheckedIndexedSeqView.Map(this, { (a: A) => f(a); a})(mutationCount)
+  override def tapEach[U](f: A => U): IndexedSeqView[A]^{f} = new CheckedIndexedSeqView.Map(this, { (a: A) => f(a); a})(mutationCount)
 
   override def concat[B >: A](suffix: IndexedSeqView.SomeIndexedSeqOps[B]): IndexedSeqView[B] = new CheckedIndexedSeqView.Concat(this, suffix)(mutationCount)
   override def appendedAll[B >: A](suffix: IndexedSeqView.SomeIndexedSeqOps[B]): IndexedSeqView[B] = new CheckedIndexedSeqView.Concat(this, suffix)(mutationCount)

tests/pos-special/stdlib/collection/mutable/Buffer.scala

@@ -18,7 +18,7 @@ import language.experimental.captureChecking
 
 
 /** A `Buffer` is a growable and shrinkable `Seq`. */
-trait Buffer[A]
+trait Buffer[sealed A]
   extends Seq[A]
     with SeqOps[A, Buffer, Buffer[A]]
     with Growable[A]

tests/pos-special/stdlib/collection/mutable/GrowableBuilder.scala

@@ -0,0 +1,37 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala
+package collection.mutable
+import language.experimental.captureChecking
+
+/** The canonical builder for collections that are growable, i.e. that support an
+  * efficient `+=` method which adds an element to the collection.
+  *
+  * GrowableBuilders can produce only a single instance of the collection they are growing.
+  *
+  * @define Coll `GrowingBuilder`
+  * @define coll growing builder
+  */
+class GrowableBuilder[Elem, To <: Growable[Elem]](protected val elems: To)
+  extends Builder[Elem, To] {
+
+  def clear(): Unit = elems.clear()
+
+  def result(): To = elems
+
+  def addOne(elem: Elem): this.type = { elems += elem; this }
+
+  override def addAll(xs: IterableOnce[Elem]^): this.type = { elems.addAll(xs); this }
+
+  override def knownSize: Int = elems.knownSize
+}