Third collections commit from Todd Vierling.

Misc cleanups associated with the previous commits: limiting overly
expanded types, fixing externally visible types for scaladoc, utilizing
abstract collection classes where possible, etc.

15 files changed, 47 insertions, 35 deletions

diff --git a/src/dbc/scala/dbc/result/Relation.scala b/src/dbc/scala/dbc/result/Relation.scala
index 4897cd1030..98d653d61e 100644
--- a/src/dbc/scala/dbc/result/Relation.scala
+++ b/src/dbc/scala/dbc/result/Relation.scala
@@ -14,7 +14,9 @@ package result
 
 /** An ISO-9075:2003 (SQL) table. This is equivalent to a relation in the
  * relational model. */
-@deprecated(DbcIsDeprecated, "2.9.0") abstract class Relation extends AnyRef with Iterable[Tuple] {
+@deprecated(DbcIsDeprecated, "2.9.0") abstract class Relation
+extends collection.AbstractIterable[Tuple]
+   with Iterable[Tuple] {
 
   /** The statement that generated this relation. */
   def statement: scala.dbc.statement.Relation
@@ -56,7 +58,7 @@ package result
    * <h3>Caution</h3> A Relation only has one single iterator, due to limitations
    * in DBMS. This means that if this method is called multiple times, all returned
    * iterators will share the same state. */
-  def iterator: Iterator[Tuple] = new Iterator[Tuple] {
+  def iterator: Iterator[Tuple] = new collection.AbstractIterator[Tuple] {
     protected val result: java.sql.ResultSet = Relation.this.sqlResult
     def hasNext: Boolean = resultNext
     private var resultNext = result.next()
diff --git a/src/library/scala/collection/Iterable.scala b/src/library/scala/collection/Iterable.scala
index 50558d5a9f..b1752a5c67 100644
--- a/src/library/scala/collection/Iterable.scala
+++ b/src/library/scala/collection/Iterable.scala
@@ -51,4 +51,4 @@ object Iterable extends TraversableFactory[Iterable] {
 }
 
 /** Explicit instantiation of the `Iterable` trait to reduce class file size in subclasses. */
-private[scala] abstract class AbstractIterable[+T] extends AbstractTraversable[T] with Iterable[T]
+private[scala] abstract class AbstractIterable[+A] extends AbstractTraversable[A] with Iterable[A]
diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala
index b56a83043d..7b780ba2e4 100644
--- a/src/library/scala/collection/Iterator.scala
+++ b/src/library/scala/collection/Iterator.scala
@@ -822,7 +822,10 @@ trait Iterator[+A] extends TraversableOnce[A] {
    *
    *  Typical uses can be achieved via methods `grouped` and `sliding`.
    */
-  class GroupedIterator[B >: A](self: Iterator[A], size: Int, step: Int) extends AbstractIterator[Seq[B]] {
+  class GroupedIterator[B >: A](self: Iterator[A], size: Int, step: Int)
+  extends AbstractIterator[Seq[B]]
+     with Iterator[Seq[B]] {
+
     require(size >= 1 && step >= 1, "size=%d and step=%d, but both must be positive".format(size, step))
 
     private[this] var buffer: ArrayBuffer[B] = ArrayBuffer()  // the buffer
@@ -1109,4 +1112,4 @@ trait Iterator[+A] extends TraversableOnce[A] {
 }
 
 /** Explicit instantiation of the `Iterator` trait to reduce class file size in subclasses. */
-private[scala] abstract class AbstractIterator[+T] extends Iterator[T]
+private[scala] abstract class AbstractIterator[+A] extends Iterator[A]
diff --git a/src/library/scala/collection/JavaConversions.scala b/src/library/scala/collection/JavaConversions.scala
index d911a16d02..d5011fc6aa 100644
--- a/src/library/scala/collection/JavaConversions.scala
+++ b/src/library/scala/collection/JavaConversions.scala
@@ -761,10 +761,7 @@ object JavaConversions {
   }
 
   case class JMapWrapper[A, B](val underlying : ju.Map[A, B])
-  extends mutable.AbstractMap[A, B]
-     with mutable.Map[A, B]
-     with JMapWrapperLike[A, B, JMapWrapper[A, B]] {
-
+  extends mutable.AbstractMap[A, B] with JMapWrapperLike[A, B, JMapWrapper[A, B]] {
     override def empty = JMapWrapper(new ju.HashMap[A, B])
   }
 
@@ -792,11 +789,7 @@ object JavaConversions {
   }
 
   case class JConcurrentMapWrapper[A, B](val underlying: juc.ConcurrentMap[A, B])
-  extends mutable.AbstractMap[A, B]
-     with mutable.Map[A, B]
-     with JMapWrapperLike[A, B, JConcurrentMapWrapper[A, B]]
-     with mutable.ConcurrentMap[A, B] {
-
+  extends mutable.AbstractMap[A, B] with JMapWrapperLike[A, B, JConcurrentMapWrapper[A, B]] with mutable.ConcurrentMap[A, B] {
     override def get(k: A) = {
       val v = underlying get k
       if (v != null) Some(v)
@@ -850,9 +843,7 @@ object JavaConversions {
   }
 
   case class JDictionaryWrapper[A, B](underlying: ju.Dictionary[A, B])
-  extends mutable.AbstractMap[A, B]
-     with mutable.Map[A, B] {
-
+  extends mutable.AbstractMap[A, B] with mutable.Map[A, B] {
     override def size: Int = underlying.size
 
     def get(k: A) = {
diff --git a/src/library/scala/collection/MapLike.scala b/src/library/scala/collection/MapLike.scala
index 3485fe1be6..1653a011d6 100644
--- a/src/library/scala/collection/MapLike.scala
+++ b/src/library/scala/collection/MapLike.scala
@@ -159,7 +159,7 @@ self =>
 
   /** The implementation class of the set returned by `keySet`.
    */
-  protected class DefaultKeySet extends AbstractSet[A] {
+  protected class DefaultKeySet extends AbstractSet[A] with Set[A] {
     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
@@ -194,7 +194,7 @@ self =>
 
   /** The implementation class of the iterable returned by `values`.
    */
-  protected class DefaultValuesIterable extends AbstractIterable[B] {
+  protected class DefaultValuesIterable extends AbstractIterable[B] with Iterable[B] {
     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/Seq.scala b/src/library/scala/collection/Seq.scala
index 3be3ca0204..cb3fe5ca71 100644
--- a/src/library/scala/collection/Seq.scala
+++ b/src/library/scala/collection/Seq.scala
@@ -42,4 +42,4 @@ object Seq extends SeqFactory[Seq] {
 }
 
 /** Explicit instantiation of the `Seq` trait to reduce class file size in subclasses. */
-private[scala] abstract class AbstractSeq[+T] extends AbstractIterable[T] with Seq[T]
+private[scala] abstract class AbstractSeq[+A] extends AbstractIterable[A] with Seq[A]
diff --git a/src/library/scala/collection/Traversable.scala b/src/library/scala/collection/Traversable.scala
index 014586b3af..3fba3dfa79 100644
--- a/src/library/scala/collection/Traversable.scala
+++ b/src/library/scala/collection/Traversable.scala
@@ -109,4 +109,4 @@ object Traversable extends TraversableFactory[Traversable] { self =>
 }
 
 /** Explicit instantiation of the `Traversable` trait to reduce class file size in subclasses. */
-private[scala] abstract class AbstractTraversable[+T] extends Traversable[T]
+private[scala] abstract class AbstractTraversable[+A] extends Traversable[A]
diff --git a/src/library/scala/collection/immutable/ListMap.scala b/src/library/scala/collection/immutable/ListMap.scala
index 3b7da3259e..b2b933c51a 100644
--- a/src/library/scala/collection/immutable/ListMap.scala
+++ b/src/library/scala/collection/immutable/ListMap.scala
@@ -49,7 +49,7 @@ class ListMap[A, +B]
 extends AbstractMap[A, B]
    with Map[A, B]
    with MapLike[A, B, ListMap[A, B]]
-  with Serializable {
+   with Serializable {
 
   override def empty = ListMap.empty
 
diff --git a/src/library/scala/collection/mutable/History.scala b/src/library/scala/collection/mutable/History.scala
index 0c3b762bd9..c1d94a904c 100644
--- a/src/library/scala/collection/mutable/History.scala
+++ b/src/library/scala/collection/mutable/History.scala
@@ -25,7 +25,11 @@ package mutable
  *  @tparam Pub   Type of publishers.
  */
 @SerialVersionUID(5219213543849892588L)
-class History[Evt, Pub] extends AbstractIterable[(Pub, Evt)] with Subscriber[Evt, Pub] with Serializable
+class History[Evt, Pub]
+extends AbstractIterable[(Pub, Evt)]
+   with Subscriber[Evt, Pub]
+   with Iterable[(Pub, Evt)]
+   with Serializable
 {
   protected val log: Queue[(Pub, Evt)] = new Queue
   val maxHistory: Int = 1000
diff --git a/src/library/scala/io/Source.scala b/src/library/scala/io/Source.scala
index e7bcc32558..3cee0ace79 100644
--- a/src/library/scala/io/Source.scala
+++ b/src/library/scala/io/Source.scala
@@ -190,7 +190,7 @@ abstract class Source extends Iterator[Char] {
 
   private def lineNum(line: Int): String = getLines() drop (line - 1) take 1 mkString
 
-  class LineIterator() extends AbstractIterator[String] {
+  class LineIterator extends AbstractIterator[String] with Iterator[String] {
     private[this] val sb = new StringBuilder
 
     lazy val iter: BufferedIterator[Char] = Source.this.iter.buffered
diff --git a/src/library/scala/sys/SystemProperties.scala b/src/library/scala/sys/SystemProperties.scala
index 25fd6e53a8..52e0ac230b 100644
--- a/src/library/scala/sys/SystemProperties.scala
+++ b/src/library/scala/sys/SystemProperties.scala
@@ -23,7 +23,10 @@ import java.security.AccessControlException
  *  @version 2.9
  *  @since   2.9
  */
-class SystemProperties extends mutable.Map[String, String] {
+class SystemProperties
+extends mutable.AbstractMap[String, String]
+   with mutable.Map[String, String] {
+
   override def empty = new SystemProperties
   override def default(key: String): String = null
 
diff --git a/src/library/scala/util/parsing/ast/Binders.scala b/src/library/scala/util/parsing/ast/Binders.scala
index 8019306524..0646f57064 100644
--- a/src/library/scala/util/parsing/ast/Binders.scala
+++ b/src/library/scala/util/parsing/ast/Binders.scala
@@ -8,6 +8,7 @@
 
 package scala.util.parsing.ast
 
+import scala.collection.AbstractIterable
 import scala.collection.mutable
 
 //DISCLAIMER: this code is highly experimental!
@@ -83,7 +84,7 @@ trait Binders extends AbstractSyntax with Mappable {
    *  For example: `[x, y]!1` represents the scope with `id` `1` and binder elements `x` and `y`.
    *  (`id` is solely used for this textual representation.)
    */
-  class Scope[binderType <: NameElement] extends Iterable[binderType]{
+  class Scope[binderType <: NameElement] extends AbstractIterable[binderType] with Iterable[binderType] {
     private val substitution: mutable.Map[binderType, Element] =
       new mutable.LinkedHashMap[binderType, Element] // a LinkedHashMap is ordered by insertion order -- important!
 
diff --git a/src/library/scala/xml/MetaData.scala b/src/library/scala/xml/MetaData.scala
index 54af0719d4..98e863eb37 100644
--- a/src/library/scala/xml/MetaData.scala
+++ b/src/library/scala/xml/MetaData.scala
@@ -10,7 +10,7 @@ package scala.xml
 
 import Utility.sbToString
 import annotation.tailrec
-import scala.collection.Iterator
+import scala.collection.{ AbstractIterable, Iterator }
 
 /**
  * Copyright 2008 Google Inc. All Rights Reserved.
@@ -72,7 +72,12 @@ object MetaData {
  *  Copyright 2008 Google Inc. All Rights Reserved.
  *  @author Burak Emir <bqe@google.com>
  */
-abstract class MetaData extends Iterable[MetaData] with Equality with Serializable {
+abstract class MetaData
+extends AbstractIterable[MetaData]
+   with Iterable[MetaData]
+   with Equality
+   with Serializable {
+
   /** Updates this MetaData with the MetaData given as argument. All attributes that occur in updates
    *  are part of the resulting MetaData. If an attribute occurs in both this instance and
    *  updates, only the one in updates is part of the result (avoiding duplicates). For prefixed
diff --git a/src/library/scala/xml/pull/XMLEventReader.scala b/src/library/scala/xml/pull/XMLEventReader.scala
index e22f064d79..f84d91d138 100755
--- a/src/library/scala/xml/pull/XMLEventReader.scala
+++ b/src/library/scala/xml/pull/XMLEventReader.scala
@@ -23,7 +23,10 @@ import scala.xml.parsing.{ ExternalSources, MarkupHandler, MarkupParser }
  *  @author Burak Emir
  *  @author Paul Phillips
  */
-class XMLEventReader(src: Source) extends ProducerConsumerIterator[XMLEvent] {
+class XMLEventReader(src: Source)
+extends collection.AbstractIterator[XMLEvent]
+   with ProducerConsumerIterator[XMLEvent] {
+
   // We implement a pull parser as an iterator, but since we may be operating on
   // a stream (e.g. XML over a network) there may be arbitrarily long periods when
   // the queue is empty.  Fortunately the ProducerConsumerIterator is ideally
diff --git a/test/files/presentation/ide-bug-1000531.check b/test/files/presentation/ide-bug-1000531.check
index 4cd932e602..a58df6f014 100644
--- a/test/files/presentation/ide-bug-1000531.check
+++ b/test/files/presentation/ide-bug-1000531.check
@@ -21,7 +21,7 @@ retrieved 122 members
 `method addString(b: StringBuilder, start: String, sep: String, end: String)StringBuilder`
 `method aggregate[B](z: B)(seqop: (B, B) => B, combop: (B, B) => B)B`
 `method asInstanceOf[T0]=> T0`
-`method buffered=> Object with scala.collection.BufferedIterator[B]`
+`method buffered=> scala.collection.BufferedIterator[B]`
 `method clone()Object`
 `method collectFirst[B](pf: PartialFunction[B,B])Option[B]`
 `method collect[B](pf: PartialFunction[B,B])Iterator[B]`
@@ -75,9 +75,9 @@ retrieved 122 members
 `method nonEmpty=> Boolean`
 `method notify()Unit`
 `method notifyAll()Unit`
-`method padTo[A1 >: B](len: Int, elem: A1)Object with Iterator[A1]`
+`method padTo[A1 >: B](len: Int, elem: A1)Iterator[A1]`
 `method partition(p: B => Boolean)(Iterator[B], Iterator[B])`
-`method patch[B >: B](from: Int, patchElems: Iterator[B], replaced: Int)Object with Iterator[B]`
+`method patch[B >: B](from: Int, patchElems: Iterator[B], replaced: Int)Iterator[B]`
 `method product[B >: B](implicit num: Numeric[B])B`
 `method reduceLeftOption[B >: B](op: (B, B) => B)Option[B]`
 `method reduceLeft[B >: B](op: (B, B) => B)B`
@@ -115,9 +115,9 @@ retrieved 122 members
 `method wait(x$1: Long)Unit`
 `method wait(x$1: Long, x$2: Int)Unit`
 `method withFilter(p: B => Boolean)Iterator[B]`
-`method zipAll[B, A1 >: B, B1 >: B](that: Iterator[B], thisElem: A1, thatElem: B1)Object with Iterator[(A1, B1)]`
-`method zipWithIndex=> Object with Iterator[(B, Int)]{def idx: Int; def idx_=(x$1: Int): Unit}`
-`method zip[B](that: Iterator[B])Object with Iterator[(B, B)]`
+`method zipAll[B, A1 >: B, B1 >: B](that: Iterator[B], thisElem: A1, thatElem: B1)Iterator[(A1, B1)]`
+`method zipWithIndex=> Iterator[(B, Int)]`
+`method zip[B](that: Iterator[B])Iterator[(B, B)]`
 `method →[B](y: B)(java.util.Iterator[B], B)`
 `value __leftOfArrowjava.util.Iterator[B]`
 `value __resultOfEnsuringjava.util.Iterator[B]`