From 628eaa5aca0117823327571a1384f0d717fd7b4e Mon Sep 17 00:00:00 2001 From: Aleksandar Prokopec Date: Fri, 4 May 2012 10:46:29 +0200 Subject: Fix for si-5018. Methods keySet, values and withDefault now return serializable collections. --- test/files/run/t5018.scala | 37 +++++++++++++++++++++++++++++++++++++ 1 file changed, 37 insertions(+) create mode 100644 test/files/run/t5018.scala (limited to 'test/files/run') diff --git a/test/files/run/t5018.scala b/test/files/run/t5018.scala new file mode 100644 index 0000000000..bb67a252e5 --- /dev/null +++ b/test/files/run/t5018.scala @@ -0,0 +1,37 @@ + + + +import java.io._ +import collection._ + + + +object Test { + + def serializeDeserialize[T <: AnyRef](obj: T) = { + val buffer = new ByteArrayOutputStream + val out = new ObjectOutputStream(buffer) + out.writeObject(obj) + val in = new ObjectInputStream(new ByteArrayInputStream(buffer.toByteArray)) + in.readObject.asInstanceOf[T] + } + + def main(args: Array[String]) { + val values = mutable.Map(1 -> 1).values + assert(serializeDeserialize(values).toList == values.toList) + + val keyset = mutable.Map(1 -> 1).keySet + assert(serializeDeserialize(keyset) == keyset) + + val imkeyset = immutable.Map(1 -> 1).keySet + assert(serializeDeserialize(imkeyset) == imkeyset) + + val defaultmap = immutable.Map(1 -> 1).withDefaultValue(1) + assert(serializeDeserialize(defaultmap) == defaultmap) + + val minusmap = mutable.Map(1 -> 1).withDefault(x => -x) + assert(serializeDeserialize(minusmap) == minusmap) + } + +} + -- cgit v1.2.3 From b2c3f87c7b1b613495eb563d909f24e1e22369d1 Mon Sep 17 00:00:00 2001 From: Aleksandar Prokopec Date: Fri, 4 May 2012 13:47:05 +0200 Subject: Fix for si-5590. --- .../scala/collection/mutable/HashTable.scala | 2 +- .../scala/collection/mutable/LinkedHashMap.scala | 8 ++++++ test/files/run/t5590.check | 4 +++ test/files/run/t5590.scala | 31 ++++++++++++++++++++++ 4 files changed, 44 insertions(+), 1 deletion(-) create mode 100644 test/files/run/t5590.check create mode 100644 test/files/run/t5590.scala (limited to 'test/files/run') diff --git a/src/library/scala/collection/mutable/HashTable.scala b/src/library/scala/collection/mutable/HashTable.scala index 06b7d40bfc..a2f78dbde9 100644 --- a/src/library/scala/collection/mutable/HashTable.scala +++ b/src/library/scala/collection/mutable/HashTable.scala @@ -187,7 +187,7 @@ trait HashTable[A, Entry >: Null <: HashEntry[A, Entry]] extends HashTable.HashU } /** Avoid iterator for a 2x faster traversal. */ - protected final def foreachEntry[C](f: Entry => C) { + protected def foreachEntry[C](f: Entry => C) { val iterTable = table var idx = lastPopulatedIndex var es = iterTable(idx) diff --git a/src/library/scala/collection/mutable/LinkedHashMap.scala b/src/library/scala/collection/mutable/LinkedHashMap.scala index cd174523b1..4150cf9eba 100644 --- a/src/library/scala/collection/mutable/LinkedHashMap.scala +++ b/src/library/scala/collection/mutable/LinkedHashMap.scala @@ -132,6 +132,14 @@ class LinkedHashMap[A, B] extends AbstractMap[A, B] } } + protected override def foreachEntry[C](f: Entry => C) { + var cur = firstEntry + while (cur ne null) { + f(cur) + cur = cur.later + } + } + override def clear() { clearTable() firstEntry = null diff --git a/test/files/run/t5590.check b/test/files/run/t5590.check new file mode 100644 index 0000000000..ad4a2eee64 --- /dev/null +++ b/test/files/run/t5590.check @@ -0,0 +1,4 @@ +Map(a -> a, b -> b, c -> c) +Map(a -> a, b -> b, c -> c) +Set(a, b, c, d, e) +Set(a, b, c, d, e) \ No newline at end of file diff --git a/test/files/run/t5590.scala b/test/files/run/t5590.scala new file mode 100644 index 0000000000..9c806e0b7d --- /dev/null +++ b/test/files/run/t5590.scala @@ -0,0 +1,31 @@ + + + +import java.io._ +import collection._ + + + +object Test { + + def check(obj: AnyRef) { + println(obj) + + val bos = new ByteArrayOutputStream() + val out = new ObjectOutputStream(bos) + out.writeObject(obj) + val arr = bos.toByteArray() + val in = new ObjectInputStream(new ByteArrayInputStream(arr)) + val deser = in.readObject() + + println(deser) + } + + def main(args: Array[String]) { + val lhm = mutable.LinkedHashMap("a" -> "a", "b" -> "b", "c" -> "c") + val lhs = mutable.LinkedHashSet("a", "b", "c", "d", "e") + check(lhm) + check(lhs) + } + +} -- cgit v1.2.3 From 5ebbfdb144ab58a63cfb34266a1b45bb8468f80a Mon Sep 17 00:00:00 2001 From: Aleksandar Prokopec Date: Fri, 4 May 2012 14:11:56 +0200 Subject: Fix for si-5577. --- src/library/scala/collection/mutable/Builder.scala | 2 ++ test/files/run/t5577.check | 11 +++++++++ test/files/run/t5577.scala | 27 ++++++++++++++++++++++ 3 files changed, 40 insertions(+) create mode 100644 test/files/run/t5577.check create mode 100644 test/files/run/t5577.scala (limited to 'test/files/run') diff --git a/src/library/scala/collection/mutable/Builder.scala b/src/library/scala/collection/mutable/Builder.scala index 44cc1c8582..bbf4f5889d 100644 --- a/src/library/scala/collection/mutable/Builder.scala +++ b/src/library/scala/collection/mutable/Builder.scala @@ -100,6 +100,8 @@ trait Builder[-Elem, +To] extends Growable[Elem] { def +=(x: Elem): this.type = { self += x; this } def clear() = self.clear() override def ++=(xs: TraversableOnce[Elem]): this.type = { self ++= xs; this } + override def sizeHint(size: Int) = self.sizeHint(size) + override def sizeHintBounded(size: Int, boundColl: TraversableLike[_, _]) = self.sizeHintBounded(size, boundColl) def result: NewTo = f(self.result) } } diff --git a/test/files/run/t5577.check b/test/files/run/t5577.check new file mode 100644 index 0000000000..3eca387955 --- /dev/null +++ b/test/files/run/t5577.check @@ -0,0 +1,11 @@ +Received a size hint: 10 +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 \ No newline at end of file diff --git a/test/files/run/t5577.scala b/test/files/run/t5577.scala new file mode 100644 index 0000000000..b5d6d8c5b6 --- /dev/null +++ b/test/files/run/t5577.scala @@ -0,0 +1,27 @@ + + + +import collection._ + + + +object Test { + + class AlarmingBuffer[T] extends mutable.ArrayBuffer[T] { + override def sizeHint(x: Int) { + println("Received a size hint: " + x) + super.sizeHint(x) + } + } + + def main(args: Array[String]) { + val iteratorBuilder = (new AlarmingBuffer[Int]) mapResult { + res => res.iterator + } + + iteratorBuilder.sizeHint(10) + iteratorBuilder ++= (0 until 10) + iteratorBuilder.result.foreach(println) + } + +} -- cgit v1.2.3 From bbd6a3d6da09a6f8caf082a25b27be74bf59c124 Mon Sep 17 00:00:00 2001 From: Aleksandar Prokopec Date: Fri, 4 May 2012 15:18:03 +0200 Subject: Fixes si-5656. --- src/library/scala/collection/TraversableViewLike.scala | 18 +++++++++++++----- test/files/run/t5656.check | 1 + test/files/run/t5656.scala | 11 +++++++++++ 3 files changed, 25 insertions(+), 5 deletions(-) create mode 100644 test/files/run/t5656.check create mode 100644 test/files/run/t5656.scala (limited to 'test/files/run') diff --git a/src/library/scala/collection/TraversableViewLike.scala b/src/library/scala/collection/TraversableViewLike.scala index ad5e3d3240..5ca038fd2e 100644 --- a/src/library/scala/collection/TraversableViewLike.scala +++ b/src/library/scala/collection/TraversableViewLike.scala @@ -28,8 +28,16 @@ trait ViewMkString[+A] { override def mkString(start: String, sep: String, end: String): String = { thisSeq.addString(new StringBuilder(), start, sep, end).toString } - override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = - b append start append "..." append end + override def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = { + var first = true + b append start + for (x <- self) { + if (first) first = false else b append sep + b append x + } + b append end + b + } } /** A template trait for non-strict views of traversable collections. @@ -41,17 +49,17 @@ trait ViewMkString[+A] { * that takes a `View` as its `From` type parameter must yield the same view (or a generic * superclass of it) as its result parameter. If that assumption is broken, cast errors might result. * - * @define viewInfo + * @define viewInfo * A view is a lazy version of some collection. Collection transformers such as * `map` or `filter` or `++` do not traverse any elements when applied on a view. * Instead they create a new view which simply records that fact that the operation * needs to be applied. The collection elements are accessed, and the view operations are applied, * when a non-view result is needed, or when the `force` method is called on a view. - * @define traversableViewInfo + * @define traversableViewInfo * $viewInfo * * All views for traversable collections are defined by creating a new `foreach` method. - + * * @author Martin Odersky * @version 2.8 * @since 2.8 diff --git a/test/files/run/t5656.check b/test/files/run/t5656.check new file mode 100644 index 0000000000..9543ee799e --- /dev/null +++ b/test/files/run/t5656.check @@ -0,0 +1 @@ +List(1, 2, 3)_List(a, b, c) \ No newline at end of file diff --git a/test/files/run/t5656.scala b/test/files/run/t5656.scala new file mode 100644 index 0000000000..f5ea147a4e --- /dev/null +++ b/test/files/run/t5656.scala @@ -0,0 +1,11 @@ + + + + +object Test { + + def main(args: Array[String]) { + println(Seq(List('1', '2', '3'), List('a', 'b', 'c')).view.addString(new StringBuilder, "_")) + } + +} -- cgit v1.2.3 From 37c157c91f9240b562faa437dbda18bcb435e0ee Mon Sep 17 00:00:00 2001 From: Aleksandar Prokopec Date: Fri, 4 May 2012 17:50:39 +0200 Subject: Fixes SI-5514. The acceptIf and acceptMatch parsers now check for end of input. Review by moors. --- .../scala/util/parsing/combinator/Parsers.scala | 6 ++-- test/files/run/t5514.check | 19 ++++++++++++ test/files/run/t5514.scala | 35 ++++++++++++++++++++++ test/pending/run/t5514.scala | 35 ---------------------- 4 files changed, 58 insertions(+), 37 deletions(-) create mode 100644 test/files/run/t5514.check create mode 100644 test/files/run/t5514.scala delete mode 100644 test/pending/run/t5514.scala (limited to 'test/files/run') diff --git a/src/library/scala/util/parsing/combinator/Parsers.scala b/src/library/scala/util/parsing/combinator/Parsers.scala index e5458f89af..17e032e7ab 100644 --- a/src/library/scala/util/parsing/combinator/Parsers.scala +++ b/src/library/scala/util/parsing/combinator/Parsers.scala @@ -596,7 +596,8 @@ trait Parsers { * @return A parser for elements satisfying p(e). */ def acceptIf(p: Elem => Boolean)(err: Elem => String): Parser[Elem] = Parser { in => - if (p(in.first)) Success(in.first, in.rest) + if (in.atEnd) Failure("end of input", in) + else if (p(in.first)) Success(in.first, in.rest) else Failure(err(in.first), in) } @@ -614,7 +615,8 @@ trait Parsers { * applying `f` to it to produce the result. */ def acceptMatch[U](expected: String, f: PartialFunction[Elem, U]): Parser[U] = Parser{ in => - if (f.isDefinedAt(in.first)) Success(f(in.first), in.rest) + if (in.atEnd) Failure("end of input", in) + else if (f.isDefinedAt(in.first)) Success(f(in.first), in.rest) else Failure(expected+" expected", in) } diff --git a/test/files/run/t5514.check b/test/files/run/t5514.check new file mode 100644 index 0000000000..c68f7c9029 --- /dev/null +++ b/test/files/run/t5514.check @@ -0,0 +1,19 @@ +constructed reader: 10 +constructed reader: 9 +constructed reader: 8 +constructed reader: 7 +constructed reader: 6 +constructed reader: 5 +constructed reader: 4 +constructed reader: 3 +constructed reader: 2 +constructed reader: 1 +constructed reader: 0 +[0.0] parsed: List(s10, s9, s8, s7, s6, s5, s4, s3, s2, s1) +constructed reader: 10 +constructed reader: 9 +constructed reader: 8 +constructed reader: 7 +constructed reader: 6 +constructed reader: 5 +[0.0] parsed: List(s10, s9, s8, s7, s6) \ No newline at end of file diff --git a/test/files/run/t5514.scala b/test/files/run/t5514.scala new file mode 100644 index 0000000000..efd5ba6cb9 --- /dev/null +++ b/test/files/run/t5514.scala @@ -0,0 +1,35 @@ + + + +import scala.io.Source +import scala.util.parsing.combinator.Parsers +import scala.util.parsing.input.Reader +import scala.util.parsing.input.Position + + + +class DemoReader(n: Int) extends Reader[String] { + def atEnd = n == 0 + def first = if (n >= 0) "s" + n else throw new IllegalArgumentException("No more input.") + def rest = new DemoReader(n - 1) + def pos = new Position { + def line = 0 + def column = 0 + def lineContents = first + } + println("constructed reader: " + n) +} + + +object Test extends App with Parsers { + type Elem = String + def startsWith(prefix: String) = acceptIf(_ startsWith prefix)("Error: " + _) + + val resrep = startsWith("s").*(new DemoReader(10)) + Console println resrep + + val resrep5 = repN(5, startsWith("s"))(new DemoReader(10)) + Console println resrep5 +} + + diff --git a/test/pending/run/t5514.scala b/test/pending/run/t5514.scala deleted file mode 100644 index eacad21cd8..0000000000 --- a/test/pending/run/t5514.scala +++ /dev/null @@ -1,35 +0,0 @@ - - - -import scala.io.Source -import scala.util.parsing.combinator.Parsers -import scala.util.parsing.input.Reader -import scala.util.parsing.input.Position - - - -object DemoApp extends App { - val parsers = new DemoParsers - val reader = new DemoReader(10) - val result = parsers.startsWith("s").*(reader) - Console println result -} - - -class DemoReader(n: Int) extends Reader[String] { - def atEnd = n == 0 - def first = "s" + n - def rest = new DemoReader(n - 1) - def pos = new Position { - def line = 0 - def column = 0 - def lineContents = first - } - println("reader: " + n) -} - - -class DemoParsers extends Parsers { - type Elem = String - def startsWith(prefix: String) = acceptIf(_ startsWith prefix)("Error: " + _) -} -- cgit v1.2.3