Sequence->Seq

6 files changed, 30 insertions, 30 deletions

diff --git a/test/files/neg/bug910.check b/test/files/neg/bug910.check
index 4ec73094cd..fe4ad4fca4 100644
--- a/test/files/neg/bug910.check
+++ b/test/files/neg/bug910.check
@@ -1,6 +1,6 @@
 bug910.scala:4: error: type mismatch;
- found   : Sequence[Char]
- required: Seq[int]
+ found   : Seq[Char]
+ required: scala.Seq[int]
     val y: Seq[int] = rest
                       ^
 one error found
diff --git a/test/files/neg/t0259.check b/test/files/neg/t0259.check
index a0b322d985..24e35e6176 100644
--- a/test/files/neg/t0259.check
+++ b/test/files/neg/t0259.check
@@ -1,7 +1,7 @@
 t0259.scala:4: error: double definition:
 constructor TestCase3:(groups: String*)test.TestCase3 and
 constructor TestCase3:(groups: (String, Int)*)test.TestCase3 at line 3
-have same type after erasure: (groups: Sequence)test.TestCase3
+have same type after erasure: (groups: Seq)test.TestCase3
   def this( groups: String*) = this()
       ^
 one error found
diff --git a/test/files/pos/implicits.scala b/test/files/pos/implicits.scala
index a8d362d0a7..aeb6591507 100644
--- a/test/files/pos/implicits.scala
+++ b/test/files/pos/implicits.scala
@@ -32,7 +32,7 @@ object Test1625 {
 }
 
 object Test2188 {
-  implicit def toJavaList[A: ClassManifest](t:collection.Sequence[A]):java.util.List[A] = java.util.Arrays.asList(t.toArray:_*)
+  implicit def toJavaList[A: ClassManifest](t:collection.Seq[A]):java.util.List[A] = java.util.Arrays.asList(t.toArray:_*)
 
   val x: java.util.List[String] = List("foo")
 }
diff --git a/test/files/pos/spec-List.scala b/test/files/pos/spec-List.scala
index 7cd6a03f6c..a68e2774cb 100644
--- a/test/files/pos/spec-List.scala
+++ b/test/files/pos/spec-List.scala
@@ -23,13 +23,13 @@ import annotation.tailrec
  *  @author  Martin Odersky and others
  *  @version 2.8
  */
-sealed abstract class List[@specialized +A] extends LinearSequence[A]
+sealed abstract class List[@specialized +A] extends LinearSeq[A]
                                   with Product
                                   with GenericTraversableTemplate[A, List]
