16 files changed, 150 insertions, 23 deletions
diff --git a/src/library/scala/collection/Map.scala b/src/library/scala/collection/Map.scala
index a124e60c96..42a56a9c5a 100644
--- a/src/library/scala/collection/Map.scala
+++ b/src/library/scala/collection/Map.scala
@@ -45,7 +45,7 @@ object Map extends MapFactory[Map] {
   /** An abstract shell used by { mutable, immutable }.Map but not by collection.Map
    *  because of variance issues.
    */
-  abstract class WithDefault[A, +B](underlying: Map[A, B], d: A => B) extends AbstractMap[A, B] with Map[A, B] {
+  abstract class WithDefault[A, +B](underlying: Map[A, B], d: A => B) extends AbstractMap[A, B] with Map[A, B] with Serializable {
     override def size               = underlying.size
     def get(key: A)                 = underlying.get(key) // removed in 2.9: orElse Some(default(key))
     def iterator                    = underlying.iterator
diff --git a/src/library/scala/collection/MapLike.scala b/src/library/scala/collection/MapLike.scala
index 034c1a0c0c..b2b687e75a 100644
--- a/src/library/scala/collection/MapLike.scala
+++ b/src/library/scala/collection/MapLike.scala
@@ -165,7 +165,7 @@ self =>
 
   /** The implementation class of the set returned by `keySet`.
    */
-  protected class DefaultKeySet extends AbstractSet[A] with Set[A] {
+  protected class DefaultKeySet extends AbstractSet[A] with Set[A] with Serializable {
     def contains(key : A) = self.contains(key)
     def iterator = keysIterator
     def + (elem: A): Set[A] = (Set[A]() ++ this + elem).asInstanceOf[Set[A]] // !!! concrete overrides abstract problem
@@ -200,7 +200,7 @@ self =>
 
   /** The implementation class of the iterable returned by `values`.
    */
-  protected class DefaultValuesIterable extends AbstractIterable[B] with Iterable[B] {
+  protected class DefaultValuesIterable extends AbstractIterable[B] with Iterable[B] with Serializable {
     def iterator = valuesIterator
     override def size = self.size
     override def foreach[C](f: B => C) = self.valuesIterator foreach f
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/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/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/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/pending/run/t5018.scala b/test/files/run/t5018.scala
index 30c0d5ac94..bb67a252e5 100644
--- a/test/pending/run/t5018.scala
+++ b/test/files/run/t5018.scala
@@ -18,7 +18,7 @@ object Test {
   
   def main(args: Array[String]) {
     val values = mutable.Map(1 -> 1).values
-    assert(serializeDeserialize(values) == values)
+    assert(serializeDeserialize(values).toList == values.toList)
     
     val keyset = mutable.Map(1 -> 1).keySet
     assert(serializeDeserialize(keyset) == keyset)
@@ -28,6 +28,9 @@ object Test {
     
     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)
   }
   
 }
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/pending/run/t5514.scala b/test/files/run/t5514.scala
index eacad21cd8..efd5ba6cb9 100644
--- a/test/pending/run/t5514.scala
+++ b/test/files/run/t5514.scala
@@ -8,28 +8,28 @@ 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 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("reader: " + n)
+  println("constructed reader: " + n)
 }
 
 
-class DemoParsers extends Parsers {
+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/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)
+  }
+  
+}
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)
+  }
+  
+}
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, "_"))
+  }
+  
+}