diff options
107 files changed, 823 insertions, 276 deletions
diff --git a/lib/scala-compiler.jar.desired.sha1 b/lib/scala-compiler.jar.desired.sha1 index 9b42928d0d..18aecb6c18 100644 --- a/lib/scala-compiler.jar.desired.sha1 +++ b/lib/scala-compiler.jar.desired.sha1 @@ -1 +1 @@ -f39fa1359f164294d0bab462c2abbcad629194bb ?scala-compiler.jar +a68c666e5fdd3c2e6f389ecde369f5c6718d1a6e ?scala-compiler.jar diff --git a/lib/scala-library.jar.desired.sha1 b/lib/scala-library.jar.desired.sha1 index 56a65e30c4..7f8055b117 100644 --- a/lib/scala-library.jar.desired.sha1 +++ b/lib/scala-library.jar.desired.sha1 @@ -1 +1 @@ -93135c0a9a529f3cc3ef76bbd6540e870dc562c7 ?scala-library.jar +4ae7d29d34a187321e703462f2d1c62e0b650731 ?scala-library.jar diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index 56b8253fa7..ff795d446e 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -822,6 +822,8 @@ class Global(var settings: Settings, var reporter: Reporter) extends SymbolTable advancePhase } + println(narrowCount+" narrowings") + if (settings.Xshowcls.value != "") showDef(newTermName(settings.Xshowcls.value), false) if (settings.Xshowobj.value != "") diff --git a/src/compiler/scala/tools/nsc/doc/DocUtil.scala b/src/compiler/scala/tools/nsc/doc/DocUtil.scala index dbb6f94386..c01d9566f8 100644 --- a/src/compiler/scala/tools/nsc/doc/DocUtil.scala +++ b/src/compiler/scala/tools/nsc/doc/DocUtil.scala @@ -92,7 +92,7 @@ object DocUtil else xs.head ++ sep ++ interleave(xs.tail, sep) def mkXML(begin: NodeSeq, separator: NodeSeq, end: NodeSeq)(f: T => NodeSeq): NodeSeq = - begin ++ interleave(list.toSequence map f, separator) ++ end + begin ++ interleave(list.toSeq map f, separator) ++ end def mkXML(begin: String, separator: String, end: String)(f: T => NodeSeq): NodeSeq = this.mkXML(Text(begin), Text(separator), Text(end))(f) diff --git a/src/compiler/scala/tools/nsc/io/Path.scala b/src/compiler/scala/tools/nsc/io/Path.scala index ed750e5b11..37cc64cf75 100644 --- a/src/compiler/scala/tools/nsc/io/Path.scala +++ b/src/compiler/scala/tools/nsc/io/Path.scala @@ -9,7 +9,7 @@ import java.io.{ FileInputStream, FileOutputStream, BufferedReader, BufferedWriter, InputStreamReader, OutputStreamWriter, BufferedInputStream, BufferedOutputStream, File => JFile } import java.net.{ URI, URL } -import collection.{ Sequence, Traversable } +import collection.{ Seq, Traversable } import PartialFunction._ import scala.util.Random.nextASCIIString diff --git a/src/compiler/scala/tools/nsc/io/ZipArchive.scala b/src/compiler/scala/tools/nsc/io/ZipArchive.scala index 54deec939e..e75f68ca92 100644 --- a/src/compiler/scala/tools/nsc/io/ZipArchive.scala +++ b/src/compiler/scala/tools/nsc/io/ZipArchive.scala @@ -301,6 +301,6 @@ final class URLZipArchive(url: URL) extends AbstractFile with ZipContainer val minusOne = (-1).toByte val buf = new BufferedInputStream(in) val bytes = Iterator continually in.read().toByte takeWhile (_ != minusOne) - new ByteArrayInputStream(bytes.toSequence.toArray) + new ByteArrayInputStream(bytes.toSeq.toArray) } } diff --git a/src/compiler/scala/tools/nsc/symtab/Definitions.scala b/src/compiler/scala/tools/nsc/symtab/Definitions.scala index 71e9725944..9c2df4a6cb 100644 --- a/src/compiler/scala/tools/nsc/symtab/Definitions.scala +++ b/src/compiler/scala/tools/nsc/symtab/Definitions.scala @@ -168,8 +168,8 @@ trait Definitions { def Iterable_next = getMember(IterableClass, nme.next) def Iterable_hasNext = getMember(IterableClass, nme.hasNext) - lazy val SeqClass = getClass2("scala.Seq", "scala.collection.Sequence") - lazy val SeqModule = getModule2("scala.Seq", "scala.collection.Sequence") + lazy val SeqClass = getClass2("scala.Seq", "scala.collection.Seq") + lazy val SeqModule = getModule2("scala.Seq", "scala.collection.Seq") def Seq_length = getMember(SeqClass, nme.length) lazy val RandomAccessSeqMutableClass = getMember( getModule2("scala.RandomAccessSeq", "scala.collection.Vector"), nme.Mutable) diff --git a/src/compiler/scala/tools/nsc/symtab/Scopes.scala b/src/compiler/scala/tools/nsc/symtab/Scopes.scala index 8a09d361cb..281981e344 100644 --- a/src/compiler/scala/tools/nsc/symtab/Scopes.scala +++ b/src/compiler/scala/tools/nsc/symtab/Scopes.scala @@ -50,7 +50,7 @@ trait Scopes { // Martin: This code contains a lot of stuff for the old Eclipse plugin. // Now it's just needless complexity, which should be eleminated. // We should make the elems list doubly-linked, - // and have scopes inherit from LinearSequence, + // and have scopes inherit from LinearSeq, // that way, we need to do way fewer toList than before. /** diff --git a/src/compiler/scala/tools/nsc/symtab/StdNames.scala b/src/compiler/scala/tools/nsc/symtab/StdNames.scala index 867b13b243..19cce08224 100644 --- a/src/compiler/scala/tools/nsc/symtab/StdNames.scala +++ b/src/compiler/scala/tools/nsc/symtab/StdNames.scala @@ -331,7 +331,7 @@ trait StdNames { val tail = newTermName("tail") val toArray = newTermName("toArray") val toList = newTermName("toList") - val toSequence = newTermName("toSequence") + val toSeq = newTermName("toSeq") val toString_ = newTermName("toString") val clone_ = newTermName("clone") val this_ = newTermName("this") diff --git a/src/compiler/scala/tools/nsc/symtab/Types.scala b/src/compiler/scala/tools/nsc/symtab/Types.scala index 9fdb446ad8..47ede4228e 100644 --- a/src/compiler/scala/tools/nsc/symtab/Types.scala +++ b/src/compiler/scala/tools/nsc/symtab/Types.scala @@ -4780,7 +4780,7 @@ A type's typeSymbol should never be inspected directly. val shorthands = Set( "scala.collection.immutable.List", "scala.collection.immutable.Nil", - "scala.collection.Sequence", + "scala.collection.Seq", "scala.collection.Traversable", "scala.collection.Iterable", "scala.collection.mutable.StringBuilder", diff --git a/src/library/scala/Array.scala b/src/library/scala/Array.scala index afd6f7bb9b..249d80653c 100644 --- a/src/library/scala/Array.scala +++ b/src/library/scala/Array.scala @@ -368,10 +368,10 @@ object Array extends FallbackArrayBuilding { b.result } - /** This method is called in a pattern match { case Sequence(...) => }. + /** This method is called in a pattern match { case Seq(...) => }. * * @param x the selector value - * @return sequence wrapped in an option, if this is a Sequence, otherwise none + * @return sequence wrapped in an option, if this is a Seq, otherwise none */ def unapplySeq[T](x: Array[T]): Option[Vector[T]] = if (x == null) None else Some(x.toVector) diff --git a/src/library/scala/collection/IterableLike.scala b/src/library/scala/collection/IterableLike.scala index 7a00d7933e..1a6b9d7aaf 100644 --- a/src/library/scala/collection/IterableLike.scala +++ b/src/library/scala/collection/IterableLike.scala @@ -364,8 +364,6 @@ self => /** <code>None</code> if iterable is empty. */ @deprecated("use `headOption' instead") def firstOption: Option[A] = headOption - @deprecated("use `toSequence' instead") def toSeq: Sequence[A] = toSequence - /** * returns a projection that can be used to call non-strict <code>filter</code>, * <code>map</code>, and <code>flatMap</code> methods that build projections diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala index 5b6d13d152..5c7e2b6c3b 100644 --- a/src/library/scala/collection/Iterator.scala +++ b/src/library/scala/collection/Iterator.scala @@ -752,7 +752,7 @@ trait Iterator[+A] { self => * understand) this method takes the way one might expect, leaving * the original iterator with 'size' fewer elements. */ - private def takeDestructively(size: Int): Sequence[A] = { + private def takeDestructively(size: Int): Seq[A] = { val buf = new ArrayBuffer[A] var i = 0 while (self.hasNext && i < size) { @@ -763,12 +763,12 @@ trait Iterator[+A] { self => } /** A flexible iterator for transforming an <code>Iterator[A]</code> into an - * Iterator[Sequence[A]], with configurable sequence size, step, and + * Iterator[Seq[A]], with configurable sequence size, step, and * strategy for dealing with elements which don't fit evenly. * * Typical uses can be achieved via methods `grouped' and `sliding'. */ - class GroupedIterator[B >: A](self: Iterator[A], size: Int, step: Int) extends Iterator[Sequence[B]] { + class GroupedIterator[B >: A](self: Iterator[A], size: Int, step: Int) extends Iterator[Seq[B]] { require(size >= 1 && step >= 1) private[this] var buffer: ArrayBuffer[B] = ArrayBuffer() // the buffer @@ -1008,7 +1008,7 @@ trait Iterator[+A] { self => * * @return A sequence which enumerates all elements of this iterator. */ - def toSequence: Sequence[A] = { + def toSeq: Seq[A] = { val buffer = new ArrayBuffer[A] this copyToBuffer buffer buffer @@ -1096,8 +1096,8 @@ trait Iterator[+A] { self => * * @return a sequence which enumerates all elements of this iterator. */ - @deprecated("use toSequence instead") - def collect: Sequence[A] = toSequence + @deprecated("use toSeq instead") + def collect: Seq[A] = toSeq /** Returns a counted iterator from this iterator. */ diff --git a/src/library/scala/collection/LinearSequence.scala b/src/library/scala/collection/LinearSeq.scala index fbd85ed544..4793d36aba 100644 --- a/src/library/scala/collection/LinearSequence.scala +++ b/src/library/scala/collection/LinearSeq.scala @@ -19,7 +19,7 @@ import mutable.Builder * For such sequences <code>isEmpty</code>, <code>head</code> and * <code>tail</code> are guaranteed to be efficient constant time (or near so) * operations.<br/> - * It does not add any methods to <code>Sequence</code> but overrides several + * It does not add any methods to <code>Seq</code> but overrides several * methods with optimized implementations. * </p> * @@ -28,16 +28,16 @@ import mutable.Builder * @version 1.0, 16/07/2003 * @since 2.8 */ -trait LinearSequence[+A] extends Sequence[A] - with GenericTraversableTemplate[A, LinearSequence] - with LinearSequenceLike[A, LinearSequence[A]] { - override def companion: GenericCompanion[LinearSequence] = LinearSequence +trait LinearSeq[+A] extends Seq[A] + with GenericTraversableTemplate[A, LinearSeq] + with LinearSeqLike[A, LinearSeq[A]] { + override def companion: GenericCompanion[LinearSeq] = LinearSeq } /** * @since 2.8 */ -object LinearSequence extends SequenceFactory[LinearSequence] { - implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, LinearSequence[A]] = immutable.LinearSequence.newBuilder[A] +object LinearSeq extends SeqFactory[LinearSeq] { + implicit def builderFactory[A]: BuilderFactory[A, LinearSeq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, LinearSeq[A]] = immutable.LinearSeq.newBuilder[A] } diff --git a/src/library/scala/collection/LinearSequenceLike.scala b/src/library/scala/collection/LinearSeqLike.scala index 131ce2624b..ed1f5329c5 100644 --- a/src/library/scala/collection/LinearSequenceLike.scala +++ b/src/library/scala/collection/LinearSeqLike.scala @@ -18,7 +18,7 @@ import scala.util.control.Breaks._ /** Class <code>Linear[A]</code> represents linear sequences of elements. * For such sequences `isEmpty`, `head` and `tail` are guaranteed to be * efficient constant time (or near so) operations. - * It does not add any methods to <code>Sequence</code> but overrides + * It does not add any methods to <code>Seq</code> but overrides * several methods with optimized implementations. * * @author Martin Odersky @@ -26,10 +26,10 @@ import scala.util.control.Breaks._ * @version 1.0, 16/07/2003 * @since 2.8 */ -trait LinearSequenceLike[+A, +Repr <: LinearSequenceLike[A, Repr]] extends SequenceLike[A, Repr] { self: Repr => +trait LinearSeqLike[+A, +Repr <: LinearSeqLike[A, Repr]] extends SeqLike[A, Repr] { self: Repr => - override protected[this] def thisCollection: LinearSequence[A] = this.asInstanceOf[LinearSequence[A]] - override protected[this] def toCollection(repr: Repr): LinearSequence[A] = repr.asInstanceOf[LinearSequence[A]] + override protected[this] def thisCollection: LinearSeq[A] = this.asInstanceOf[LinearSeq[A]] + override protected[this] def toCollection(repr: Repr): LinearSeq[A] = repr.asInstanceOf[LinearSeq[A]] /** Abstract method to be implemented in a subclass */ def isEmpty: Boolean @@ -318,7 +318,7 @@ trait LinearSequenceLike[+A, +Repr <: LinearSequenceLike[A, Repr]] extends Seque * @param that the other linear sequence */ override def sameElements[B >: A](that: Iterable[B]): Boolean = that match { - case that1: LinearSequence[_] => + case that1: LinearSeq[_] => var these = this var those = that1 while (!these.isEmpty && !those.isEmpty && these.head == those.head) { @@ -330,7 +330,7 @@ trait LinearSequenceLike[+A, +Repr <: LinearSequenceLike[A, Repr]] extends Seque super.sameElements(that) } - // Overridden methods from Sequence + // Overridden methods from Seq /** Result of comparing <code>length</code> with operand <code>len</code>. * returns <code>x</code> where diff --git a/src/library/scala/collection/Sequence.scala b/src/library/scala/collection/Seq.scala index b9439c909b..6e5f084a06 100644 --- a/src/library/scala/collection/Sequence.scala +++ b/src/library/scala/collection/Seq.scala @@ -15,7 +15,7 @@ import generic._ import mutable.Builder /** <p> - * Class <code>Sequence[A]</code> represents sequences of elements + * Class <code>Seq[A]</code> represents sequences of elements * of type <code>A</code>.<br/> * It adds the following methods to class <code>Iterable</code>: * <code>length</code>, <code>lengthCompare</code>, <code>apply</code>, @@ -30,33 +30,33 @@ import mutable.Builder * @author Matthias Zenger * @version 1.0, 16/07/2003 */ -trait Sequence[+A] extends PartialFunction[Int, A] +trait Seq[+A] extends PartialFunction[Int, A] with Iterable[A] - with GenericTraversableTemplate[A, Sequence] - with SequenceLike[A, Sequence[A]] { - override def companion: GenericCompanion[Sequence] = Sequence + with GenericTraversableTemplate[A, Seq] + with SeqLike[A, Seq[A]] { + override def companion: GenericCompanion[Seq] = Seq } -/** Factory object for <code>Sequence</code> trait. +/** Factory object for <code>Seq</code> trait. * * @author Martin Odersky * @version 2.8 */ -object Sequence extends SequenceFactory[Sequence] { +object Seq extends SeqFactory[Seq] { - private[collection] val hashSeed = "Sequence".hashCode + private[collection] val hashSeed = "Seq".hashCode - implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, Sequence[A]] = immutable.Sequence.newBuilder[A] + implicit def builderFactory[A]: BuilderFactory[A, Seq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, Seq[A]] = immutable.Seq.newBuilder[A] @deprecated("use View instead") - type Projection[A] = SequenceView[A, Coll] + type Projection[A] = SeqView[A, Coll] - @deprecated("use Sequence(value) instead") - def singleton[A](value: A) = Sequence(value) + @deprecated("use Seq(value) instead") + def singleton[A](value: A) = Seq(value) /** Builds a singleton sequence. */ - @deprecated("use <code>Sequence(x)</code> instead.") + @deprecated("use <code>Seq(x)</code> instead.") def single[A](x: A) = singleton(x) } diff --git a/src/library/scala/collection/SequenceLike.scala b/src/library/scala/collection/SeqLike.scala index 20f0c20f57..50ea0c3a5a 100644 --- a/src/library/scala/collection/SequenceLike.scala +++ b/src/library/scala/collection/SeqLike.scala @@ -21,7 +21,7 @@ import generic._ * @author paulp * @since 2.8 */ -object SequenceLike { +object SeqLike { private def KMP[B](S: Seq[B], W: Seq[B]): Option[Int] = { // trivial cases @@ -95,7 +95,7 @@ object SequenceLike { } } -/** Class <code>Sequence[A]</code> represents sequences of elements +/** Class <code>Seq[A]</code> represents sequences of elements * of type <code>A</code>. * It adds the following methods to class Iterable: * `length`, `lengthCompare`, `apply`, `isDefinedAt`, `segmentLength`, `prefixLength`, @@ -108,10 +108,10 @@ object SequenceLike { * @version 1.0, 16/07/2003 * @since 2.8 */ -trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => +trait SeqLike[+A, +Repr] extends IterableLike[A, Repr] { self => - override protected[this] def thisCollection: Sequence[A] = this.asInstanceOf[Sequence[A]] - override protected[this] def toCollection(repr: Repr): Sequence[A] = repr.asInstanceOf[Sequence[A]] + override protected[this] def thisCollection: Seq[A] = this.asInstanceOf[Seq[A]] + override protected[this] def toCollection(repr: Repr): Seq[A] = repr.asInstanceOf[Seq[A]] import Traversable.breaks._ @@ -304,7 +304,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * * @see String.startsWith */ - def startsWith[B](that: Sequence[B], offset: Int): Boolean = { + def startsWith[B](that: Seq[B], offset: Int): Boolean = { val i = this.iterator drop offset val j = that.iterator while (j.hasNext && i.hasNext) @@ -320,12 +320,12 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * @return true if <code>that</code> is a prefix of <code>this</code>, * otherwise false */ - def startsWith[B](that: Sequence[B]): Boolean = startsWith(that, 0) + def startsWith[B](that: Seq[B]): Boolean = startsWith(that, 0) /** @return true if this sequence end with that sequence * @see String.endsWith */ - def endsWith[B](that: Sequence[B]): Boolean = { + def endsWith[B](that: Seq[B]): Boolean = { val i = this.iterator.drop(length - that.length) val j = that.iterator while (i.hasNext && j.hasNext) @@ -338,14 +338,14 @@ trait SequenceLike[+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: Sequence[B]): Int = indexOfSeq(that, 0) + def indexOfSeq[B >: A](that: Seq[B]): Int = indexOfSeq(that, 0) - def indexOfSeq[B >: A](that: Sequence[B], fromIndex: Int): Int = + def indexOfSeq[B >: A](that: Seq[B], fromIndex: Int): Int = if (this.hasDefiniteSize && that.hasDefiniteSize) - SequenceLike.indexOf(thisCollection, 0, length, that, 0, that.length, fromIndex) + SeqLike.indexOf(thisCollection, 0, length, that, 0, that.length, fromIndex) else { var i = fromIndex - var s: Sequence[A] = thisCollection drop i + var s: Seq[A] = thisCollection drop i while (!s.isEmpty) { if (s startsWith that) return i @@ -360,12 +360,12 @@ trait SequenceLike[+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: Sequence[B]): Int = lastIndexOfSeq(that, that.length) + def lastIndexOfSeq[B >: A](that: Seq[B]): Int = lastIndexOfSeq(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: Sequence[B], fromIndex: Int): Int = - SequenceLike.lastIndexOf(thisCollection, 0, length, that, 0, that.length, fromIndex) + def lastIndexOfSeq[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 * sequence. @@ -390,7 +390,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * @return a sequence containing the elements of this * sequence and those of the given sequence <code>that</code>. */ - def union[B >: A, That](that: Sequence[B])(implicit bf: BuilderFactory[B, That, Repr]): That = + def union[B >: A, That](that: Seq[B])(implicit bf: BuilderFactory[B, That, Repr]): That = this ++ that /** <p> @@ -412,7 +412,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * <i>m</i> copies of each element present in both sequences, * where <i>m</i> is defined as above. */ - def diff[B >: A, That](that: Sequence[B]): Repr = { + def diff[B >: A, That](that: Seq[B]): Repr = { val occ = occCounts(that) val b = newBuilder for (x <- this) @@ -438,7 +438,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * @return the sequence of elements contained both in this sequence and * in the given sequence <code>that</code>. */ - def intersect[B >: A, That](that: Sequence[B]): Repr = { + def intersect[B >: A, That](that: Seq[B]): Repr = { val occ = occCounts(that) val b = newBuilder for (x <- this) @@ -449,7 +449,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => b.result } - private def occCounts[B](seq: Sequence[B]): mutable.Map[B, Int] = { + private def occCounts[B](seq: Seq[B]): mutable.Map[B, Int] = { val occ = new mutable.HashMap[B, Int] { override def default(k: B) = 0 } for (y <- seq) occ(y) += 1 occ @@ -474,7 +474,7 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * except that `replaced` elements starting from `from` are replaced * by `patch`. */ - def patch[B >: A, That](from: Int, patch: Sequence[B], replaced: Int)(implicit bf: BuilderFactory[B, That, Repr]): That = { + def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: BuilderFactory[B, That, Repr]): That = { val b = bf(repr) val (prefix, rest) = this.splitAt(from) b ++= toCollection(prefix) @@ -532,13 +532,13 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * * @return the sequence itself */ - override def toSequence: Sequence[A] = thisCollection + override def toSeq: Seq[A] = thisCollection /** The range of all indices of this sequence. */ def indices: Range = 0 until length - override def view = new SequenceView[A, Repr] { + override def view = new SeqView[A, Repr] { protected lazy val underlying = self.repr override def iterator = self.iterator override def length = self.length @@ -547,10 +547,10 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => override def view(from: Int, until: Int) = view.slice(from, until) - override def hashCode() = (Sequence.hashSeed /: this)(_ * 41 + _.hashCode) + override def hashCode() = (Seq.hashSeed /: this)(_ * 41 + _.hashCode) override def equals(that: Any): Boolean = that match { - case that: Sequence[_] => (that canEqual this) && (this sameElements that) + case that: Seq[_] => (that canEqual this) && (this sameElements that) case _ => false } @@ -569,10 +569,10 @@ trait SequenceLike[+A, +Repr] extends IterableLike[A, Repr] { self => * @throws IndexOutOfBoundsException if <code>from < 0</code> */ @deprecated("use `drop' instead") - def slice(from: Int): Sequence[A] = toCollection(slice(from, length)) + def slice(from: Int): Seq[A] = toCollection(slice(from, length)) @deprecated("Should be replaced by <code>(s1, s2) forall { case (x, y) => f(x, y) }</code>") - def equalsWith[B](that: Sequence[B])(f: (A,B) => Boolean): Boolean = { + def equalsWith[B](that: Seq[B])(f: (A,B) => Boolean): Boolean = { val i = this.iterator val j = that.iterator while (i.hasNext && j.hasNext) @@ -584,7 +584,7 @@ trait SequenceLike[+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: Sequence[B]): Boolean = indexOfSeq(that) != -1 + def containsSlice[B](that: Seq[B]): Boolean = indexOfSeq(that) != -1 /** * returns a projection that can be used to call non-strict <code>filter</code>, diff --git a/src/library/scala/collection/SequenceProxy.scala b/src/library/scala/collection/SeqProxy.scala index ffa956faf1..d2e4c0a7b7 100644 --- a/src/library/scala/collection/SequenceProxy.scala +++ b/src/library/scala/collection/SeqProxy.scala @@ -18,4 +18,4 @@ package scala.collection * @version 2.8 * @since 2.8 */ -trait SequenceProxy[+A] extends Sequence[A] with SequenceProxyLike[A, Sequence[A]] +trait SeqProxy[+A] extends Seq[A] with SeqProxyLike[A, Seq[A]] diff --git a/src/library/scala/collection/SequenceProxyLike.scala b/src/library/scala/collection/SeqProxyLike.scala index d2c846fb58..4ea57a2e99 100644 --- a/src/library/scala/collection/SequenceProxyLike.scala +++ b/src/library/scala/collection/SeqProxyLike.scala @@ -13,7 +13,7 @@ package scala.collection import generic._ -// Methods could be printed by cat SequenceLike.scala | egrep '^ (override )?def' +// Methods could be printed by cat SeqLike.scala | egrep '^ (override )?def' /** This trait implements a proxy for sequences. It forwards @@ -23,7 +23,7 @@ import generic._ * @version 2.8 * @since 2.8 */ -trait SequenceProxyLike[+A, +This <: SequenceLike[A, This] with Sequence[A]] extends SequenceLike[A, This] with IterableProxyLike[A, This] { +trait SeqProxyLike[+A, +This <: SeqLike[A, This] with Seq[A]] extends SeqLike[A, This] with IterableProxyLike[A, This] { override def length: Int = self.length override def apply(idx: Int): A = self.apply(idx) override def lengthCompare(len: Int): Int = self.lengthCompare(len) @@ -42,22 +42,22 @@ trait SequenceProxyLike[+A, +This <: SequenceLike[A, This] with Sequence[A]] ext override def lastIndexWhere(p: A => Boolean, end: Int): Int = self.lastIndexWhere(p) override def reverse: This = self.reverse override def reverseIterator: Iterator[A] = self.reverseIterator - override def startsWith[B](that: Sequence[B], offset: Int): Boolean = self.startsWith(that, offset) - override def startsWith[B](that: Sequence[B]): Boolean = self.startsWith(that) - override def endsWith[B](that: Sequence[B]): Boolean = self.endsWith(that) - override def indexOfSeq[B >: A](that: Sequence[B]): Int = self.indexOfSeq(that) + 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 contains(elem: Any): Boolean = self.contains(elem) - override def union[B >: A, That](that: Sequence[B])(implicit bf: BuilderFactory[B, That, This]): That = self.union(that)(bf) - override def diff[B >: A, That](that: Sequence[B]): This = self.diff(that) - override def intersect[B >: A, That](that: Sequence[B]): This = self.intersect(that) + override def union[B >: A, That](that: Seq[B])(implicit bf: BuilderFactory[B, That, This]): That = self.union(that)(bf) + override def diff[B >: A, That](that: Seq[B]): This = self.diff(that) + override def intersect[B >: A, That](that: Seq[B]): This = self.intersect(that) override def removeDuplicates: This = self.removeDuplicates - override def patch[B >: A, That](from: Int, patch: Sequence[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That = self.patch(from, patch, replaced)(bf) + override def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That = self.patch(from, patch, replaced)(bf) override def padTo[B >: A, That](len: Int, elem: B)(implicit bf: BuilderFactory[B, That, This]): That = self.padTo(len, elem)(bf) override def indices: Range = self.indices override def view = self.view override def view(from: Int, until: Int) = self.view(from, until) override def findLastIndexOf(p: A => Boolean): Int = self.lastIndexWhere(p) - override def slice(from: Int): Sequence[A] = self.drop(from) - override def equalsWith[B](that: Sequence[B])(f: (A,B) => Boolean): Boolean = (self zip that) forall { case (x,y) => f(x,y) } - override def containsSlice[B](that: Sequence[B]): Boolean = self.indexOfSeq(that) != -1 + override def slice(from: Int): Seq[A] = self.drop(from) + 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 } diff --git a/src/library/scala/collection/SequenceView.scala b/src/library/scala/collection/SeqView.scala index 3a03493932..40e1022754 100644 --- a/src/library/scala/collection/SequenceView.scala +++ b/src/library/scala/collection/SeqView.scala @@ -19,10 +19,10 @@ import TraversableView.NoBuilder * @author Martin Odersky * @version 2.8 */ -trait SequenceView[+A, +Coll] extends SequenceViewLike[A, Coll, SequenceView[A, Coll]] +trait SeqView[+A, +Coll] extends SeqViewLike[A, Coll, SeqView[A, Coll]] -object SequenceView { +object SeqView { type Coll = TraversableView[_, C] forSome {type C <: Traversable[_]} - implicit def builderFactory[A]: BuilderFactory[A, SequenceView[A, Sequence[_]], Coll] = new BuilderFactory[A, SequenceView[A, Sequence[_]], Coll] { def apply(from: Coll) = new NoBuilder } + implicit def builderFactory[A]: BuilderFactory[A, SeqView[A, Seq[_]], Coll] = new BuilderFactory[A, SeqView[A, Seq[_]], Coll] { def apply(from: Coll) = new NoBuilder } } diff --git a/src/library/scala/collection/SequenceViewLike.scala b/src/library/scala/collection/SeqViewLike.scala index c57985e044..471d447a15 100644 --- a/src/library/scala/collection/SequenceViewLike.scala +++ b/src/library/scala/collection/SeqViewLike.scala @@ -12,7 +12,7 @@ package scala.collection import generic._ -import Sequence.fill +import Seq.fill import TraversableView.NoBuilder /** A non-strict projection of an iterable. @@ -20,13 +20,13 @@ import TraversableView.NoBuilder * @author Martin Odersky * @version 2.8 */ -trait SequenceViewLike[+A, +trait SeqViewLike[+A, +Coll, - +This <: SequenceView[A, Coll] with SequenceViewLike[A, Coll, This]] - extends Sequence[A] with SequenceLike[A, This] with IterableView[A, Coll] with IterableViewLike[A, Coll, This] + +This <: SeqView[A, Coll] with SeqViewLike[A, Coll, This]] + extends Seq[A] with SeqLike[A, This] with IterableView[A, Coll] with IterableViewLike[A, Coll, This] { self => - trait Transformed[+B] extends SequenceView[B, Coll] with super.Transformed[B] { + trait Transformed[+B] extends SeqView[B, Coll] with super.Transformed[B] { override def length: Int override def apply(idx: Int): B } @@ -60,12 +60,12 @@ trait SequenceViewLike[+A, override def length = index(self.length) override def apply(idx: Int) = { val row = findRow(idx, 0, self.length - 1) - mapping(self(row)).toSequence(idx - index(row)) + mapping(self(row)).toSeq(idx - index(row)) } } trait Appended[B >: A] extends Transformed[B] with super.Appended[B] { - lazy val restSeq = rest.toSequence + lazy val restSeq = rest.toSeq override def length = self.length + restSeq.length override def apply(idx: Int) = if (idx < self.length) self(idx) else restSeq(idx - self.length) @@ -111,7 +111,7 @@ trait SequenceViewLike[+A, trait Patched[B >: A] extends Transformed[B] { protected[this] val from: Int - protected[this] val patch: Sequence[B] + protected[this] val patch: Seq[B] protected[this] val replaced: Int private lazy val plen = patch.length override def iterator: Iterator[B] = self.iterator patch (from, patch.iterator, replaced) @@ -134,13 +134,13 @@ trait SequenceViewLike[+A, protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p } protected override def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p } protected def newReversed: Transformed[A] = new Reversed { } - protected def newPatched[B >: A](_from: Int, _patch: Sequence[B], _replaced: Int): Transformed[B] = new Patched[B] { + protected def newPatched[B >: A](_from: Int, _patch: Seq[B], _replaced: Int): Transformed[B] = new Patched[B] { val from = _from; val patch = _patch; val replaced = _replaced } override def reverse: This = newReversed.asInstanceOf[This] - override def patch[B >: A, That](from: Int, patch: Sequence[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That = { + override def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That = { newPatched(from, patch, replaced).asInstanceOf[That] // was: val b = bf(repr) // if (b.isInstanceOf[NoBuilder[_]]) newPatched(from, patch, replaced).asInstanceOf[That] @@ -150,7 +150,7 @@ trait SequenceViewLike[+A, override def padTo[B >: A, That](len: Int, elem: B)(implicit bf: BuilderFactory[B, That, This]): That = patch(length, fill(len - length)(elem), 0) - override def stringPrefix = "SequenceView" + override def stringPrefix = "SeqView" } diff --git a/src/library/scala/collection/Traversable.scala b/src/library/scala/collection/Traversable.scala index 432acfac62..a5d4c6b18a 100644 --- a/src/library/scala/collection/Traversable.scala +++ b/src/library/scala/collection/Traversable.scala @@ -79,7 +79,7 @@ trait Traversable[+A] extends TraversableLike[A, Traversable[A]] override def toArray[B >: A : ClassManifest]: Array[B] override def toList: List[A] override def toIterable: Iterable[A] - override def toSequence: Sequence[A] + override def toSeq: Seq[A] override def toStream: Stream[A] // override def sortWith(lt : (A,A) => Boolean): Traversable[A] override def mkString(start: String, sep: String, end: String): String diff --git a/src/library/scala/collection/TraversableLike.scala b/src/library/scala/collection/TraversableLike.scala index b87dff042d..9f4bdbac7f 100644 --- a/src/library/scala/collection/TraversableLike.scala +++ b/src/library/scala/collection/TraversableLike.scala @@ -718,7 +718,7 @@ self => /** Returns a sequence with all elements in this traversable object. * @note Will not terminate for infinite-sized collections. */ - def toSequence: Sequence[A] = toList + def toSeq: Seq[A] = toList /** Returns a vector with all elements in this traversable object. * @note Will not terminate for infinite-sized collections. diff --git a/src/library/scala/collection/TraversableProxyLike.scala b/src/library/scala/collection/TraversableProxyLike.scala index ee50105bae..34ebc667c6 100644 --- a/src/library/scala/collection/TraversableProxyLike.scala +++ b/src/library/scala/collection/TraversableProxyLike.scala @@ -72,7 +72,7 @@ trait TraversableProxyLike[+A, +This <: TraversableLike[A, This] with Traversabl override def toArray[B >: A: ClassManifest]: Array[B] = self.toArray override def toList: List[A] = self.toList override def toIterable: Iterable[A] = self.toIterable - override def toSequence: Sequence[A] = self.toSequence + override def toSeq: Seq[A] = self.toSeq override def toStream: Stream[A] = self.toStream override def toSet[B >: A]: immutable.Set[B] = self.toSet override def mkString(start: String, sep: String, end: String): String = self.mkString(start, sep, end) diff --git a/src/library/scala/collection/Vector.scala b/src/library/scala/collection/Vector.scala index 93ca11427c..cf802ca095 100644 --- a/src/library/scala/collection/Vector.scala +++ b/src/library/scala/collection/Vector.scala @@ -27,13 +27,13 @@ import mutable.{Builder, ArrayBuffer} * @version 2.8 * @since 2.8 */ -trait Vector[+A] extends Sequence[A] +trait Vector[+A] extends Seq[A] with GenericTraversableTemplate[A, Vector] with VectorLike[A, Vector[A]] { override def companion: GenericCompanion[Vector] = Vector } -object Vector extends SequenceFactory[Vector] { +object Vector extends SeqFactory[Vector] { implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, Vector[A]] = mutable.Vector.newBuilder[A] } diff --git a/src/library/scala/collection/VectorLike.scala b/src/library/scala/collection/VectorLike.scala index 901d99972e..d4b2ca1d4c 100644 --- a/src/library/scala/collection/VectorLike.scala +++ b/src/library/scala/collection/VectorLike.scala @@ -15,7 +15,7 @@ import generic._ import mutable.ArrayBuffer /** Sequences that support O(1) element access and O(1) length computation. - * This class does not add any methods to Sequence but overrides several + * This class does not add any methods to Seq but overrides several * methods with optimized implementations. * * @author Sean McDirmid @@ -23,7 +23,7 @@ import mutable.ArrayBuffer * @version 2.8 * @since 2.8 */ -trait VectorLike[+A, +Repr] extends SequenceLike[A, Repr] { self => +trait VectorLike[+A, +Repr] extends SeqLike[A, Repr] { self => override protected[this] def thisCollection: Vector[A] = this.asInstanceOf[Vector[A]] override protected[this] def toCollection(repr: Repr): Vector[A] = repr.asInstanceOf[Vector[A]] @@ -177,7 +177,7 @@ trait VectorLike[+A, +Repr] extends SequenceLike[A, Repr] { self => } - // Overridden methods from Sequence + // Overridden methods from Seq override def lengthCompare(len: Int): Int = length - len @@ -223,7 +223,7 @@ trait VectorLike[+A, +Repr] extends SequenceLike[A, Repr] { self => } else Iterator.empty.next } - override def startsWith[B](that: Sequence[B], offset: Int): Boolean = that match { + override def startsWith[B](that: Seq[B], offset: Int): Boolean = that match { case that: Vector[_] => var i = offset var j = 0 @@ -247,7 +247,7 @@ trait VectorLike[+A, +Repr] extends SequenceLike[A, Repr] { self => !thatElems.hasNext } - override def endsWith[B](that: Sequence[B]): Boolean = that match { + override def endsWith[B](that: Seq[B]): Boolean = that match { case that: Vector[_] => var i = length - 1 var j = that.length - 1 diff --git a/src/library/scala/collection/VectorViewLike.scala b/src/library/scala/collection/VectorViewLike.scala index 3a1527f13a..dfaa0f4752 100644 --- a/src/library/scala/collection/VectorViewLike.scala +++ b/src/library/scala/collection/VectorViewLike.scala @@ -6,7 +6,7 @@ ** |/ ** \* */ -// $Id: Sequence.scala 16092 2008-09-12 10:37:06Z nielsen $ +// $Id: Seq.scala 16092 2008-09-12 10:37:06Z nielsen $ package scala.collection @@ -24,7 +24,7 @@ import TraversableView.NoBuilder trait VectorViewLike[+A, +Coll, +This <: VectorView[A, Coll] with VectorViewLike[A, Coll, This]] - extends Vector[A] with VectorLike[A, This] with SequenceView[A, Coll] with SequenceViewLike[A, Coll, This] + extends Vector[A] with VectorLike[A, This] with SeqView[A, Coll] with SeqViewLike[A, Coll, This] { self => trait Transformed[+B] extends VectorView[B, Coll] with super.Transformed[B] @@ -100,7 +100,7 @@ trait VectorViewLike[+A, protected override def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p } protected override def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p } protected override def newReversed: Transformed[A] = new Reversed { } - protected override def newPatched[B >: A](_from: Int, _patch: Sequence[B], _replaced: Int): Transformed[B] = new Patched[B] { + protected override def newPatched[B >: A](_from: Int, _patch: Seq[B], _replaced: Int): Transformed[B] = new Patched[B] { val from = _from; val patch = _patch; val replaced = _replaced } protected override def newZipped[B](that: Iterable[B]): Transformed[(A, B)] = new Zipped[B] { diff --git a/src/library/scala/collection/generic/IterableForwarder.scala b/src/library/scala/collection/generic/IterableForwarder.scala index 09903ae26a..600104938d 100644 --- a/src/library/scala/collection/generic/IterableForwarder.scala +++ b/src/library/scala/collection/generic/IterableForwarder.scala @@ -39,7 +39,7 @@ trait IterableForwarder[+A] extends Iterable[A] with TraversableForwarder[A] { protected def underlying: Iterable[A] // Iterable delegates - // Iterable methods could be printed by cat IterableTemplate.scala | sed -n '/trait Iterable/,$ p' | egrep '^ (override )?def' + // Iterable methods could be printed by cat IterableLike.scala | sed -n '/trait Iterable/,$ p' | egrep '^ (override )?def' override def iterator = underlying.iterator override def sameElements[B >: A](that: Iterable[B]): Boolean = underlying.sameElements(that) diff --git a/src/library/scala/collection/generic/SequenceFactory.scala b/src/library/scala/collection/generic/SeqFactory.scala index 3c2d36b1fd..fabffa0151 100644 --- a/src/library/scala/collection/generic/SequenceFactory.scala +++ b/src/library/scala/collection/generic/SeqFactory.scala @@ -12,16 +12,16 @@ package scala.collection package generic -/** A template for companion objects of Sequence and subclasses thereof. +/** A template for companion objects of Seq and subclasses thereof. * * @since 2.8 */ -abstract class SequenceFactory[CC[X] <: Sequence[X] with GenericTraversableTemplate[X, CC]] extends TraversableFactory[CC] { +abstract class SeqFactory[CC[X] <: Seq[X] with GenericTraversableTemplate[X, CC]] extends TraversableFactory[CC] { - /** This method is called in a pattern match { case Sequence(...) => }. + /** This method is called in a pattern match { case Seq(...) => }. * * @param x the selector value - * @return sequence wrapped in an option, if this is a Sequence, otherwise none + * @return sequence wrapped in an option, if this is a Seq, otherwise none */ def unapplySeq[A](x: CC[A]): Some[CC[A]] = Some(x) } diff --git a/src/library/scala/collection/generic/SequenceForwarder.scala b/src/library/scala/collection/generic/SeqForwarder.scala index f21a02605c..0472b901a5 100644 --- a/src/library/scala/collection/generic/SequenceForwarder.scala +++ b/src/library/scala/collection/generic/SeqForwarder.scala @@ -16,26 +16,26 @@ import scala.collection._ * all calls to a different sequence object except for * * - toString, hashCode, equals, stringPrefix - * - newBuilder, view, toSequence + * - newBuilder, view, toSeq * - all calls creating a new sequence of the same kind * - * The above methods are forwarded by subclass SequenceProxy + * The above methods are forwarded by subclass SeqProxy * * @author Martin Odersky * @version 2.8 * @since 2.8 */ -trait SequenceForwarder[+A] extends Sequence[A] with IterableForwarder[A] { +trait SeqForwarder[+A] extends Seq[A] with IterableForwarder[A] { - protected override def underlying: Sequence[A] + protected override def underlying: Seq[A] // PartialFunction delegates override def apply(i: Int): A = underlying.apply(i) override def isDefinedAt(x: Int): Boolean = underlying.isDefinedAt(x) - // Sequence delegates - // Sequence methods could be printed by cat SequenceTemplate.scala | sed -n '/trait Seq/,$ p' | egrep '^ (override )?def' + // Seq delegates + // Seq methods could be printed by cat SeqLike.scala | sed -n '/trait Seq/,$ p' | egrep '^ (override )?def' override def length: Int = underlying.length override def lengthCompare(l: Int) = underlying lengthCompare l @@ -44,9 +44,9 @@ trait SequenceForwarder[+A] extends Sequence[A] with IterableForwarder[A] { override def indexWhere(p: A => Boolean, from: Int): Int = underlying.indexWhere(p, from) override def indexOf[B >: A](elem: B, from: Int): Int = underlying.indexOf(elem, from) override def reverseIterator: Iterator[A] = underlying.reverseIterator - override def startsWith[B](that: Sequence[B], offset: Int): Boolean = underlying.startsWith(that, offset) - override def endsWith[B](that: Sequence[B]): Boolean = underlying.endsWith(that) - override def indexOfSeq[B >: A](that: Sequence[B]): Int = underlying.indexOfSeq(that) + 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 contains(elem: Any): Boolean = underlying.contains(elem) override def indices: Range = underlying.indices } diff --git a/src/library/scala/collection/generic/TraversableForwarder.scala b/src/library/scala/collection/generic/TraversableForwarder.scala index 50652e9343..5e24f2b367 100644 --- a/src/library/scala/collection/generic/TraversableForwarder.scala +++ b/src/library/scala/collection/generic/TraversableForwarder.scala @@ -42,7 +42,7 @@ trait TraversableForwarder[+A] extends Traversable[A] { protected def underlying: Traversable[A] // Iterable delegates - // Iterable methods could be printed by cat IterableTemplate.scala | sed -n '/trait Iterable/,$ p' | egrep '^ (override )?def' + // Iterable methods could be printed by cat TarversableLike.scala | sed -n '/trait Iterable/,$ p' | egrep '^ (override )?def' override def isEmpty = underlying.isEmpty override def nonEmpty = underlying.nonEmpty @@ -62,7 +62,7 @@ trait TraversableForwarder[+A] extends Traversable[A] { override def copyToArray[B >: A](xs: Array[B], start: Int, len: Int) = underlying.copyToArray(xs, start, len) override def toArray[B >: A : ClassManifest]: Array[B] = underlying.toArray override def toList: List[A] = underlying.toList - override def toSequence: Sequence[A] = underlying.toSequence + override def toSeq: Seq[A] = underlying.toSeq override def toStream: Stream[A] = underlying.toStream override def mkString(start: String, sep: String, end: String): String = underlying.mkString(start, sep, end) override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = underlying.addString(b, start, sep, end) diff --git a/src/library/scala/collection/immutable/LinearSequence.scala b/src/library/scala/collection/immutable/LinearSeq.scala index acfe7e826e..09ef071ca4 100644 --- a/src/library/scala/collection/immutable/LinearSequence.scala +++ b/src/library/scala/collection/immutable/LinearSeq.scala @@ -15,22 +15,22 @@ package immutable import generic._ import mutable.Builder -/** A subtrait of <code>collection.Sequence</code> which represents sequences +/** A subtrait of <code>collection.Seq</code> which represents sequences * that cannot be mutated. * * @since 2.8 */ -trait LinearSequence[+A] extends Sequence[A] - with scala.collection.LinearSequence[A] - with GenericTraversableTemplate[A, LinearSequence] - with LinearSequenceLike[A, LinearSequence[A]] { - override def companion: GenericCompanion[LinearSequence] = LinearSequence +trait LinearSeq[+A] extends Seq[A] + with scala.collection.LinearSeq[A] + with GenericTraversableTemplate[A, LinearSeq] + with LinearSeqLike[A, LinearSeq[A]] { + override def companion: GenericCompanion[LinearSeq] = LinearSeq } /** * @since 2.8 */ -object LinearSequence extends SequenceFactory[LinearSequence] { - implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, LinearSequence[A]] = new mutable.ListBuffer +object LinearSeq extends SeqFactory[LinearSeq] { + implicit def builderFactory[A]: BuilderFactory[A, LinearSeq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, LinearSeq[A]] = new mutable.ListBuffer } diff --git a/src/library/scala/collection/immutable/List.scala b/src/library/scala/collection/immutable/List.scala index cea5753e18..b7a2908536 100644 --- a/src/library/scala/collection/immutable/List.scala +++ b/src/library/scala/collection/immutable/List.scala @@ -26,13 +26,13 @@ import annotation.tailrec * @version 2.8 * @since 2.8 */ -sealed abstract class List[+A] extends LinearSequence[A] +sealed abstract class List[+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. @@ -450,7 +450,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 } } @@ -498,9 +498,9 @@ final case class ::[B](private var hd: B, private[scala] var tl: List[B]) extend * @version 2.8 * @since 2.8 */ -object List extends SequenceFactory[List] { +object List extends SeqFactory[List] { - import scala.collection.{Iterable, Sequence, Vector} + import scala.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/src/library/scala/collection/immutable/Queue.scala b/src/library/scala/collection/immutable/Queue.scala index 80c7285be8..2d5b05778b 100644 --- a/src/library/scala/collection/immutable/Queue.scala +++ b/src/library/scala/collection/immutable/Queue.scala @@ -30,7 +30,7 @@ object Queue { @SerialVersionUID(-7622936493364270175L) class Queue[+A] protected( protected val in: List[A], - protected val out: List[A]) extends Sequence[A] + protected val out: List[A]) extends Seq[A] { /** Returns the <code>n</code>-th element of this queue. * The first element is at position 0. diff --git a/src/library/scala/collection/immutable/Sequence.scala b/src/library/scala/collection/immutable/Seq.scala index 7127b3fc9d..6091971ffd 100644 --- a/src/library/scala/collection/immutable/Sequence.scala +++ b/src/library/scala/collection/immutable/Seq.scala @@ -15,22 +15,22 @@ package immutable import generic._ import mutable.Builder -/** A subtrait of collection.Sequence which represents sequences +/** A subtrait of collection.Seq which represents sequences * that cannot be mutated. * * @since 2.8 */ -trait Sequence[+A] extends Iterable[A] - with scala.collection.Sequence[A] - with GenericTraversableTemplate[A, Sequence] - with SequenceLike[A, Sequence[A]] { - override def companion: GenericCompanion[Sequence] = Sequence +trait Seq[+A] extends Iterable[A] + with scala.collection.Seq[A] + with GenericTraversableTemplate[A, Seq] + with SeqLike[A, Seq[A]] { + override def companion: GenericCompanion[Seq] = Seq } /** * @since 2.8 */ -object Sequence extends SequenceFactory[Sequence] { - implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, Sequence[A]] = new mutable.ListBuffer +object Seq extends SeqFactory[Seq] { + implicit def builderFactory[A]: BuilderFactory[A, Seq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, Seq[A]] = new mutable.ListBuffer } diff --git a/src/library/scala/collection/immutable/Stack.scala b/src/library/scala/collection/immutable/Stack.scala index a7b3e8a614..2813bc6656 100644 --- a/src/library/scala/collection/immutable/Stack.scala +++ b/src/library/scala/collection/immutable/Stack.scala @@ -33,7 +33,7 @@ object Stack { * @since 1 */ @serializable @SerialVersionUID(1976480595012942526L) -class Stack[+A] protected (protected val elems: List[A]) extends Sequence[A] { +class Stack[+A] protected (protected val elems: List[A]) extends Seq[A] { def this() = this(Nil) diff --git a/src/library/scala/collection/immutable/Stream.scala b/src/library/scala/collection/immutable/Stream.scala index 01530294e0..bcf8076a1c 100644 --- a/src/library/scala/collection/immutable/Stream.scala +++ b/src/library/scala/collection/immutable/Stream.scala @@ -38,13 +38,13 @@ import scala.annotation.tailrec * @version 1.1 08/08/03 * @since 2.8 */ -abstract class Stream[+A] extends LinearSequence[A] +abstract class Stream[+A] extends LinearSeq[A] with GenericTraversableTemplate[A, Stream] - with LinearSequenceLike[A, Stream[A]] { + with LinearSeqLike[A, Stream[A]] { self => override def companion: GenericCompanion[Stream] = Stream - import scala.collection.{Traversable, Iterable, Sequence, Vector} + import scala.collection.{Traversable, Iterable, Seq, Vector} /** is this stream empty? */ def isEmpty: Boolean @@ -317,7 +317,7 @@ self => these } - // there's nothing we can do about dropRight, so we just keep the definition in LinearSequence + // there's nothing we can do about dropRight, so we just keep the definition in LinearSeq /** Returns the longest prefix of this stream whose elements satisfy * the predicate <code>p</code>. @@ -398,7 +398,7 @@ self => * @version 1.1 08/08/03 * @since 2.8 */ -object Stream extends SequenceFactory[Stream] { +object Stream extends SeqFactory[Stream] { /** The factory for streams. * @note Methods such as map/flatMap will not invoke the Builder factory, @@ -415,7 +415,7 @@ object Stream extends SequenceFactory[Stream] { /** Creates a new builder for a stream */ def newBuilder[A]: Builder[A, Stream[A]] = new StreamBuilder[A] - import scala.collection.{Iterable, Sequence, Vector} + import scala.collection.{Iterable, Seq, Vector} /** A builder for streams * @note: This builder is lazy only in the sense that it does not go downs the spine diff --git a/src/library/scala/collection/immutable/StringLike.scala b/src/library/scala/collection/immutable/StringLike.scala index 3d4a0b8fb9..c1aa03a16c 100644 --- a/src/library/scala/collection/immutable/StringLike.scala +++ b/src/library/scala/collection/immutable/StringLike.scala @@ -235,7 +235,7 @@ self => * @throws java.lang.IllegalArgumentException */ def format(args : Any*) : String = - java.lang.String.format(toString, args.asInstanceOf[Seq[AnyRef]]: _*) + java.lang.String.format(toString, args.asInstanceOf[scala.collection.Seq[AnyRef]]: _*) /** <p> * Like format(args*) but takes an initial Locale parameter @@ -252,6 +252,6 @@ self => * @throws java.lang.IllegalArgumentException */ def format(l: java.util.Locale, args: Any*): String = - java.lang.String.format(l, toString, args.asInstanceOf[Seq[AnyRef]]: _*) + java.lang.String.format(l, toString, args.asInstanceOf[scala.collection.Seq[AnyRef]]: _*) } diff --git a/src/library/scala/collection/immutable/Vector.scala b/src/library/scala/collection/immutable/Vector.scala index 3bc8955194..7e76549f7e 100644 --- a/src/library/scala/collection/immutable/Vector.scala +++ b/src/library/scala/collection/immutable/Vector.scala @@ -20,7 +20,7 @@ import mutable.{Builder, ArrayBuffer} * * @since 2.8 */ -trait Vector[+A] extends Sequence[A] +trait Vector[+A] extends Seq[A] with scala.collection.Vector[A] with GenericTraversableTemplate[A, Vector] with VectorLike[A, Vector[A]] { @@ -30,7 +30,7 @@ trait Vector[+A] extends Sequence[A] /** * @since 2.8 */ -object Vector extends SequenceFactory[Vector] { +object Vector extends SeqFactory[Vector] { // todo: insert better vector implementation here @serializable @SerialVersionUID(7129304555082767876L) class Impl[A](buf: ArrayBuffer[A]) extends Vector[A] { diff --git a/src/library/scala/collection/interfaces/SequenceMethods.scala b/src/library/scala/collection/interfaces/SeqMethods.scala index ee91d33648..a595d101fa 100644 --- a/src/library/scala/collection/interfaces/SequenceMethods.scala +++ b/src/library/scala/collection/interfaces/SeqMethods.scala @@ -16,43 +16,43 @@ import scala.reflect.ClassManifest /** * @since 2.8 */ -trait SequenceMethods[+A, +This <: SequenceLike[A, This] with Sequence[A]] extends IterableMethods[A, This] +trait SeqMethods[+A, +This <: SeqLike[A, This] with Seq[A]] extends IterableMethods[A, This] { // abstract def apply(idx: Int): A def length: Int def contains(elem: Any): Boolean - def diff[B >: A, That](that: Sequence[B]): This - def endsWith[B](that: Sequence[B]): Boolean - def indexOfSeq[B >: A](that: Sequence[B]): Int - def indexOfSeq[B >: A](that: Sequence[B], fromIndex: Int): Int + 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 indexOf[B >: A](elem: B): Int def indexOf[B >: A](elem: B, from: Int): Int def indexWhere(p: A => Boolean): Int def indexWhere(p: A => Boolean, from: Int): Int def indices: Range - def intersect[B >: A, That](that: Sequence[B]): This + def intersect[B >: A, That](that: Seq[B]): This def isDefinedAt(x: Int): Boolean - def lastIndexOfSeq[B >: A](that: Sequence[B]): Int - def lastIndexOfSeq[B >: A](that: Sequence[B], fromIndex: Int): Int + def lastIndexOfSeq[B >: A](that: Seq[B]): Int + def lastIndexOfSeq[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 def lastIndexWhere(p: A => Boolean, end: Int): Int def lengthCompare(len: Int): Int def padTo[B >: A, That](len: Int, elem: B)(implicit bf: BuilderFactory[B, That, This]): That - def patch[B >: A, That](from: Int, patch: Sequence[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That + def patch[B >: A, That](from: Int, patch: Seq[B], replaced: Int)(implicit bf: BuilderFactory[B, That, This]): That def prefixLength(p: A => Boolean): Int def removeDuplicates: This def reverse: This def reverseIterator: Iterator[A] def segmentLength(p: A => Boolean, from: Int): Int - def slice(from: Int): Sequence[A] - def startsWith[B](that: Sequence[B]): Boolean - def startsWith[B](that: Sequence[B], offset: Int): Boolean - def union[B >: A, That](that: Sequence[B])(implicit bf: BuilderFactory[B, That, This]): That + def slice(from: Int): Seq[A] + def startsWith[B](that: Seq[B]): Boolean + def startsWith[B](that: Seq[B], offset: Int): Boolean + def union[B >: A, That](that: Seq[B])(implicit bf: BuilderFactory[B, That, This]): That - override def view: SequenceView[A, This] - override def view(from: Int, until: Int): SequenceView[A, This] + override def view: SeqView[A, This] + override def view(from: Int, until: Int): SeqView[A, This] } diff --git a/src/library/scala/collection/interfaces/TraversableMethods.scala b/src/library/scala/collection/interfaces/TraversableMethods.scala index 4e8cdf6ec7..ffedb10476 100644 --- a/src/library/scala/collection/interfaces/TraversableMethods.scala +++ b/src/library/scala/collection/interfaces/TraversableMethods.scala @@ -37,7 +37,7 @@ trait TraversableMethods[+A, +This <: TraversableLike[A, This] with Traversable[ def toArray[B >: A : ClassManifest]: Array[B] def toIterable: Iterable[A] def toList: List[A] - def toSequence: Sequence[A] + def toSeq: Seq[A] def toSet[B >: A]: immutable.Set[B] def toStream: Stream[A] def toVector[B >: A]: mutable.Vector[B] diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala index f0a52d9f26..6c2f092505 100644 --- a/src/library/scala/collection/mutable/ArrayBuffer.scala +++ b/src/library/scala/collection/mutable/ArrayBuffer.scala @@ -167,7 +167,7 @@ class ArrayBuffer[A](override protected val initialSize: Int) * @version 2.8 * @since 2.8 */ -object ArrayBuffer extends SequenceFactory[ArrayBuffer] { +object ArrayBuffer extends SeqFactory[ArrayBuffer] { implicit def builderFactory[A]: BuilderFactory[A, ArrayBuffer[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, ArrayBuffer[A]] = new ArrayBuffer[A] diff --git a/src/library/scala/collection/mutable/ArrayStack.scala b/src/library/scala/collection/mutable/ArrayStack.scala index 5e2f5e2b1a..0059d5ff6b 100644 --- a/src/library/scala/collection/mutable/ArrayStack.scala +++ b/src/library/scala/collection/mutable/ArrayStack.scala @@ -37,7 +37,7 @@ private object Utils { */ @cloneable class ArrayStack[T] private(private var table : Array[AnyRef], - private var index : Int) extends scala.collection.Sequence[T] with Cloneable[ArrayStack[T]] { + private var index : Int) extends scala.collection.Seq[T] with Cloneable[ArrayStack[T]] { def this() = this(new Array[AnyRef](1), 0) /** Retrieve n'th element from stack, where top of stack has index 0 */ diff --git a/src/library/scala/collection/mutable/Buffer.scala b/src/library/scala/collection/mutable/Buffer.scala index a11ef77fef..59da5bbd83 100644 --- a/src/library/scala/collection/mutable/Buffer.scala +++ b/src/library/scala/collection/mutable/Buffer.scala @@ -25,7 +25,7 @@ import generic._ * @since 1 */ @cloneable -trait Buffer[A] extends Sequence[A] +trait Buffer[A] extends Seq[A] with GenericTraversableTemplate[A, Buffer] with BufferLike[A, Buffer[A]] { override def companion: GenericCompanion[Buffer] = Buffer @@ -33,7 +33,7 @@ trait Buffer[A] extends Sequence[A] /** Factory object for <code>Buffer</code> trait. */ -object Buffer extends SequenceFactory[Buffer] { +object Buffer extends SeqFactory[Buffer] { implicit def builderFactory[A]: BuilderFactory[A, Buffer[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, Buffer[A]] = new ArrayBuffer } diff --git a/src/library/scala/collection/mutable/BufferLike.scala b/src/library/scala/collection/mutable/BufferLike.scala index 428b5b7aa9..a1506ce6ed 100644 --- a/src/library/scala/collection/mutable/BufferLike.scala +++ b/src/library/scala/collection/mutable/BufferLike.scala @@ -33,7 +33,7 @@ trait BufferLike[A, +This <: BufferLike[A, This] with Buffer[A]] with Addable[A, This] with Subtractable[A, This] with Cloneable[This] - with SequenceLike[A, This] + with SeqLike[A, This] { self => import scala.collection.{Iterable, Traversable} @@ -329,7 +329,7 @@ trait BufferLike[A, +This <: BufferLike[A, This] with Buffer[A]] repr } - def readOnly: scala.collection.Sequence[A] = toSequence + def readOnly: scala.collection.Seq[A] = toSeq } diff --git a/src/library/scala/collection/mutable/DoubleLinkedList.scala b/src/library/scala/collection/mutable/DoubleLinkedList.scala index 3534e4727b..1c5d7211c0 100644 --- a/src/library/scala/collection/mutable/DoubleLinkedList.scala +++ b/src/library/scala/collection/mutable/DoubleLinkedList.scala @@ -23,7 +23,7 @@ import generic._ * @since 1 */ @serializable @SerialVersionUID(419155950203746706L) -class DoubleLinkedList[A](_elem: A, _next: DoubleLinkedList[A]) extends LinearSequence[A] +class DoubleLinkedList[A](_elem: A, _next: DoubleLinkedList[A]) extends LinearSeq[A] with GenericTraversableTemplate[A, DoubleLinkedList] with DoubleLinkedListLike[A, DoubleLinkedList[A]] { elem = _elem @@ -31,7 +31,7 @@ class DoubleLinkedList[A](_elem: A, _next: DoubleLinkedList[A]) extends LinearSe override def companion: GenericCompanion[DoubleLinkedList] = DoubleLinkedList } -object DoubleLinkedList extends SequenceFactory[DoubleLinkedList] { +object DoubleLinkedList extends SeqFactory[DoubleLinkedList] { implicit def builderFactory[A]: BuilderFactory[A, DoubleLinkedList[A], Coll] = //new BuilderFactory[A, DoubleLinkedList[A], Coll] { def apply(from: Coll) = from.traversableBuilder[A] } new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, DoubleLinkedList[A]] = diff --git a/src/library/scala/collection/mutable/DoubleLinkedListLike.scala b/src/library/scala/collection/mutable/DoubleLinkedListLike.scala index 2297d40209..65b0621b6b 100644 --- a/src/library/scala/collection/mutable/DoubleLinkedListLike.scala +++ b/src/library/scala/collection/mutable/DoubleLinkedListLike.scala @@ -21,7 +21,7 @@ package mutable * @version 1.0, 08/07/2003 * @since 2.8 */ -trait DoubleLinkedListLike[A, This >: Null <: LinearSequence[A] with DoubleLinkedListLike[A, This]] extends LinkedListLike[A, This] { self => +trait DoubleLinkedListLike[A, This >: Null <: LinearSeq[A] with DoubleLinkedListLike[A, This]] extends LinkedListLike[A, This] { self => var prev: This = _ diff --git a/src/library/scala/collection/mutable/GenericArray.scala b/src/library/scala/collection/mutable/GenericArray.scala index 106eedc766..9194d7f39c 100644 --- a/src/library/scala/collection/mutable/GenericArray.scala +++ b/src/library/scala/collection/mutable/GenericArray.scala @@ -54,7 +54,7 @@ extends Vector[A] /** Copy all elements to a buffer * @param The buffer to which elements are copied override def copyToBuffer[B >: A](dest: Buffer[B]) { - dest ++= (array: Sequence[AnyRef]).asInstanceOf[Sequence[B]] + dest ++= (array: Seq[AnyRef]).asInstanceOf[Seq[B]] } */ @@ -67,7 +67,7 @@ extends Vector[A] } } -object GenericArray extends SequenceFactory[GenericArray] { +object GenericArray extends SeqFactory[GenericArray] { implicit def builderFactory[A]: BuilderFactory[A, GenericArray[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, GenericArray[A]] = new ArrayBuffer[A] mapResult { buf => diff --git a/src/library/scala/collection/mutable/LinearSequence.scala b/src/library/scala/collection/mutable/LinearSeq.scala index 75da5021c3..285dc7721d 100644 --- a/src/library/scala/collection/mutable/LinearSequence.scala +++ b/src/library/scala/collection/mutable/LinearSeq.scala @@ -14,19 +14,19 @@ package mutable import generic._ -/** A subtrait of <code>collection.Sequence</code> which represents sequences +/** A subtrait of <code>collection.Seq</code> which represents sequences * that cannot be mutated. * * @since 2.8 */ -trait LinearSequence[A] extends Sequence[A] - with scala.collection.LinearSequence[A] - with GenericTraversableTemplate[A, LinearSequence] - with LinearSequenceLike[A, LinearSequence[A]] { - override def companion: GenericCompanion[LinearSequence] = LinearSequence +trait LinearSeq[A] extends Seq[A] + with scala.collection.LinearSeq[A] + with GenericTraversableTemplate[A, LinearSeq] + with LinearSeqLike[A, LinearSeq[A]] { + override def companion: GenericCompanion[LinearSeq] = LinearSeq } -object LinearSequence extends SequenceFactory[LinearSequence] { - implicit def builderFactory[A]: BuilderFactory[A, LinearSequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, LinearSequence[A]] = new MutableList[A] +object LinearSeq extends SeqFactory[LinearSeq] { + implicit def builderFactory[A]: BuilderFactory[A, LinearSeq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, LinearSeq[A]] = new MutableList[A] } diff --git a/src/library/scala/collection/mutable/LinkedList.scala b/src/library/scala/collection/mutable/LinkedList.scala index cc171c07de..a881902a67 100644 --- a/src/library/scala/collection/mutable/LinkedList.scala +++ b/src/library/scala/collection/mutable/LinkedList.scala @@ -23,7 +23,7 @@ import generic._ * @since 1 */ @serializable -class LinkedList[A](_elem: A, _next: LinkedList[A]) extends LinearSequence[A] +class LinkedList[A](_elem: A, _next: LinkedList[A]) extends LinearSeq[A] with GenericTraversableTemplate[A, LinkedList] with LinkedListLike[A, LinkedList[A]] { elem = _elem @@ -31,7 +31,7 @@ class LinkedList[A](_elem: A, _next: LinkedList[A]) extends LinearSequence[A] override def companion: GenericCompanion[LinkedList] = LinkedList } -object LinkedList extends SequenceFactory[LinkedList] { +object LinkedList extends SeqFactory[LinkedList] { implicit def builderFactory[A]: BuilderFactory[A, LinkedList[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, LinkedList[A]] = diff --git a/src/library/scala/collection/mutable/LinkedListLike.scala b/src/library/scala/collection/mutable/LinkedListLike.scala index 9ce8284772..e26735ed23 100644 --- a/src/library/scala/collection/mutable/LinkedListLike.scala +++ b/src/library/scala/collection/mutable/LinkedListLike.scala @@ -24,7 +24,7 @@ import annotation.tailrec * @version 2.8 * @since 2.8 */ -trait LinkedListLike[A, This >: Null <: Sequence[A] with LinkedListLike[A, This]] extends SequenceLike[A, This] { self => +trait LinkedListLike[A, This >: Null <: Seq[A] with LinkedListLike[A, This]] extends SeqLike[A, This] { self => var elem: A = _ var next: This = _ diff --git a/src/library/scala/collection/mutable/ListBuffer.scala b/src/library/scala/collection/mutable/ListBuffer.scala index 7d40719b02..fa8d777977 100644 --- a/src/library/scala/collection/mutable/ListBuffer.scala +++ b/src/library/scala/collection/mutable/ListBuffer.scala @@ -28,7 +28,7 @@ final class ListBuffer[A] with GenericTraversableTemplate[A, ListBuffer] with BufferLike[A, ListBuffer[A]] with Builder[A, List[A]] - with SequenceForwarder[A] + with SeqForwarder[A] { override def companion: GenericCompanion[ListBuffer] = ListBuffer @@ -39,7 +39,7 @@ final class ListBuffer[A] private var exported: Boolean = false private var len = 0 - protected def underlying: immutable.Sequence[A] = start + protected def underlying: immutable.Seq[A] = start /** The current length of the buffer */ @@ -328,7 +328,7 @@ final class ListBuffer[A] * @author Martin Odersky * @version 2.8 */ -object ListBuffer extends SequenceFactory[ListBuffer] { +object ListBuffer extends SeqFactory[ListBuffer] { implicit def builderFactory[A]: BuilderFactory[A, ListBuffer[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, ListBuffer[A]] = diff --git a/src/library/scala/collection/mutable/MutableList.scala b/src/library/scala/collection/mutable/MutableList.scala index dcf163bcb2..d85dde71da 100644 --- a/src/library/scala/collection/mutable/MutableList.scala +++ b/src/library/scala/collection/mutable/MutableList.scala @@ -27,8 +27,8 @@ import generic._ * @since 1 */ @serializable @SerialVersionUID(5938451523372603072L) -class MutableList[A] extends LinearSequence[A] - with LinearSequenceLike[A, MutableList[A]] +class MutableList[A] extends LinearSeq[A] + with LinearSeqLike[A, MutableList[A]] with Builder[A, MutableList[A]] { override protected[this] def newBuilder = new MutableList[A] diff --git a/src/library/scala/collection/mutable/Queue.scala b/src/library/scala/collection/mutable/Queue.scala index 1c9e98b1f0..6316b2d5c6 100644 --- a/src/library/scala/collection/mutable/Queue.scala +++ b/src/library/scala/collection/mutable/Queue.scala @@ -80,9 +80,9 @@ class Queue[A] extends MutableList[A] with Cloneable[Queue[A]] { * @return a sequence of all elements in the queue for which * p yields true. */ - def dequeueAll(p: A => Boolean): Sequence[A] = { + def dequeueAll(p: A => Boolean): Seq[A] = { if (first0 eq null) - Sequence.empty + Seq.empty else { val res = new ArrayBuffer[A] while ((first0 ne null) && p(first0.elem)) { diff --git a/src/library/scala/collection/mutable/ResizableArray.scala b/src/library/scala/collection/mutable/ResizableArray.scala index 2f45881307..25a41b278e 100644 --- a/src/library/scala/collection/mutable/ResizableArray.scala +++ b/src/library/scala/collection/mutable/ResizableArray.scala @@ -63,7 +63,7 @@ trait ResizableArray[A] extends Vector[A] /** Copy all elements to a buffer * @param The buffer to which elements are copied override def copyToBuffer[B >: A](dest: Buffer[B]) { - dest ++= (array: Sequence[AnyRef]).asInstanceOf[Sequence[B]] + dest ++= (array: Seq[AnyRef]).asInstanceOf[Seq[B]] } */ @@ -114,7 +114,7 @@ trait ResizableArray[A] extends Vector[A] } } -object ResizableArray extends SequenceFactory[ResizableArray] { +object ResizableArray extends SeqFactory[ResizableArray] { implicit def builderFactory[A]: BuilderFactory[A, ResizableArray[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, ResizableArray[A]] = new ArrayBuffer[A] } diff --git a/src/library/scala/collection/mutable/Sequence.scala b/src/library/scala/collection/mutable/Seq.scala index 961c144338..e6a9acf84a 100644 --- a/src/library/scala/collection/mutable/Sequence.scala +++ b/src/library/scala/collection/mutable/Seq.scala @@ -14,28 +14,28 @@ package mutable import generic._ -/** A subtrait of <code>collection.Sequence</code> which represents sequences +/** A subtrait of <code>collection.Seq</code> which represents sequences * that can be mutated. - * The class adds an <code>update</code> method to <code>collection.Sequence</code>. + * The class adds an <code>update</code> method to <code>collection.Seq</code>. * * @since 2.8 */ -trait Sequence[A] extends Iterable[A] - with scala.collection.Sequence[A] - with GenericTraversableTemplate[A, Sequence] - with SequenceLike[A, Sequence[A]] { - override def companion: GenericCompanion[Sequence] = Sequence +trait Seq[A] extends Iterable[A] + with scala.collection.Seq[A] + with GenericTraversableTemplate[A, Seq] + with SeqLike[A, Seq[A]] { + override def companion: GenericCompanion[Seq] = Seq def update(idx: Int, elem: A) } -/** A factory object for the trait <code>Sequence</code>. +/** A factory object for the trait <code>Seq</code>. * * @author Martin Odersky * @version 2.8 * @since 2.8 */ -object Sequence extends SequenceFactory[Sequence] { - implicit def builderFactory[A]: BuilderFactory[A, Sequence[A], Coll] = new VirtualBuilderFactory[A] - def newBuilder[A]: Builder[A, Sequence[A]] = new ArrayBuffer +object Seq extends SeqFactory[Seq] { + implicit def builderFactory[A]: BuilderFactory[A, Seq[A], Coll] = new VirtualBuilderFactory[A] + def newBuilder[A]: Builder[A, Seq[A]] = new ArrayBuffer } diff --git a/src/library/scala/collection/mutable/Stack.scala b/src/library/scala/collection/mutable/Stack.scala index 8790a81767..ee66c2a2a3 100644 --- a/src/library/scala/collection/mutable/Stack.scala +++ b/src/library/scala/collection/mutable/Stack.scala @@ -23,7 +23,7 @@ import generic._ * @since 1 */ @serializable @cloneable -class Stack[A] private (var elems: List[A]) extends scala.collection.Sequence[A] with Cloneable[Stack[A]] { +class Stack[A] private (var elems: List[A]) extends scala.collection.Seq[A] with Cloneable[Stack[A]] { def this() = this(Nil) diff --git a/src/library/scala/collection/mutable/StringBuilder.scala b/src/library/scala/collection/mutable/StringBuilder.scala index 6bebc430a7..2f062b4b94 100644 --- a/src/library/scala/collection/mutable/StringBuilder.scala +++ b/src/library/scala/collection/mutable/StringBuilder.scala @@ -35,6 +35,8 @@ final class StringBuilder(initCapacity: Int, private val initValue: String) require(initCapacity >= 0) + import scala.collection.Seq + /** The value is used for character storage. */ private var array = new Array[Char](initCapacity + initValue.length) diff --git a/src/library/scala/collection/mutable/Vector.scala b/src/library/scala/collection/mutable/Vector.scala index cb81aab03b..42fb62fccd 100644 --- a/src/library/scala/collection/mutable/Vector.scala +++ b/src/library/scala/collection/mutable/Vector.scala @@ -17,14 +17,14 @@ import generic._ /** A subtrait of <code>collection.Vector</code> which represents sequences * that can be mutated. */ -trait Vector[A] extends Sequence[A] +trait Vector[A] extends Seq[A] with scala.collection.Vector[A] with GenericTraversableTemplate[A, Vector] with VectorLike[A, Vector[A]] { override def companion: GenericCompanion[Vector] = Vector } -object Vector extends SequenceFactory[Vector] { +object Vector extends SeqFactory[Vector] { implicit def builderFactory[A]: BuilderFactory[A, Vector[A], Coll] = new VirtualBuilderFactory[A] def newBuilder[A]: Builder[A, Vector[A]] = new ArrayBuffer } diff --git a/src/library/scala/package.scala b/src/library/scala/package.scala index c894e1e9ad..a4a14ccdf5 100644 --- a/src/library/scala/package.scala +++ b/src/library/scala/package.scala @@ -16,8 +16,10 @@ package object scala { @deprecated("use Iterable instead") type Collection[+A] = Iterable[A] @deprecated("use Iterable instead") val Collection = Iterable - type Seq[+A] = scala.collection.Sequence[A] - val Seq = scala.collection.Sequence + type Seq[+A] = scala.collection.Seq[A] + val Seq = scala.collection.Seq + + @deprecated("use Seq instead") type Sequence[+A] = scala.collection.Seq[A] type RandomAccessSeq[+A] = scala.collection.Vector[A] val RandomAccessSeq = scala.collection.Vector diff --git a/src/library/scala/runtime/BoxedArray.scala b/src/library/scala/runtime/BoxedArray.scala index dd0f5ddf94..7293cff319 100644 --- a/src/library/scala/runtime/BoxedArray.scala +++ b/src/library/scala/runtime/BoxedArray.scala @@ -14,7 +14,7 @@ package scala.runtime import Predef._ import scala.reflect.ClassManifest import collection.mutable._ -import collection.Sequence +import collection.Seq /** * <p>A class representing <code>Array[T]</code></p> diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala index 158e83b582..89096e0e6f 100644 --- a/src/library/scala/runtime/ScalaRunTime.scala +++ b/src/library/scala/runtime/ScalaRunTime.scala @@ -12,7 +12,7 @@ package scala.runtime import scala.reflect.ClassManifest -import scala.collection.Sequence +import scala.collection.Seq import scala.collection.mutable._ /* The object <code>ScalaRunTime</code> provides ... @@ -55,7 +55,7 @@ object ScalaRunTime { dest } - def toArray[T](xs: scala.collection.Sequence[T]) = { + def toArray[T](xs: scala.collection.Seq[T]) = { val arr = new Array[AnyRef](xs.length) var i = 0 for (x <- xs) arr(i) = x.asInstanceOf[AnyRef] diff --git a/src/library/scala/util/Random.scala b/src/library/scala/util/Random.scala index ac01b9172c..0cf2490c81 100644 --- a/src/library/scala/util/Random.scala +++ b/src/library/scala/util/Random.scala @@ -107,13 +107,13 @@ class Random(val self: java.util.Random) { */ object Random extends Random { - import collection.Sequence + import collection.Seq /** Returns a new sequence in random order. * @param seq the sequence to shuffle * @return the shuffled sequence */ - def shuffle[T: ClassManifest](seq: Sequence[T]): Sequence[T] = { + def shuffle[T: ClassManifest](seq: Seq[T]): Seq[T] = { // It would be better if this preserved the shape of its container, but I have // again been defeated by the lack of higher-kinded type inference. I can // only make it work that way if it's called like @@ -132,11 +132,11 @@ object Random extends Random swap(n - 1, k) } - buf.toSequence + buf.toSeq } /** I was consumed by weeping when I discovered how easy this - * is to implement in SequenceTemplate rather than trying to + * is to implement in SeqLike rather than trying to * accomplish the inference from the outside. For reference * here is the shape-preserving implementation. */ diff --git a/src/library/scala/util/control/Exception.scala b/src/library/scala/util/control/Exception.scala index 70c34015ac..bf53eed251 100644 --- a/src/library/scala/util/control/Exception.scala +++ b/src/library/scala/util/control/Exception.scala @@ -201,7 +201,7 @@ object Exception } /** Private **/ - private def wouldMatch(x: Throwable, classes: collection.Sequence[Class[_]]): Boolean = + private def wouldMatch(x: Throwable, classes: collection.Seq[Class[_]]): Boolean = classes exists (_ isAssignableFrom x.getClass) private def pfFromExceptions(exceptions: Class[_]*) = diff --git a/src/library/scala/xml/NodeSeq.scala b/src/library/scala/xml/NodeSeq.scala index 8f2e3a994d..bd9999ab3c 100644 --- a/src/library/scala/xml/NodeSeq.scala +++ b/src/library/scala/xml/NodeSeq.scala @@ -12,7 +12,7 @@ package scala.xml import collection.immutable -import collection.SequenceLike +import collection.SeqLike import collection.mutable.{Builder, ListBuffer} import collection.generic.BuilderFactory @@ -38,7 +38,7 @@ object NodeSeq { * @author Burak Emir * @version 1.0 */ -abstract class NodeSeq extends immutable.Sequence[Node] with SequenceLike[Node, NodeSeq] { +abstract class NodeSeq extends immutable.Seq[Node] with SeqLike[Node, NodeSeq] { import NodeSeq.seqToNodeSeq // import view magic for NodeSeq wrappers /** Creates a list buffer as builder for this class */ diff --git a/src/library/scala/xml/transform/BasicTransformer.scala b/src/library/scala/xml/transform/BasicTransformer.scala index f3a4d10a33..301f2e23a5 100644 --- a/src/library/scala/xml/transform/BasicTransformer.scala +++ b/src/library/scala/xml/transform/BasicTransformer.scala @@ -31,7 +31,7 @@ abstract class BasicTransformer extends Function1[Node,Node] * to NodeBuffer. */ def transform(it: Iterator[Node], nb: NodeBuffer): Seq[Node] = - it.foldLeft(nb)(_ ++= transform(_)).toSequence + it.foldLeft(nb)(_ ++= transform(_)).toSeq /** Call transform(Node) to each node in ns, yield ns if nothing changes, * otherwise a new sequence of concatenated results. diff --git a/src/swing/scala/swing/ListView.scala b/src/swing/scala/swing/ListView.scala index 9dbd14fcbe..49b69396fe 100644 --- a/src/swing/scala/swing/ListView.scala +++ b/src/swing/scala/swing/ListView.scala @@ -203,8 +203,8 @@ class ListView[A] extends Component { /** * The currently selected items. */ - object items extends scala.collection.SequenceProxy[A] { - def self = peer.getSelectedValues.toSequence.map(_.asInstanceOf[A]) + object items extends scala.collection.SeqProxy[A] { + def self = peer.getSelectedValues.toSeq.map(_.asInstanceOf[A]) def leadIndex: Int = peer.getSelectionModel.getLeadSelectionIndex def anchorIndex: Int = peer.getSelectionModel.getAnchorSelectionIndex } diff --git a/src/swing/scala/swing/Table.scala b/src/swing/scala/swing/Table.scala index 729d0c344c..d31325863d 100644 --- a/src/swing/scala/swing/Table.scala +++ b/src/swing/scala/swing/Table.scala @@ -199,7 +199,7 @@ class Table extends Component with Scrollable.Wrapper { } def cells: Set[(Int, Int)] = - new SelectionSet[(Int, Int)]((for(r <- selection.rows; c <- selection.columns) yield (r,c)).toSequence) { outer => + new SelectionSet[(Int, Int)]((for(r <- selection.rows; c <- selection.columns) yield (r,c)).toSeq) { outer => def -=(n: (Int, Int)) = { peer.removeRowSelectionInterval(n._1,n._1) peer.removeColumnSelectionInterval(n._2,n._2) 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 diff --git a/test/pending/neg/t1545.scala b/test/pending/neg/t1545.scala new file mode 100755 index 0000000000..d7c0245725 --- /dev/null +++ b/test/pending/neg/t1545.scala @@ -0,0 +1,16 @@ +object Main extends Application { + + case class Foo (field : Option[String]) + + val x : PartialFunction[Foo,Int] = + { + c => c.field match { + case Some (s) => 42 + case None => 99 + } + } + + println (x (Foo (None))) // prints 99 + println (x (Foo (Some ("foo")))) // prints 42 + +} diff --git a/test/pending/neg/t1800.scala b/test/pending/neg/t1800.scala new file mode 100644 index 0000000000..eebbbad9c7 --- /dev/null +++ b/test/pending/neg/t1800.scala @@ -0,0 +1,28 @@ +object ObjectHolder { + private[ObjectHolder] class PrivateObject + def getPrivateObject = new PrivateObject +} + +object Test { + def main(args: Array[String]) { + // compiler error: class PrivateObject cannot be accessed + // in object test.ObjectHolder + val a: ObjectHolder.PrivateObject = ObjectHolder.getPrivateObject + + // works fine + val b = ObjectHolder.getPrivateObject + println(b.getClass) + } +} +/* +When declaring objects as private[package/object] or protected[package/object] it is possible to leak out references to these objects into the public api (can be desirable, this in itself is not a problem). + +When users of the api receive such private object via a function call, they can create a variable to reference the private object using inferred typing: + +val b = getPrivateObject() + +However they cannot create such variable using declared typing: + +val a: PrivateObject? = getPrivateObject() + +The line above will generate a compiler error: "class PrivateObject? cannot be accessed". Which makes sense, because PrivateObject? was declared private. But in this case inferred typing should not work either, otherwise the behaviors of inferred typing and declared typing become inconsistent. */ diff --git a/test/pending/neg/t1845.scala b/test/pending/neg/t1845.scala new file mode 100644 index 0000000000..cfb28aa03c --- /dev/null +++ b/test/pending/neg/t1845.scala @@ -0,0 +1,12 @@ +// Compiling the attached code makes scalac give a NPE. + +import scala.util.parsing.combinator.syntactical.TokenParsers +import scala.util.parsing.combinator.lexical.StdLexical +import scala.util.parsing.syntax.StdTokens + +class MyTokenParsers extends TokenParsers { + import lexical._ + type Tokens = StdTokens + type Elem = lexical.Token + val lexical = new StdLexical +} diff --git a/test/pending/neg/t2080.scala b/test/pending/neg/t2080.scala new file mode 100644 index 0000000000..0880a40faa --- /dev/null +++ b/test/pending/neg/t2080.scala @@ -0,0 +1,17 @@ +trait A { + type T + def f(x : T) : T +} + +trait B extends A { + trait T { } + override def f(x : T) : T = x +} + +object C extends B { + override trait T { + def g { } + } + override def f(x : T) : T = { x.g; x } +} +//It compiles without errors, but T in B and T in C are completely unrelated types. diff --git a/test/pending/neg/t2180.scala b/test/pending/neg/t2180.scala new file mode 100644 index 0000000000..a8055bf77d --- /dev/null +++ b/test/pending/neg/t2180.scala @@ -0,0 +1,31 @@ + + +Given the following code (which is broken): + +class Mxml { + + private def processChildren( children:Seq[Any] ):List[Mxml] = { + + children.toList.flatMap ( e => { + + e match { + + case s:scala.collection.Traversable[_] => s case a => List(a) + + } + + }) + + } + +} + +I get the following error: + +Mxml.scala:5: error: could not find implicit value for parameter bf:scala.collection.generic.BuilderFactory[Any,List[Mxml],Sequence[Any]]. + + children.flatMap ( e => { + +I spent 4 hours failing before I figured out the problem. The return type was wrong. It should have been List[Any]. + +I have seen similar errors with map. My solution in the past has been to change it to a foldLeft because I have never been able to determine how to fix the problem until now. diff --git a/test/pending/pos/local-objects.scala b/test/pending/pos/local-objects.scala new file mode 100644 index 0000000000..ed7c50ead9 --- /dev/null +++ b/test/pending/pos/local-objects.scala @@ -0,0 +1,9 @@ + + +object Main { + val x = { + object Boo + Boo + } +} + diff --git a/test/pending/pos/t1722.scala b/test/pending/pos/t1722.scala new file mode 100644 index 0000000000..d059bf22f8 --- /dev/null +++ b/test/pending/pos/t1722.scala @@ -0,0 +1,10 @@ +sealed trait Top +trait C { + private object P extends Top +} +/* +$ scala -e 'new AnyRef with C' +error: error while loading Top, class file '/private/tmp/bobobo/./Top.class' is broken +(error reading Scala signature of /private/tmp/bobobo/./Top.class: malformed Scala signature of Top at 185; reference value P of trait C refers to nonexisting symbol.) +one error found +*/ diff --git a/test/pending/pos/t1722/C.scala b/test/pending/pos/t1722/C.scala new file mode 100755 index 0000000000..2695296292 --- /dev/null +++ b/test/pending/pos/t1722/C.scala @@ -0,0 +1,9 @@ +trait C { + private object P extends Top +} +/* +$ scala -e 'new AnyRef with C' +error: error while loading Top, class file '/private/tmp/bobobo/./Top.class' is broken +(error reading Scala signature of /private/tmp/bobobo/./Top.class: malformed Scala signature of Top at 185; reference value P of trait C refers to nonexisting symbol.) +one error found +*/ diff --git a/test/pending/pos/t1722/Test.scala b/test/pending/pos/t1722/Test.scala new file mode 100755 index 0000000000..4cba7ab01b --- /dev/null +++ b/test/pending/pos/t1722/Test.scala @@ -0,0 +1,4 @@ +package t1722 +object Test { + val x = new AnyRef with C +} diff --git a/test/pending/pos/t1722/Top.scala b/test/pending/pos/t1722/Top.scala new file mode 100755 index 0000000000..4ac52412aa --- /dev/null +++ b/test/pending/pos/t1722/Top.scala @@ -0,0 +1,13 @@ +package t1722 + +sealed trait Top +trait C { + private object P extends Top +} +/* +$ scala -e 'new AnyRef with C' +error: error while loading Top, class file '/private/tmp/bobobo/./Top.class' is broken +(error reading Scala signature of /private/tmp/bobobo/./Top.class: malformed Scala signature of Top at 185; reference value P of trait C refers to nonexisting symbol.) +one error found +Martin: I think this has to do with children property. +*/ diff --git a/test/pending/pos/t1756.scala b/test/pending/pos/t1756.scala new file mode 100644 index 0000000000..c22d5509e1 --- /dev/null +++ b/test/pending/pos/t1756.scala @@ -0,0 +1,30 @@ +trait Ring[T <: Ring[T]] { + def +(that: T): T + def *(that: T): T +} + +class A extends Ring[A] { + def +(that: A) = new A + def *(that: A) = new A +} + +class Poly[C <: Ring[C]](val c: C) extends Ring[Poly[C]] { + def +(that: Poly[C]) = new Poly(this.c+that.c) + def *(that: Poly[C]) = new Poly(this.c*that.c) +} + +implicit def coef2poly[C <: Ring[C]](c: C) = new Poly(c) + +val a = new A +val x = new Poly(new A) + +x+a // works +a+x // works + +val y = new Poly(new Poly(new A)) + +x+y*x // works +x*y+x // works +y*x+x // works + +x+x*y diff --git a/test/pending/pos/t1786.scala b/test/pending/pos/t1786.scala new file mode 100644 index 0000000000..86aaee0121 --- /dev/null +++ b/test/pending/pos/t1786.scala @@ -0,0 +1,13 @@ +class SomeClass(val intValue:Int) +class MyClass[T <: SomeClass](val myValue:T) + +def myMethod(i:MyClass[_]) { + i.myValue.intValue/2 // << error i is of type Any +} + +def myMethod(i:MyClass[_ <: SomeClass]) { + i.myValue.intValue/2 // << works +} +/* +The below code shows a compiler flaw in that the wildcard "_" as value for a bounded type parameter either breaks the boundry - as it result in Any - or doesnt (as id hoped it to be) evaluates to the boundy. +*/ diff --git a/test/pending/pos/t1798.scala b/test/pending/pos/t1798.scala new file mode 100644 index 0000000000..1624e3025e --- /dev/null +++ b/test/pending/pos/t1798.scala @@ -0,0 +1,10 @@ +object Foo { private def bar(): Int = 55 } +class Foo(x: Int) { def this() = this(Foo.bar()) } + +/* + * scalac28 a.scala +a.scala:2: error: method bar cannot be accessed in object Foo +class Foo(x: Int) { def this() = this(Foo.bar()) } + ^ +one error found +*/ diff --git a/test/pending/pos/t1987.scala b/test/pending/pos/t1987.scala new file mode 100644 index 0000000000..ccab133716 --- /dev/null +++ b/test/pending/pos/t1987.scala @@ -0,0 +1,8 @@ +package object overloading { + def bar(f: (Int) => Unit): Unit = () + def bar(f: (Int, Int) => Unit): Unit = () +} + +class PackageObjectOverloadingTest { + overloading.bar( (i: Int) => () ) // doesn't compile. +} diff --git a/test/pending/pos/t1996.scala b/test/pending/pos/t1996.scala new file mode 100644 index 0000000000..2730128196 --- /dev/null +++ b/test/pending/pos/t1996.scala @@ -0,0 +1,19 @@ +object forbug { + val l1 = List(List(ValDef(new A)), List(ValDef(new A))) + for ((e1s, e2s) <- l1.zip(l1); + (e1, e2) <- e1s.zip(e2s)) { + e1.a.doSome(20) +// () + } +} + + +class A { + def doSome(a: Int): this.type = { + println(a) + this + } +} + +case class ValDef(a: A) + diff --git a/test/pending/pos/t2071.scala b/test/pending/pos/t2071.scala new file mode 100644 index 0000000000..a96edb4cfb --- /dev/null +++ b/test/pending/pos/t2071.scala @@ -0,0 +1,14 @@ +trait Iterable[+S] +trait Box[U] + +trait A { + type T <: Iterable[S] forSome { type S <: Box[U]; type U } +} + +trait B extends A { + type T <: Iterable[S] forSome { type S <: Box[U]; type U } +} +But according to SLS, 3.5.1 Type Equivalence: Two existential types (§3.2.10) are equivalent if they have the same number of quantifiers, and, after renaming one list of type quantifiers by another, the quantified types as well as lower and upper bounds of corresponding quantifiers are equivalent. + +So, every existential type must be equivalent to (and conform to) itself. +Attachments diff --git a/test/pending/pos/t2081.scala b/test/pending/pos/t2081.scala new file mode 100644 index 0000000000..72ebd0557b --- /dev/null +++ b/test/pending/pos/t2081.scala @@ -0,0 +1,7 @@ +class RichInt(n: Int) { + def days = 1000*60*60*24*n +} + +implicit def RichInt(n: Int): RichInt = new RichInt(n) + +10.days diff --git a/test/pending/pos/t2099.scala b/test/pending/pos/t2099.scala new file mode 100644 index 0000000000..ddeee58a4b --- /dev/null +++ b/test/pending/pos/t2099.scala @@ -0,0 +1,27 @@ + + +I have a trait: + +trait Vis[+T] + +and an object/class pair: + +object VisImpl? { def apply() = new VisImpl? } class VisImpl? extends Vis[Missing] + +Where Missing is some class of mine. In a separate project (where Vis and VisImpl? are on the classpath but Missing is not), if I do: + +object Test extends Application { + + val v = VisImpl?() println(v) + +} + +This causes a Scala compiler error (using 2.7.5 compiler). The error is: + +"Caused by java.lang.RuntimeException?: malformed Scala signature of VisImpl? at 3634; reference value data of package mypack refers to nonexisting symbol" + +Where mypack is the root package of the Missing class. This is not a helpful error as all my classes share the same root package and the problem is not in the VisImpl? declaration in any case. + +I would expect to see an error of the form: + +" Type parameter not found 'Missing': VisImpl? extends Vis[Missing] at Test: #4: val v = VisImpl?() " diff --git a/test/pending/pos/t2108.scala b/test/pending/pos/t2108.scala new file mode 100644 index 0000000000..cd73b42627 --- /dev/null +++ b/test/pending/pos/t2108.scala @@ -0,0 +1,2 @@ +val a: Vector[_ <: Vector[Any]] = Array(Array("", 0)) +val x = a(0) // java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to scala.collection.mutable.Vector diff --git a/test/pending/pos/t2127.scala b/test/pending/pos/t2127.scala new file mode 100644 index 0000000000..a196a95c58 --- /dev/null +++ b/test/pending/pos/t2127.scala @@ -0,0 +1,29 @@ + + +As discussed here: http://www.nabble.com/Companion-object-constructor-visibility-td24342096.html + +//Simplified example: + + class Foo private (val value : Int) + + abstract class Bar(val ctor : (Int) => Foo) + + object Foo extends Bar(new Foo(_)) //<--- ILLEGAL ACCESS + +//however the following is legal: + + class Foo private (val value : Int) + + abstract class Bar{ + + var ctor : (Int) => Foo + + } + + object Foo extends Bar{ + + ctor = new Foo(_) //<--- Legal access + + } + +The constructor invocation of Bar is done within the scope of object Foo's constructor, and therefor the private constructor of Foo should be visible and accessible. diff --git a/test/pending/pos/t2130.scala b/test/pending/pos/t2130.scala new file mode 100644 index 0000000000..8e978b125b --- /dev/null +++ b/test/pending/pos/t2130.scala @@ -0,0 +1,44 @@ +Assertion failed while re-compiling a package object containing a case class +Reported by: rjm Owned by: odersky +Priority: normal Component: Compiler +Keywords: Cc: erik.engbrecht@… +Fixed in version: +Description + +While playing with the latest 2.8 snapshot (r18215-b20090706020217 to be precise) I noticed that a package object containing a case class gets an assertion failure when re-compiling (i.e., the class files already exist from a previous run, even a previous build of the exact same source). A minimal test case: + +package object foo { + + case class X() + +} + +And the error: + +Exception in thread "main" java.lang.AssertionError?: assertion failed: List(object package$X, object package$X) + + at scala.Predef$.assert(Predef.scala:97) at scala.tools.nsc.symtab.Symbols$Symbol.suchThat(Symbols.scala:988) at scala.tools.nsc.symtab.Symbols$Symbol.linkedModuleOfClass(Symbols.scala:1159) at scala.tools.nsc.backend.jvm.GenJVM$BytecodeGenerator?.genClass(GenJVM.scala:203) at scala.tools.nsc.backend.jvm.GenJVM$JvmPhase?$$anonfun$run$2.apply(GenJVM.scala:50) at scala.tools.nsc.backend.jvm.GenJVM$JvmPhase?$$anonfun$run$2.apply(GenJVM.scala:50) at scala.collection.Iterator$class.foreach(Iterator.scala:500) at scala.collection.generic.MapTemplate?$$anon$4.foreach(MapTemplate?.scala:156) at scala.tools.nsc.backend.jvm.GenJVM$JvmPhase?.run(GenJVM.scala:50) at scala.tools.nsc.Global$Run.compileSources(Global.scala:781) at scala.tools.nsc.Global$Run.compile(Global.scala:855) at scala.tools.nsc.Main$.process(Main.scala:75) at scala.tools.nsc.Main$.main(Main.scala:89) at scala.tools.nsc.Main.main(Main.scala) + +A normal class does not cause the failure; nor does a case object. +Attachments +Change History +Changed 4 weeks ago by eengbrec + + * cc erik.engbrecht@… added + +Changed 3 weeks ago by rompf + + * owner changed from scala_reviewer to scala_meeting + +Changed 3 weeks ago by rompf + + * owner changed from scala_meeting to odersky + +Add/Change #2130 (Assertion failed while re-compiling a package object containing a case class) +Comment (you may use WikiFormatting here): + +Change Properties +Summary: +Reporter: +Description: While playing with the latest 2.8 snapshot (r18215-b20090706020217 to be precise) I noticed that a package object containing a case class gets an assertion failure when re-compiling (i.e., the class files already exist from a previous run, even a previous build of the exact same source). A minimal test case: package object foo { case class X() } And the error: Exception in thread "main" java.lang.AssertionError: assertion failed: List(object package$X, object package$X) at scala.Predef$.assert(Predef.scala:97) at scala.tools.nsc.symtab.Symbols$Symbol.suchThat(Symbols.scala:988) at scala.tools.nsc.symtab.Symbols$Symbol.linkedModuleOfClass(Symbols.scala:1159) at scala.tools.nsc.backend.jvm.GenJVM$BytecodeGenerator.genClass(GenJVM.scala:203) at scala.tools.nsc.backend.jvm.GenJVM$JvmPhase$$anonfun$run$2.apply(GenJVM.scala:50) at scala.tools.nsc.backend.jvm.GenJVM$JvmPhase$$anonfun$run$2.apply(GenJVM.scala:50) at scala.collection.Iterator$class.foreach(Iterator.scala:500) at scala.collection.generic.MapTemplate$$anon$4.foreach(MapTemplate.scala:156) at scala.tools.nsc.backend.jvm.GenJVM$JvmPhase.run(GenJVM.scala:50) at scala.tools.nsc.Global$Run.compileSources(Global.scala:781) at scala.tools.nsc.Global$Run.compile(Global.scala:855) at scala.tools.nsc.Main$.process(Main.scala:75) at scala.tools.nsc.Main$.main(Main.scala:89) at scala.tools.nsc.Main.main(Main.scala) A normal class does not cause the failure; nor does a case object. +Type: diff --git a/test/pending/pos/t2162.scala b/test/pending/pos/t2162.scala new file mode 100644 index 0000000000..f90d48101d --- /dev/null +++ b/test/pending/pos/t2162.scala @@ -0,0 +1,19 @@ +class Foo(x: Int) +class Bar extends Foo(1) + +trait A { + def foo[T <: Foo] +} +class B extends A { + def foo[Bar] { println("B.foo[Bar]") } +} +object test { + val x = new B + val y = new A { + def foo[Bar] { println("A.foo[Bar]") } + } + def main(args: Array[String]) { + x.foo // ok + y.foo // java.lang.AssertionError: assertion failed (Erasure.scala:441 in r18338)) + } +} diff --git a/test/pending/pos/t2173.scala b/test/pending/pos/t2173.scala new file mode 100644 index 0000000000..9a9a2edce4 --- /dev/null +++ b/test/pending/pos/t2173.scala @@ -0,0 +1,17 @@ + + +This (somewhat convoluted) code fails to compile + +class A[+U>:Null] { + + type R[+X>:Null] = X type O[+X] = A[R[X]] + +} + +with the following error: + +type arguments [A.this.R[X]] do not conform to class A's type parameter bounds [+U >: Null] + +However, because type R[+X>:Null] is identical to X, it should carry X bounds and R[X] lower bound should be known to be X's lower bound, i.e. Null. + +The same problem occurs with upper bounds. diff --git a/test/pending/pos/t2178.scala b/test/pending/pos/t2178.scala new file mode 100644 index 0000000000..9ee3165a72 --- /dev/null +++ b/test/pending/pos/t2178.scala @@ -0,0 +1,10 @@ +scala> Array(Array(1)).last.last +java.lang.ClassCastException: [I + at .<init>(<console>:5) + at .<clinit>(<console>) + at RequestResult$.<init>(<console>:4) + at RequestResult$.<clinit>(<console>) + at RequestResult$result(<console>) + at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) + at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) + at sun.reflect.DelegatingMethodAccessorImpl... diff --git a/test/pending/pos/t2179.scala b/test/pending/pos/t2179.scala new file mode 100644 index 0000000000..fd37d8f760 --- /dev/null +++ b/test/pending/pos/t2179.scala @@ -0,0 +1,6 @@ +on trunk r18368, this delightful little poison pill: + +(Nil:List[List[Double]]).reduceLeft((_: Any, _: Any) => Nil.indices.map(_ => 0d)) + +sends the compiler into an apparently infinite loop. a sample thread dump shows: + diff --git a/test/pending/pos/t2185,.scala b/test/pending/pos/t2185,.scala new file mode 100644 index 0000000000..98e544e5ad --- /dev/null +++ b/test/pending/pos/t2185,.scala @@ -0,0 +1,3 @@ +scala> def foo { Nil.map(identity) } +<console>:4: error: could not find implicit value for parameter bf:scala.collection.generic.BuilderFactory[Nothing,Unit,List[Nothing]]. + def foo { Nil.map(identity) } diff --git a/test/pending/pos/t2188.scala b/test/pending/pos/t2188.scala new file mode 100644 index 0000000000..e9f6e4fb2c --- /dev/null +++ b/test/pending/pos/t2188.scala @@ -0,0 +1,9 @@ +scala> implicit def toJavaList[A](t:collection.Sequence[A]):java.util.List[A] = + | java.util.Arrays.asList(t.toArray:_*) +toJavaList: [A](t: Sequence[A])java.util.List[A] + +scala> val x: java.util.List[String] = List("foo") +<console>:7: error: type mismatch; + found : List[Any] + required: java.util.List[String] + val x: java.util.List[String] = List("foo") diff --git a/test/pending/pos/t2194.scala b/test/pending/pos/t2194.scala new file mode 100644 index 0000000000..6197ca0e90 --- /dev/null +++ b/test/pending/pos/t2194.scala @@ -0,0 +1,15 @@ +scala> class C +defined class C + +scala> def f = { object o extends C; o} +f: ewo.type forSome { val o: o; type o <: C with ScalaObject } + +scala> val x = f +<console>:6: error: type mismatch; + found : o.type(in object $iw) where type o.type(in object $iw) <: o with Singleton + required: o.type(in value x) forSome { type o.type(in value x) <: o with Singleton; type o <: C with ScalaObject } + val x = f + ^ + +scala> val x : C = f +x: C = o$2$@111985e diff --git a/test/pending/pos/t2201.scala b/test/pending/pos/t2201.scala new file mode 100644 index 0000000000..21af170cf1 --- /dev/null +++ b/test/pending/pos/t2201.scala @@ -0,0 +1,8 @@ +class Test +object Test { implicit def view(x : Test) = 0 } + +object Call { + def call(implicit view : Test => Int) = view(null) + call + call +} diff --git a/test/pending/pos/ticket2251.scala b/test/pending/pos/ticket2251.scala new file mode 100644 index 0000000000..7b6efb0ea0 --- /dev/null +++ b/test/pending/pos/ticket2251.scala @@ -0,0 +1,25 @@ + +// Martin: I am not sure this is a solvable problem right now. I'll leave it in pending. +// derived from pos/bug1001 +class A +trait B[T <: B[T]] extends A +class C extends B[C] +class D extends B[D] + +class Data { + // force computing lub of C and D (printLubs enabled:) + +/* +lub of List(D, C) at depth 2 + lub of List(D, C) at depth 1 + lub of List(D, C) at depth 0 + lub of List(D, C) is A + lub of List(D, C) is B[_1] forSome { type _1 >: D with C <: A } +lub of List(D, C) is B[_2] forSome { type _2 >: D with C{} <: B[_1] forSome { type _1 >: D with C{} <: A } } +*/ +// --> result = WRONG + + // should be: B[X] forSome {type X <: B[X]} -- can this be done automatically? for now, just detect f-bounded polymorphism and fall back to more coarse approximation + + val data: List[A] = List(new C, new D) +} diff --git a/test/pending/run/t1939.scala b/test/pending/run/t1939.scala new file mode 100644 index 0000000000..4860ca8169 --- /dev/null +++ b/test/pending/run/t1939.scala @@ -0,0 +1,42 @@ + + +class Module {} + +abstract class T { + type moduleType <: Module + def module: moduleType +} + +final class T1(val module: Module) extends T { + type moduleType = Module +} + +final class T2(_module: Module) extends T { + type moduleType = Module + + def module = _module +} + +object Main extends Application { + + type mType = Module + + type tType = T { type moduleType <: mType } + // type tType = T { type moduleType <: Module } // runs successfully + // type tType = T // runs successfully + + def f(ts: List[tType]): Unit = { + + for (t <- ts; m = t.module) {} + ts.map(_.module).foreach { _ => () } + // ts.map(t => (t : T).module).foreach { _ => () } // runs successfully + } + + f(new T1(new Module) :: new T2(new Module) :: Nil) +} + +/* + * java.lang.AbstractMethodError + at scala.List.foreach(List.scala:849) + at Main$.f +*/ diff --git a/test/pending/run/t1980.scala b/test/pending/run/t1980.scala new file mode 100644 index 0000000000..7c5737f95e --- /dev/null +++ b/test/pending/run/t1980.scala @@ -0,0 +1,13 @@ +scala> def foo() = { println("foo") ; 5 } +foo: ()Int + +scala> class C { def m1(f: => Int) = () ; def m2_:(f: => Int) = () } +defined class C + +scala> val c = new C +c: C = C@96d484 + +scala> c m1 foo() + +scala> foo() m2_: c +foo diff --git a/test/pending/run/t2005.scala b/test/pending/run/t2005.scala new file mode 100644 index 0000000000..8e4243a768 --- /dev/null +++ b/test/pending/run/t2005.scala @@ -0,0 +1,24 @@ +Object Bug { + def main(args: Array[String]) { + val a = new Array[Array[Int]](2,2) + test(a) + } + def test[A](t: Array[Array[A]]) { + val tmp = t(0) + t(1) = tmp + } +} +java.lang.ArrayStoreException: scala.runtime.BoxedIntArray + at scala.runtime.BoxedObjectArray.update(BoxedObjectArray.scala:26) + at Bug$.test(Bug.scala:12) + at Bug$.main(Bug.scala:7) + at Bug.main(Bug.scala) + at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) + at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) + at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) + at java.lang.reflect.Method.invoke(Method.java:585) + at scala.tools.nsc.ObjectRunner$$anonfun$run$1.apply(ObjectRunner.scala:75) + at scala.tools.nsc.ObjectRunner$.withContextClassLoader(ObjectRunner.scala:49) + at scala.tools.nsc.ObjectRunner$.run(ObjectRunner.scala:74) + at scala.tools.nsc.MainGenericRunner$.main(MainGenericRunner.scala:154) + at scala.tools.nsc.MainGenericRunner.main(MainGenericRunner.scala) |