-                                  with LinearSequenceLike[A, List[A]] {
+                                  with LinearSeqLike[A, List[A]] {
   override def companion: GenericCompanion[List] = List
 
-  import scala.collection.{Iterable, Traversable, Sequence, Vector}
+  import scala.collection.{Iterable, Traversable, Seq, Vector}
 
   /** Returns true if the list does not contain any elements.
    *  @return <code>true</code>, iff the list is empty.
@@ -446,7 +446,7 @@ case object Nil extends List[Nothing] {
     throw new NoSuchElementException("tail of empty list")
   // Removal of equals method here might lead to an infinite recusion similar to IntMap.equals.
   override def equals(that: Any) = that match {
-    case that1: Sequence[_] => that1.isEmpty
+    case that1: Seq[_] => that1.isEmpty
     case _ => false
   }
 }
@@ -492,9 +492,9 @@ final case class ::[@specialized B](private var hd: B, private[scala] var tl: Li
  *  @author  Martin Odersky
  *  @version 2.8
  */
-object List extends SequenceFactory[List] {
+object List extends SeqFactory[List] {
 
-  import collection.{Iterable, Sequence, Vector}
+  import collection.{Iterable, Seq, Vector}
 
   implicit def builderFactory[A]: BuilderFactory[A, List[A], Coll] = new VirtualBuilderFactory[A]
   def newBuilder[A]: Builder[A, List[A]] = new ListBuffer[A]
diff --git a/test/files/run/colltest1.scala b/test/files/run/colltest1.scala
index ea8ff8e305..efdce00277 100644
--- a/test/files/run/colltest1.scala
+++ b/test/files/run/colltest1.scala
@@ -55,10 +55,10 @@ object Test extends Application {
     secondFive copyToBuffer buf
     assert(buf.result == ten, buf.result)
     assert(ten.toArray.size == 10)
-    assert(ten.toArray.toSequence == ten, ten.toArray.toSequence)
+    assert(ten.toArray.toSeq == ten, ten.toArray.toSeq)
     assert(ten.toIterable == ten)
     assert(ten.toList == ten)
-    assert(ten.toSequence == ten)
+    assert(ten.toSeq == ten)
     assert(ten.toStream == ten)
     assert(ten.toString endsWith "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)")
     assert(ten.mkString("[", "; ", "]") endsWith "[1; 2; 3; 4; 5; 6; 7; 8; 9; 10]")
@@ -73,7 +73,7 @@ object Test extends Application {
     assert(six sameElements (1 to 6))
   }
 
-  def sequenceTest(empty: Sequence[Int]) {
+  def sequenceTest(empty: Seq[Int]) {
     orderedIterableTest(empty)
     val ten = empty ++ (1 to 10)
     println(ten)
@@ -125,7 +125,7 @@ object Test extends Application {
     assert((ten ++ ten).removeDuplicates == ten)
     assert(ten.patch(3, List(4, 5, 6, 7), 4) == ten)
     assert(ten.patch(0, List(1, 2, 3), 9) == List(1, 2, 3, 10))
-    assert(empty.padTo(10, 7) == Array.fill(10)(7).toSequence)
+    assert(empty.padTo(10, 7) == Array.fill(10)(7).toSeq)
     assert((ten zip ten.indices) == ten.zipWithIndex)
     assert(ten.sortWith(_ < _) == ten)
     assert(ten.sortWith(_ > _) == ten.reverse)
@@ -209,12 +209,12 @@ object Test extends Application {
   orderedIterableTest(Iterable())
   orderedIterableTest(mutable.Iterable())
   orderedIterableTest(immutable.Iterable())
-  sequenceTest(Sequence())
-  sequenceTest(mutable.Sequence())
-  sequenceTest(immutable.Sequence())
-  sequenceTest(LinearSequence())
-//  sequenceTest(mutable.LinearSequence())
-  sequenceTest(immutable.LinearSequence())
+  sequenceTest(Seq())
+  sequenceTest(mutable.Seq())
+  sequenceTest(immutable.Seq())
+  sequenceTest(LinearSeq())
+//  sequenceTest(mutable.LinearSeq())
+  sequenceTest(immutable.LinearSeq())
   sequenceTest(mutable.Vector())
   rangeTest(1 to 10)
 
diff --git a/test/files/run/sequenceComparisons.scala b/test/files/run/sequenceComparisons.scala
index cc1cf3610c..cf1f64d67d 100644
--- a/test/files/run/sequenceComparisons.scala
+++ b/test/files/run/sequenceComparisons.scala
@@ -1,27 +1,27 @@
 import scala.collection.{ mutable, immutable }
-import collection.{ Sequence, Traversable }
+import collection.{ Seq, Traversable }
 
 object Test {
   // TODO:
   //
-  // SequenceProxy
-  // SequenceForwarder
+  // SeqProxy
+  // SeqForwarder
   // the commented out ones in seqMakers
 
-  val seqMakers = List[List[Int] => Sequence[Int]](
+  val seqMakers = List[List[Int] => Seq[Int]](
     // scala.Array(_: _*),
     mutable.ArrayBuffer(_: _*),
     // mutable.ArrayStack(_: _*),
     mutable.Buffer(_: _*),
-    mutable.LinearSequence(_: _*),
+    mutable.LinearSeq(_: _*),
     // null on Nil
     // mutable.LinkedList(_: _*),
     mutable.ListBuffer(_: _*),
     // mutable.PriorityQueue(_: _*),
     // immutable.Queue(_: _*),
     // mutable.Queue(_: _*),
-    immutable.Sequence(_: _*),
-    mutable.Sequence(_: _*),
+    immutable.Seq(_: _*),
+    mutable.Seq(_: _*),
     // immutable.Stack(_: _*),
     // mutable.Stack(_: _*),
     immutable.Vector(_: _*),
@@ -31,12 +31,12 @@ object Test {
   )
 
   abstract class Data[T] {
-    val seq: Sequence[T]
+    val seq: Seq[T]
     private def seqList = seq.toList
     // _1 is inputs which must be true, _2 which must be false
     type Inputs = (List[List[T]], List[List[T]])
     case class Method(
-      f: (Sequence[T], Sequence[T]) => Boolean,
+      f: (Seq[T], Seq[T]) => Boolean,
       inputs: Inputs,
       descr: String
     ) {
@@ -53,7 +53,7 @@ object Test {
     lazy val endsWith = Method(_ endsWith _, endsWithInputs, "%s endsWith %s")
 
     val indexOfSeqInputs: Inputs
-    private def subseqTest(s1: Sequence[T], s2: Sequence[T]) = (s1 indexOfSeq s2) != -1
+    private def subseqTest(s1: Seq[T], s2: Seq[T]) = (s1 indexOfSeq s2) != -1
     lazy val indexOfSeq = Method(subseqTest _, indexOfSeqInputs, "(%s indexOfSeq %s) != -1")
 
     val sameElementsInputs: Inputs