undeprecated containsSlice.

7 files changed, 19 insertions, 20 deletions

diff --git a/src/library/scala/collection/Seq.scala b/src/library/scala/collection/Seq.scala
index 18d37eba82..acf9d8fbb0 100644
--- a/src/library/scala/collection/Seq.scala
+++ b/src/library/scala/collection/Seq.scala
@@ -23,7 +23,7 @@ import mutable.Builder
  *    <code>prefixLength</code>, <code>indexWhere</code>, <code>indexOf</code>,
  *    <code>lastIndexWhere</code>, <code>lastIndexOf</code>, <code>reverse</code>,
  *    <code>reverseIterator</code>, <code>startsWith</code>,
- *    <code>endsWith</code>, <code>indexOfSeq</code>.
+ *    <code>endsWith</code>, <code>indexOfSlice</code>.
  *  </p>
  *
  *  @author  Martin Odersky
diff --git a/src/library/scala/collection/SeqLike.scala b/src/library/scala/collection/SeqLike.scala
index 661f7b7a04..265fb8c91c 100644
--- a/src/library/scala/collection/SeqLike.scala
+++ b/src/library/scala/collection/SeqLike.scala
@@ -101,7 +101,7 @@ object SeqLike {
  *  It adds the following methods to class Iterable:
  *   `length`, `lengthCompare`, `apply`, `isDefinedAt`, `segmentLength`, `prefixLength`,
  *   `indexWhere`, `indexOf`, `lastIndexWhere`, `lastIndexOf`, `reverse`, `reverseIterator`,
- *   `startsWith`, `endsWith`, `indexOfSeq`, , `zip`, `zipAll`, `zipWithIndex`.
+ *   `startsWith`, `endsWith`, `indexOfSlice`, , `zip`, `zipAll`, `zipWithIndex`.
  *
  *
  *  @author  Martin Odersky
@@ -343,9 +343,9 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] { self =>
   /** @return -1 if <code>that</code> not contained in this, otherwise the
    *  first index where <code>that</code> is contained.
    */
-  def indexOfSeq[B >: A](that: Seq[B]): Int = indexOfSeq(that, 0)
+  def indexOfSlice[B >: A](that: Seq[B]): Int = indexOfSlice(that, 0)
 
-  def indexOfSeq[B >: A](that: Seq[B], fromIndex: Int): Int =
+  def indexOfSlice[B >: A](that: Seq[B], fromIndex: Int): Int =
     if (this.hasDefiniteSize && that.hasDefiniteSize)
       SeqLike.indexOf(thisCollection, 0, length, that, 0, that.length, fromIndex)
     else {
@@ -365,11 +365,11 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] { self =>
   *  last index where <code>that</code> is contained.
   *  @note may not terminate for infinite-sized collections.
   */
-  def lastIndexOfSeq[B >: A](that: Seq[B]): Int = lastIndexOfSeq(that, that.length)
+  def lastIndexOfSlice[B >: A](that: Seq[B]): Int = lastIndexOfSlice(that, that.length)
 
   // since there's no way to find the last index in an infinite sequence,
   // we just document it may not terminate and assume it will.
-  def lastIndexOfSeq[B >: A](that: Seq[B], fromIndex: Int): Int =
+  def lastIndexOfSlice[B >: A](that: Seq[B], fromIndex: Int): Int =
     SeqLike.lastIndexOf(thisCollection, 0, length, that, 0, that.length, fromIndex)
 
   /** Tests if the given value <code>elem</code> is a member of this
@@ -629,8 +629,7 @@ trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] { self =>
   }
 
   /** Is <code>that</code> a slice in this? */
-  @deprecated("Should be replaced by <code>indexOfSeq(that) != -1</code>")
-  def containsSlice[B](that: Seq[B]): Boolean = indexOfSeq(that) != -1
+  def containsSlice[B](that: Seq[B]): Boolean = indexOfSlice(that) != -1
 
  /**
    * returns a projection that can be used to call non-strict <code>filter</code>,
diff --git a/src/library/scala/collection/SeqProxyLike.scala b/src/library/scala/collection/SeqProxyLike.scala
index 06bae39aef..98f4a8772a 100644
--- a/src/library/scala/collection/SeqProxyLike.scala
+++ b/src/library/scala/collection/SeqProxyLike.scala
@@ -45,7 +45,7 @@ trait SeqProxyLike[+A, +This <: SeqLike[A, This] with Seq[A]] extends SeqLike[A,
   override def startsWith[B](that: Seq[B], offset: Int): Boolean = self.startsWith(that, offset)
   override def startsWith[B](that: Seq[B]): Boolean = self.startsWith(that)
   override def endsWith[B](that: Seq[B]): Boolean = self.endsWith(that)
-  override def indexOfSeq[B >: A](that: Seq[B]): Int = self.indexOfSeq(that)
+  override def indexOfSlice[B >: A](that: Seq[B]): Int = self.indexOfSlice(that)
   override def contains(elem: Any): Boolean = self.contains(elem)
   override def union[B >: A, That](that: Seq[B])(implicit bf: CanBuildFrom[This, B, That]): That = self.union(that)(bf)
   override def diff[B >: A, That](that: Seq[B]): This = self.diff(that)
@@ -57,5 +57,5 @@ trait SeqProxyLike[+A, +This <: SeqLike[A, This] with Seq[A]] extends SeqLike[A,
   override def view = self.view
   override def view(from: Int, until: Int) = self.view(from, until)
   override def equalsWith[B](that: Seq[B])(f: (A,B) => Boolean): Boolean = (self zip that) forall { case (x,y) => f(x,y) }
-  override def containsSlice[B](that: Seq[B]): Boolean = self.indexOfSeq(that) != -1
+  override def containsSlice[B](that: Seq[B]): Boolean = self.indexOfSlice(that) != -1
 }
diff --git a/src/library/scala/collection/generic/SeqForwarder.scala b/src/library/scala/collection/generic/SeqForwarder.scala
index 02fdc62b65..5feef1af13 100644
--- a/src/library/scala/collection/generic/SeqForwarder.scala
+++ b/src/library/scala/collection/generic/SeqForwarder.scala
@@ -47,7 +47,7 @@ trait SeqForwarder[+A] extends Seq[A] with IterableForwarder[A] {
   override def reverseIterator: Iterator[A] = underlying.reverseIterator
   override def startsWith[B](that: Seq[B], offset: Int): Boolean = underlying.startsWith(that, offset)
   override def endsWith[B](that: Seq[B]): Boolean = underlying.endsWith(that)
-  override def indexOfSeq[B >: A](that: Seq[B]): Int = underlying.indexOfSeq(that)
+  override def indexOfSlice[B >: A](that: Seq[B]): Int = underlying.indexOfSlice(that)
   override def contains(elem: Any): Boolean = underlying.contains(elem)
   override def indices: Range = underlying.indices
 }
diff --git a/src/library/scala/collection/interfaces/SeqMethods.scala b/src/library/scala/collection/interfaces/SeqMethods.scala
index c7c138c2c3..0a4163cef5 100644
--- a/src/library/scala/collection/interfaces/SeqMethods.scala
+++ b/src/library/scala/collection/interfaces/SeqMethods.scala
@@ -25,8 +25,8 @@ trait SeqMethods[+A, +This <: SeqLike[A, This] with Seq[A]] extends IterableMeth
   def contains(elem: Any): Boolean
   def diff[B >: A, That](that: Seq[B]): This
   def endsWith[B](that: Seq[B]): Boolean
-  def indexOfSeq[B >: A](that: Seq[B]): Int
-  def indexOfSeq[B >: A](that: Seq[B], fromIndex: Int): Int
+  def indexOfSlice[B >: A](that: Seq[B]): Int
+  def indexOfSlice[B >: A](that: Seq[B], fromIndex: Int): Int
   def indexOf[B >: A](elem: B): Int
   def indexOf[B >: A](elem: B, from: Int): Int
   def indexWhere(p: A => Boolean): Int
@@ -34,8 +34,8 @@ trait SeqMethods[+A, +This <: SeqLike[A, This] with Seq[A]] extends IterableMeth
   def indices: Range
   def intersect[B >: A, That](that: Seq[B]): This
   def isDefinedAt(x: Int): Boolean
-  def lastIndexOfSeq[B >: A](that: Seq[B]): Int
-  def lastIndexOfSeq[B >: A](that: Seq[B], fromIndex: Int): Int
+  def lastIndexOfSlice[B >: A](that: Seq[B]): Int
+  def lastIndexOfSlice[B >: A](that: Seq[B], fromIndex: Int): Int
   def lastIndexOf[B >: A](elem: B): Int
   def lastIndexOf[B >: A](elem: B, end: Int): Int
   def lastIndexWhere(p: A => Boolean): Int
diff --git a/src/library/scala/collection/mutable/GenericArray.scala b/src/library/scala/collection/mutable/GenericArray.scala
index 84341bacd4..118b2b1ee7 100644
--- a/src/library/scala/collection/mutable/GenericArray.scala
+++ b/src/library/scala/collection/mutable/GenericArray.scala
@@ -14,10 +14,10 @@ package mutable
 
 import generic._
 
-/** This class is used internally to implement data structures that
- *  are based on resizable arrays.
+/** A class for polymorphic arrays of elements that's represented
+ *  internally by an array of objects. This means that elements of
+ *  primitive types are boxed.
  *
- *  @author  Matthias Zenger, Burak Emir
  *  @author Martin Odersky
  *  @version 2.8
  *  @since   2.8
diff --git a/src/library/scala/collection/mutable/StringBuilder.scala b/src/library/scala/collection/mutable/StringBuilder.scala
index e83a30b180..264ee1a270 100644
--- a/src/library/scala/collection/mutable/StringBuilder.scala
+++ b/src/library/scala/collection/mutable/StringBuilder.scala
@@ -739,7 +739,7 @@ final class StringBuilder(initCapacity: Int, private val initValue: String)
    *  @return           the index within this string of the first occurrence
    *                    of the specified substring, starting at the specified index.
    */
-  def indexOf(str: String, fromIndex: Int): Int = indexOfSeq(str.toIndexedSeq, fromIndex)
+  def indexOf(str: String, fromIndex: Int): Int = indexOfSlice(str.toIndexedSeq, fromIndex)
 
   /** <p>
    *    Returns the index within this string of the rightmost occurrence
@@ -780,7 +780,7 @@ final class StringBuilder(initCapacity: Int, private val initValue: String)
    *  @return            the index within this sequence of the last occurrence
    *                     of the specified substring.
    */
-  def lastIndexOf(str: String, fromIndex: Int): Int = lastIndexOfSeq(str.toIndexedSeq, fromIndex)
+  def lastIndexOf(str: String, fromIndex: Int): Int = lastIndexOfSlice(str.toIndexedSeq, fromIndex)
 
   /** <p>
    *    Causes this character sequence to be replaced by the reverse of the