Checking in, I guess the test failing means thi...

Checking in, I guess the test failing means this is urgent. Not sure
what else will break.

28 files changed, 351 insertions, 104 deletions

diff --git a/src/library/scala/Collection.scala b/src/library/scala/Collection.scala
new file mode 100644
index 0000000000..10aa17d3e8
--- /dev/null
+++ b/src/library/scala/Collection.scala
@@ -0,0 +1,33 @@
+package scala;
+
+/** Variant of <code>Iterable</code> used to describe
+ *  collections with a finite number of elements.
+ *  Basically, this trait just adds size and toString to Iterable,
+ *  as most of the methods in Iterable already assume finite-ness.
+ *
+ *  @author Sean McDirmid
+ */
+trait Collection[+A] extends Iterable[A] {
+  /** Returns the number of elements in this collection.
+    *
+    *  @return number of collection elements.
+    */
+  def size : Int
+  /** Converts this iterable to a fresh Array with elements.
+    *
+    * @deprecated This method is broken for BitSet. BitSet.toArray will be updated to new behavior in a future release.
+    */
+  @deprecated def toArray[B >: A]: Array[B] = toList.toArray
+
+  override def toString = mkString(stringPrefix + "(", ", ", ")")
+
+  /** Defines the prefix of this object's <code>toString</code> representation.
+   */
+  protected def stringPrefix : String = {
+    val string = getClass.getName
+    val idx = string.lastIndexOf('.' : Int)
+    if (idx != -1) string.substring(idx + 1)
+    else string
+  }
+
+}
\ No newline at end of file
diff --git a/src/library/scala/Iterable.scala b/src/library/scala/Iterable.scala
index 85d61c7227..914395d40a 100644
--- a/src/library/scala/Iterable.scala
+++ b/src/library/scala/Iterable.scala
@@ -94,14 +94,14 @@ trait Iterable[+A] {
    *  @deprecated  use <code>++</code> instead
    */
   @deprecated
-  def concat[B >: A](that: Iterable[B]): Iterable[B] =
+  def concat[B >: A](that: Iterable[B]): Collection[B] =
     this ++ that
 
   /** Appends two iterable objects.
    *
    *  @return the new iterable object
    */
-  def ++ [B >: A](that: Iterable[B]): Iterable[B] = {
+  def ++ [B >: A](that: Iterable[B]): Collection[B] = {
     val buf = new ArrayBuffer[B]
     this copyToBuffer buf
     that copyToBuffer buf
@@ -115,7 +115,7 @@ trait Iterable[+A] {
    *  @return <code>f(a<sub>0</sub>), ..., f(a<sub>n</sub>)</code>
    *          if this iterable is <code>a<sub>0</sub>, ..., an</code>.
    */
-  def map[B](f: A => B): Iterable[B] = {
+  def map[B](f: A => B): Collection[B] = {
     val buf = new ArrayBuffer[B]
     val elems = elements
     while (elems.hasNext) buf += f(elems.next)
@@ -129,7 +129,7 @@ trait Iterable[+A] {
    *  @return  <code>f(a<sub>0</sub>) ::: ... ::: f(a<sub>n</sub>)</code> if
    *           this iterable is <code>a<sub>0</sub>, ..., a<sub>n</sub></code>.
    */
-  def flatMap[B](f: A => Iterable[B]): Iterable[B] = {
+  def flatMap[B](f: A => Iterable[B]): Collection[B] = {
     val buf = new ArrayBuffer[B]
     val elems = elements
     while (elems.hasNext) f(elems.next) copyToBuffer buf
@@ -142,7 +142,7 @@ trait Iterable[+A] {
    *  @param p the predicate used to filter the list.
    *  @return the elements of this list satisfying <code>p</code>.
    */
-  def filter(p: A => Boolean): Iterable[A] = {
+  def filter(p: A => Boolean): Collection[A] = {
     val buf = new ArrayBuffer[A]
     val elems = elements
     while (elems.hasNext) { val x = elems.next; if (p(x)) buf += x }
@@ -156,7 +156,7 @@ trait Iterable[+A] {
    *  @return  the longest prefix of this iterable whose elements satisfy
    *           the predicate <code>p</code>.
    */
-  def takeWhile(p: A => Boolean): Iterable[A] =
+  def takeWhile(p: A => Boolean): Collection[A] =
     new ArrayBuffer[A] ++ elements.takeWhile(p)
 
   /** Returns the longest suffix of this iterable whose first element
@@ -166,7 +166,7 @@ trait Iterable[+A] {
    *  @return  the longest suffix of the iterable whose first element
    *           does not satisfy the predicate <code>p</code>.
    */
-  def dropWhile(p: A => Boolean): Iterable[A] =
+  def dropWhile(p: A => Boolean): Collection[A] =
     new ArrayBuffer[A] ++ elements.dropWhile(p)
 
   /** Returns an iterable consisting only over the first <code>n</code>
@@ -176,7 +176,7 @@ trait Iterable[+A] {
    *  @param n the number of elements to take
    *  @return  the new iterable
    */
-  def take(n: Int): Iterable[A] =
+  def take(n: Int): Collection[A] =
     new ArrayBuffer[A] ++ elements.take(n)
 
   /** Returns this iterable without its <code>n</code> first elements
@@ -186,7 +186,7 @@ trait Iterable[+A] {
    *  @param n the number of elements to drop
    *  @return  the new iterable
    */
-  def drop(n: Int): Iterable[A] =
+  def drop(n: Int): Collection[A] =
     new ArrayBuffer[A] ++ elements.drop(n)
 
   /** Apply a function <code>f</code> to all elements of this
@@ -316,6 +316,7 @@ trait Iterable[+A] {
 
   /** Copy all elements to a given buffer
    *  @param  dest   The buffer to which elements are copied
+   *  @note Will not terminate if not finite.
    */
   def copyToBuffer[B >: A](dest: Buffer[B]): Unit = elements copyToBuffer dest
 
@@ -335,7 +336,7 @@ trait Iterable[+A] {
   }
 
   /**
-   *  Create a fresh list with all the elements of this iterable object
+   *  Create a fresh list with all the elements of this iterable object.
    */
   def toList: List[A] = elements.toList
 
@@ -368,6 +369,7 @@ trait Iterable[+A] {
    */
   def mkString(sep: String): String = this.mkString("", sep, "")
 
+
   /** Write all elements of this string into given string builder.
    *
    *  @param buf ...
@@ -393,9 +395,6 @@ trait Iterable[+A] {
   def copyToArray[B >: A](xs: Array[B], start: Int): Unit =
     elements.copyToArray(xs, start)
 
-  /** Converts this iterable to a fresh Array with elements.
-   */
-  def toArray[B >: A]: Array[B] = toList.toArray
 
   /** Is this collection empty? */
   def isEmpty = elements.hasNext
diff --git a/src/library/scala/IterableProxy.scala b/src/library/scala/IterableProxy.scala
index 486108e930..c28fa1e8a0 100644
--- a/src/library/scala/IterableProxy.scala
+++ b/src/library/scala/IterableProxy.scala
@@ -27,14 +27,14 @@ trait IterableProxy[+A] extends Iterable[A] with Proxy {
   def self: Iterable[A]
   override def elements: Iterator[A] = self.elements
   @deprecated
-  override def concat [B >: A](that: Iterable[B]): Iterable[B] = self concat that
-  override def map[B](f: A => B): Iterable[B] = self map f
-  override def flatMap[B](f: A => Iterable[B]): Iterable[B] = self flatMap f
-  override def filter(p: A => Boolean): Iterable[A] = self filter p
-  override def takeWhile(p: A => Boolean): Iterable[A] = self takeWhile p
-  override def dropWhile(p: A => Boolean): Iterable[A] = self dropWhile p
-  override def take(n: Int): Iterable[A] = self take n
-  override def drop(n: Int): Iterable[A] = self drop n
+  override def concat [B >: A](that: Iterable[B]): Collection[B] = self concat that
+  override def map[B](f: A => B): Collection[B] = self map f
+  override def flatMap[B](f: A => Iterable[B]): Collection[B] = self flatMap f
+  override def filter(p: A => Boolean): Collection[A] = self filter p
+  override def takeWhile(p: A => Boolean): Collection[A] = self takeWhile p
+  override def dropWhile(p: A => Boolean): Collection[A] = self dropWhile p
+  override def take(n: Int): Collection[A] = self take n
+  override def drop(n: Int): Collection[A] = self drop n
   override def foreach(f: A => Unit): Unit = self foreach f
   override def forall(p: A => Boolean): Boolean = self forall p
   override def exists(p: A => Boolean): Boolean = self exists p
diff --git a/src/library/scala/List.scala b/src/library/scala/List.scala
index de0b24c716..7e327ef8f0 100644
--- a/src/library/scala/List.scala
+++ b/src/library/scala/List.scala
@@ -1123,8 +1123,6 @@ sealed abstract class List[+a] extends Seq[a] {
     b.toList
   }
 
-  protected override def stringPrefix: String = "List"
-
 }
 
 /** The empty list.
diff --git a/src/library/scala/Seq.scala b/src/library/scala/Seq.scala
index 78dc4af435..76939c3745 100644
--- a/src/library/scala/Seq.scala
+++ b/src/library/scala/Seq.scala
@@ -69,13 +69,14 @@ object Seq {
  *  @author  Matthias Zenger
  *  @version 1.0, 16/07/2003
  */
-trait Seq[+A] extends AnyRef with PartialFunction[Int, A] with Iterable[A] {
+trait Seq[+A] extends AnyRef with PartialFunction[Int, A] with Collection[A] {
 
   /** Returns the length of the sequence.
    *
    *  @return the sequence length.
    */
   def length: Int
+  final def size = length
 
   /** Returns true if length == 0
    */
@@ -242,17 +243,6 @@ trait Seq[+A] extends AnyRef with PartialFunction[Int, A] with Iterable[A] {
   @deprecated
   def subseq(from: Int, end: Int): Seq[A] = slice(from, end - from)
 
-  /** Customizes the <code>toString</code> method.
-   *
-   *  @return a string representation of this sequence.
-   */
-  override def toString() =
-    stringPrefix + "(" + mkString(",") + ")"
-
-
-  /** Defines the prefix of the string representation.
-   */
-  protected def stringPrefix: String = "Seq"
 
   /** Converts this sequence to a fresh Array with <code>length</code> elements.
    */
diff --git a/src/library/scala/collection/BitSet.scala b/src/library/scala/collection/BitSet.scala
index eea70c3cb9..c2197dc137 100644
--- a/src/library/scala/collection/BitSet.scala
+++ b/src/library/scala/collection/BitSet.scala
@@ -11,7 +11,6 @@
 
 package scala.collection
 
-
 /** <p>
  *    The class <code>BitSet</code> provides the interface for a space-efficient
  *    implementation of dense integer sets represented as bits in array of
@@ -144,5 +143,22 @@ abstract class BitSet extends Set[Int] {
    */
   protected final def mask(n: Int): Int = 1 << (n & 0x1F)
 
-  override def toArray[B >: Int]: Array[B] = super.toArray
+  /**
+   * @return a copy of the array underlying this bitset
+   */
+  def underlying : Array[Int] = {
+     val length = memsize(capacity)
+     val newarr = new Array[Int](length)
+     if (arr.length > 0)
+       arraycopy(this.arr, 0, newarr, 0, length)
+     newarr;
+   }
+  /**
+   * @return a copy of the array underlying this bitset
+   *
+   * @deprecated This method does not currently implement behavior specified in Iterable.toArray.
+   *             This method will implement the Iterbale.toArray behavior in a future release.
+   *             Please use <code>underlying</code> to get previous <code>toArray</code> behavior.
+   */
+  @deprecated override def toArray[B >: Int]: Array[B] = underlying.asInstanceOf[Array[B]];
 }
diff --git a/src/library/scala/collection/Map.scala b/src/library/scala/collection/Map.scala
index df2f2630d3..30ce8a1ab9 100644
--- a/src/library/scala/collection/Map.scala
+++ b/src/library/scala/collection/Map.scala
@@ -34,7 +34,7 @@ import Predef._
  *  @author  Martin Odersky
  *  @version 1.2, 31/12/2006
  */
-trait Map[A, +B] extends PartialFunction[A, B] with Iterable[(A, B)] {
+trait Map[A, +B] extends PartialFunction[A, B] with Collection[(A, B)] {
 
   /** Compute the number of key-to-value mappings.
    *
diff --git a/src/library/scala/collection/Set.scala b/src/library/scala/collection/Set.scala
index 6f90a27cb4..049228de0d 100644
--- a/src/library/scala/collection/Set.scala
+++ b/src/library/scala/collection/Set.scala
@@ -31,7 +31,7 @@ package scala.collection
  *  @author  Martin Odersky
  *  @version 2.0, 01/01/2007
  */
-trait Set[A] extends (A => Boolean) with Iterable[A] {
+trait Set[A] extends (A => Boolean) with Collection[A] {
 
   /** Returns the number of elements in this set.
    *
@@ -92,12 +92,7 @@ trait Set[A] extends (A => Boolean) with Iterable[A] {
     (0 /: this)((hash, e) => hash + e.hashCode())
 
 
-  /** Returns a string representation of this set.
-   *
-   *  @return a string showing all elements of this set.
-   */
-  override def toString() = mkString("Set(", ", ", ")")
-  override def toArray[B >: A]: Array[B] = {
+  @deprecated override def toArray[B >: A]: Array[B] = {
     val result = new Array[B](size)
     copyToArray(result, 0)
     result
diff --git a/src/library/scala/collection/immutable/BitEnumeration.scala b/src/library/scala/collection/immutable/BitEnumeration.scala
new file mode 100644
index 0000000000..e54d02b6d8
--- /dev/null
+++ b/src/library/scala/collection/immutable/BitEnumeration.scala
@@ -0,0 +1,198 @@
+package scala.collection.immutable;
+import scala.collection.mutable;
+
+/** Holds the two underlying bit enumeration representations.
+ *  @author Sean McDirmid
+ */
+object BitEnumeration {
+  def At32 = new At32;
+  /** A bit enumeration that supports at most 32 values
+   */
+  class At32 extends BitEnumeration {
+    type Underlying = Int;
+    def maxBits = 32;
+    def Set(underlying : Int) = new Set(underlying);
+    class Set(val underlying : Int) extends SetImpl {
+      def underlyingAsLong = {
+        if (underlying >= 0) underlying.toLong;
+        else {
+          val underlying0 = (~(1 << 31)) & underlying;
+          assert(underlying0 >= 0);
+          underlying0.toLong | (1L << 31);
+        }
+      }
+      def contains(value : Value) = (underlying & value.mask32) != 0;
+      def |(  set :   Set) = new Set(underlying |   set.underlying);
+      def |(value : Value) = new Set(underlying | value.mask32);
+      def &~(value : Value) = new Set(underlying & (~value.mask32));
+      def &(set : Set) = new Set(underlying & set.underlying);
+    }
+  }
+  def At64 = new At64;
+  /** A bit enumeration that supports at most 64 values
+   */
+  class At64 extends BitEnumeration {
+    type Underlying = Long;
+    def maxBits = 64;
+    def Set(underlying : Long) = new Set(underlying);
+    class Set(val underlying : Long) extends SetImpl {
+      def underlyingAsLong = underlying;
+      def contains(value : Value) = (underlying & value.mask64) != 0;
+      def |(  set :   Set) = new Set(underlying |   set.underlying);
+      def |(value : Value) = new Set(underlying | value.mask64);
+      def &~(value : Value) = new Set(underlying & (~value.mask64));
+      def &(set : Set) = new Set(underlying & set.underlying);
+    }
+  }
+}
+
+/** Defines a finite set of values specific to an enumeration. Unlike
+  * <code>scala.Enumeration</code>, each value in a bit enumeration is
+  * associated with a unique bit that enables efficient representation
+  * and manipulation as an integer bit mask. For this reason, only a
+  * small number (32 or 64) of values are supported per bit enumeration.
+  * Concrete sub-classes of this class include <code>BitEnumeration.At32</code>
+  * and <code>BitEnumeration.At64</code>, which respectively support 32 and 64
+  * values.
+  *
+  * @ex
+  <style type="text/css">
+    p.p1 {margin: 0.0px 0.0px 0.0px 0.0px; font: 18.0px Courier New}
+    p.p2 {margin: 0.0px 0.0px 0.0px 0.0px; font: 18.0px Courier New; color: #913030}
+    span.s1 {color: #808080}
+    span.s2 {color: #000000}
+    span.s3 {color: #1a417b}
+    span.s4 {color: #4c4c4c}
+    span.s5 {color: #913030}
+    span.s6 {color: #1229cd}
+  </style>
+  * <p class="p1">    <span class="s1"><b>import</b></span> <b>scala</b>.<b>collection</b>.<b>immutable</b>.<b>BitEnumeration</b>;</p>
+  * <p class="p2"><span class="s2">    </span><span class="s1"><b>object</b></span><span class="s2"> </span><b>fruits</b><span class="s2"> </span><span class="s1"><b>extends</b></span><span class="s2"> </span><b>BitEnumeration</b><span class="s2">.</span><b>At32</b><span class="s2"> {</span></p>
+  *
+  * <p class="p1">      <span class="s1"><b>override</b></span> <span class="s1"><b>def</b></span> <span class="s3"><b>stringPrefix</b></span> = <span class="s4"><i>"fruits"</i></span>;</p>
+  * <p class="p1">    }</p>
+  * <p class="p2"><span class="s2">    </span><span class="s1"><b>object</b></span><span class="s2"> </span><b>Apple</b><span class="s2"> </span><span class="s1"><b>extends</b></span><span class="s2"> </span><b>fruits</b><span class="s2">.</span><b>Value</b><span class="s2">(</span><span class="s4"><i>"apple"</i></span><span class="s2">, 1);</span></p>
+  * <p class="p2"><span class="s2">    </span><span class="s1"><b>object</b></span><span class="s2"> </span><b>Orange</b><span class="s2"> </span><span class="s1"><b>extends</b></span><span class="s2"> </span><b>fruits</b><span class="s2">.</span><b>Value</b><span class="s2">(</span><span class="s4"><i>"orange"</i></span><span class="s2">, 31);</span></p>
+  * <p class="p1">    <span class="s1"><b>object</b></span> <span class="s5"><b>Pear</b></span> <span class="s1"><b>extends</b></span> <span class="s5"><b>fruits</b></span>.<span class="s5"><b>Value</b></span>(<span class="s4"><i>"pear"</i></span>, 15);</p>
+  * <p class="p1">    </p>
+  * <p class="p1">    <span class="s1"><b>val</b></span> <span class="s6"><b>set</b></span> = <span class="s5"><b>fruits</b></span>.<span class="s3"><b>Empty</b></span>;</p>
+  * <p class="p1">    <span class="s1"><b>val</b></span> <span class="s6"><b>set0</b></span> = <span class="s6"><b>set</b></span> <span class="s3"><b>|</b></span> <span class="s5"><b>Apple</b></span> <span class="s3"><b>|</b></span> <span class="s5"><b>Orange</b></span> <span class="s3"><b>|</b></span> <span class="s5"><b>Pear</b></span>;</p>
+  * <p class="p1">    <span class="s1"><b>val</b></span> <span class="s6"><b>set1</b></span> = <span class="s6"><b>set0</b></span> <span class="s3"><b>&amp;~</b></span> <span class="s5"><b>Orange</b></span>;</p>
+  *
+  * @param names Names that are added to the enumeration upon creation.
+  *
+  * @author  Sean McDirmid
+  */
+sealed abstract class BitEnumeration {
+  private val bits = new mutable.HashMap[Int,Value];
+  /** Maximum number of values supported by this bit enumeration. */
+  protected def maxBits : Int;
+  /** Create a new value of a specified <code>name</code> and <code>bit</code>.
+   *  @throw IllegalArgumentException if <code>bit</code> is already reserved for another value or is greater than <code>maxBits</code>.
+   */
+  def Value(name : String, bit : Int) = new Value(name, bit);
+  /** Create a new value of a specified <code>name</code>, choose first available bit.
+   *  @throw IllegalArgumentException if all bits in enumeration are already reserved.
+   */
+  def Value(name : String           ) : Value = Value(name, {
+    var bit = 0;
+    while (bits.contains(bit)) bit = bit + 1;
+    bit;
+  });
+  /** Create a new value of a specified <code>bit</code>, name not specified.
+   *  @throw IllegalArgumentException if <code>bit</code> is already reserved for another value or is greater than <code>maxBits</code>.
+   */
+  def Value(               bit : Int) : Value = Value(null, bit);
+   /** Create a new value with no name, choose first available bit.
+    *  @throw IllegalArgumentException if all bits in enumeration are already reserved.
+    */
+  def Value(                        ) : Value = Value(null);
+
+  /** Represents values of the enumeration with a <code>name</code>, which is used for printing purposes only,
+   *  and a <code>bit</code> that encodes this value in a set representation.
+   */
+  class Value(name : String, bit : Int) {
+
+    val existing = bits.get(bit);
+    if (!existing.isEmpty || bit >= maxBits)
+      throw new IllegalArgumentException("bit " + bit + " is invalid for " + this + {
+        if (!existing.isEmpty) " - already used for " + existing.get;
+        else "";
+      });
+    bits += (bit -> this);
+    override def toString = {
+      if (name == null) "bit" + bit else name;
+    }
+    def mask32 : Int  = 1  << bit;
+    def mask64 : Long = 1L << bit;
+  }
+  /** Represents wrappers around integers that bit-encode sets of enumeration values.
+   */
+  type Set <: SetImpl;
+  /** Underlying integer type of a set based on this bit enumeration.
+   */
+  type Underlying <: AnyVal;
+  /** A set that contains no values in this bit enumeration.
+   */
+  def Empty : Set = Set(0.asInstanceOf[Underlying]);
+  /** Given an integer that bit encodes a set of enumeration values,
+   *  produces an object that wraps this integer with high-level Set APIs.
+   */
+  def Set(underlying : Underlying) : Set;
+  protected def stringPrefix = "Bits";
+
+  abstract class SetImpl extends collection.immutable.Set[Value] {
+    /** The integer that bit-encodes a set of enumeration values.
+     */
+    val underlying : Underlying;
+    /** Equivalent to <code>++</code> for bit sets. Returns a set
+     *  that has all values in <code>this</code> and <code>set</code>.
+     */
+    def |(set   : Set  ) : Set;
+    /** Equivalent to <code>+</code> for bit sets. Returns a set
+     *  that has all values in <code>this</code> with the addition of <code>value</code>.
+     */
+    def |(value : Value) : Set;
+    /** Equivalent to <code>**</code> for bit sets.
+     *  Returns a bit set that has all values that are both in <code>this</code> and <code>set</code>.
+     */
+    def &(set   : Set  ) : Set;
+    /** Equivalent to <code>-</code> for bit sets.
+     *  Returns a bit set that has all values in <code>this</code> except for <code>value</code>.
+     */
+    def &~(value : Value) : Set;
+    /** returns the underlying integer representation of this set as a long. */
+    protected def underlyingAsLong : Long;
+    def -(value : Value) : Set = this &~ value;
+    def +(value : Value) : Set = this | value;
+    def ++(set : Set) : Set = this | set;
+    def **(set : Set) : Set = this & set;
+    def size = {
+      var x = underlyingAsLong;
+      var sz = 0;
+      while (x != 0) {
+        if ((x & 1) != 0) sz = sz + 1;
+        x = x >> 1;
+      }
+      sz;
+    }
+    override def stringPrefix = BitEnumeration.this.stringPrefix;
+    def elements = new Iterator[Value] {
+      var bit = 0;
+      var underlying = underlyingAsLong;
+      def hasNext = underlying != 0;
+      private def shift = {
+        underlying = underlying >> 1;
+        bit = bit + 1;
+      }
+      def next = {
+        if (underlying == 0) throw new NoSuchElementException;
+        while ((underlying & 1) == 0) shift;
+        val ret = bits(bit);
+        shift;
+        ret;
+      }
+    }
+    def empty[B]: scala.collection.immutable.Set[B] = new scala.collection.immutable.HashSet[B];
+  }
+}
diff --git a/src/library/scala/collection/jcl/Buffer.scala b/src/library/scala/collection/jcl/Buffer.scala
index db22270f97..28aa87dc98 100644
--- a/src/library/scala/collection/jcl/Buffer.scala
+++ b/src/library/scala/collection/jcl/Buffer.scala
@@ -86,6 +86,7 @@ trait Buffer[A] extends MutableSeq[A] with Collection[A] with Ranged[Int,A] {
   override def pfilter(p : A => Boolean) : MutableSeq[A] = super[MutableSeq].pfilter(p);
   override def rangeImpl(from : Option[Int], until : Option[Int]) : Buffer[A] = new Range(from, until);
 
+
   protected class Range(var from : Option[Int], var until : Option[Int]) extends Buffer[A] {
     if (from == None && until == None) throw new IllegalArgumentException;
     if (from != None && until != None && !(from.get < until.get)) throw new IllegalArgumentException;
@@ -104,11 +105,11 @@ trait Buffer[A] extends MutableSeq[A] with Collection[A] with Ranged[Int,A] {
     override def set(idx : Int, a : A) = Buffer.this.set(translate(idx), a);
     override def add(idx : Int, a : A) = Buffer.this.add(translate(idx), a);
     override def remove(idx : Int) = Buffer.this.remove(translate(idx));
-    override def size = {
+    override def length = {
       if (until != None) {
         if (from != None) until.get - from.get;
         else until.get;
-      } else super.size;
+      } else super.length;
     }
     def elements : BufferIterator[Int,A] = new RangeIterator;
     class RangeIterator extends BufferIterator[Int,A] {
diff --git a/src/library/scala/collection/jcl/BufferWrapper.scala b/src/library/scala/collection/jcl/BufferWrapper.scala
index af97e9f03f..c056899fa0 100644
--- a/src/library/scala/collection/jcl/BufferWrapper.scala
+++ b/src/library/scala/collection/jcl/BufferWrapper.scala
@@ -48,4 +48,5 @@ trait BufferWrapper[A] extends Buffer[A] with CollectionWrapper[A] {
     def previousIndex = underlying.previousIndex;
     def nextIndex = underlying.nextIndex;
   }
+  override def length = underlying.size;
 }
diff --git a/src/library/scala/collection/jcl/Collection.scala b/src/library/scala/collection/jcl/Collection.scala
index 2f2dd646cb..5f422364e9 100644
--- a/src/library/scala/collection/jcl/Collection.scala
+++ b/src/library/scala/collection/jcl/Collection.scala
@@ -80,5 +80,6 @@ trait Collection[A] extends MutableIterable[A] {
     override def pfilter(p1 : A => Boolean) : MutableIterable[A] =
       Collection.this.pfilter(a => p(a) && p1(a));
     def elements = Collection.this.elements.filter(p);
+    def size = size0;
   }
 }
diff --git a/src/library/scala/collection/jcl/IterableWrapper.scala b/src/library/scala/collection/jcl/IterableWrapper.scala
index b904342af6..6e556e3199 100644
--- a/src/library/scala/collection/jcl/IterableWrapper.scala
+++ b/src/library/scala/collection/jcl/IterableWrapper.scala
@@ -25,7 +25,7 @@ trait IterableWrapper[A] extends MutableIterable[A] {
     case that : IterableWrapper[_] => underlying.retainAll(that.underlying);
     case _ => super.retainAll(that);
   }
-  override def size = underlying.size;
+  //override def size = underlying.size;
   override def isEmpty = underlying.isEmpty;
   override def clear = underlying.clear;
   override def elements : MutableIterator[A] = new IteratorWrapper(underlying.iterator);
diff --git a/src/library/scala/collection/jcl/Map.scala b/src/library/scala/collection/jcl/Map.scala
index 1546831d23..9a70e08016 100644
--- a/src/library/scala/collection/jcl/Map.scala
+++ b/src/library/scala/collection/jcl/Map.scala
@@ -69,6 +69,7 @@ trait Map[K,E] extends MutableIterable[Tuple2[K,E]] with scala.collection.mutabl
       Map.this.pfilter(p).lense(f, g);
     override def lense[G](f0 : F => G, g0 : G => F) : jcl.Map[K,G] =
       Map.this.lense[G](x => f0(f(x)), y => g(g0(y)));
+    override def size = size0;
   }
   protected class Filter(p : K => Boolean) extends jcl.Map[K,E] {
     override def elements = Map.this.elements.filter(k => p(k._1));
@@ -87,8 +88,10 @@ trait Map[K,E] extends MutableIterable[Tuple2[K,E]] with scala.collection.mutabl
     }
     override def pfilter(p0 : K => Boolean) : jcl.Map[K,E] =
       Map.this.pfilter(k => p(k) && p0(k));
+    override def size = size0;
   }
   protected class KeySet extends Set[K] {
+    override def size = Map.this.size;
     override def add(k : K) = Map.this.put(k, default(k)) == None;
     override def elements = Map.this.elements.map(._1);
     override def has(k : K) = Map.this.contains(k);
diff --git a/src/library/scala/collection/jcl/MutableIterable.scala b/src/library/scala/collection/jcl/MutableIterable.scala
index 081865169a..be7d071fec 100644
--- a/src/library/scala/collection/jcl/MutableIterable.scala
+++ b/src/library/scala/collection/jcl/MutableIterable.scala
@@ -48,12 +48,13 @@ trait MutableIterable[A] extends Iterable[A] {
 
   /** @return the current number of elements in the collection.
    **/
-  def size : Int = {
+  protected def size0 : Int = {
     var count = 0;
     val i = elements;
     while (i.hasNext) { count = count + 1; i.next; }
     count;
   }
+
   /** clear all elements from the collection.
    **/
   def clear(): Unit = {
diff --git a/src/library/scala/collection/jcl/MutableSeq.scala b/src/library/scala/collection/jcl/MutableSeq.scala
index a84f248966..d3869465d3 100644
--- a/src/library/scala/collection/jcl/MutableSeq.scala
+++ b/src/library/scala/collection/jcl/MutableSeq.scala
@@ -19,8 +19,6 @@ trait MutableSeq[A] extends MutableIterable[A] with Seq[A] {
 
   override def isEmpty = super[MutableIterable].isEmpty;
 
-  override def length = size;
-
   override def apply(idx : Int) = elements.seek(idx);
 
   def pfilter(p : A => Boolean) : MutableSeq[A] = new Filter(p);
@@ -79,4 +77,13 @@ trait MutableSeq[A] extends MutableIterable[A] with Seq[A] {
     override def elements = MutableSeq.this.elements.map(f);
     override def apply(idx : Int) = f(MutableSeq.this.apply(idx));
   }
+  override def length = {
+    var i = elements;
+    var sz = 0;
+    while (i.hasNext) {
+      sz = sz + 1;
+      i.next;
+    }
+    sz;
+  }
 }
diff --git a/src/library/scala/collection/jcl/SetWrapper.scala b/src/library/scala/collection/jcl/SetWrapper.scala
index 18f7e342b2..77113800d5 100644
--- a/src/library/scala/collection/jcl/SetWrapper.scala
+++ b/src/library/scala/collection/jcl/SetWrapper.scala
@@ -18,4 +18,5 @@ trait SetWrapper[A] extends CollectionWrapper[A] with Set[A] {
   protected def underlying: java.util.Set;
   override def isEmpty = super[CollectionWrapper].isEmpty;
   override def clear() = super[CollectionWrapper].clear;
+  override def size = underlying.size;
 }
diff --git a/src/library/scala/collection/mutable/ArrayBuffer.scala b/src/library/scala/collection/mutable/ArrayBuffer.scala
index 58bd61bbb2..e32f8aecb9 100644
--- a/src/library/scala/collection/mutable/ArrayBuffer.scala
+++ b/src/library/scala/collection/mutable/ArrayBuffer.scala
@@ -29,9 +29,9 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] {
    *  @param elem  the element to append.
    */
   def +=(elem: A): Unit = {
-    ensureSize(size+1)
-    array(size) = elem
-    size = size + 1
+    ensureSize(size0+1)
+    array(size0) = elem
+    size0 = size0 + 1
   }
 
   /** Appends a number of elements provided by an iterable object
@@ -50,9 +50,9 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] {
    *  @param len    the number of elements to append
    */
   override def ++=(src: Array[A], start: int, len: int): Unit = {
-    ensureSize(size + len)
-    Array.copy(src, start, array, size, len)
-    size = size + len
+    ensureSize(size0 + len)
+    Array.copy(src, start, array, size0, len)
+    size0 = size0 + len
   }
 
   /** Prepends a single element to this buffer and return
@@ -62,10 +62,10 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] {
    *  @return      the updated buffer.
    */
   def +:(elem: A): Buffer[A] = {
-    ensureSize(size+1)
-    copy(0, 1, size)
+    ensureSize(size0+1)
+    copy(0, 1, size0)
     array(0) = elem
-    size = size + 1
+    size0 = size0 + 1
     this
   }
 
@@ -76,7 +76,7 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] {
    *  @throws Predef.IndexOutOfBoundException if <code>i</code> is out of bounds.
    */
   override def apply(i: Int) = {
-    if ((i < 0) || (i >= size))
+    if ((i < 0) || (i >= size0))
       throw new IndexOutOfBoundsException(i.toString())
     else
       array(i)
@@ -100,14 +100,14 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] {
    *  @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds.
    */
   def insertAll(n: Int, iter: Iterable[A]): Unit = {
-    if ((n < 0) || (n > size))
+    if ((n < 0) || (n > size0))
       throw new IndexOutOfBoundsException("cannot insert element at " + n);
     val xs = iter.elements.toList
     val len = xs.length
-    ensureSize(size+len)
-    copy(n, n + len, size - n)
+    ensureSize(size0+len)
+    copy(n, n + len, size0 - n)
     xs.copyToArray(array, n)
-    size = size + len
+    size0 = size0 + len
   }
 
   /** Replace element at index <code>n</code> with the new element
@@ -118,7 +118,7 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] {
    *  @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds.
    */
   def update(n: Int, newelem: A): Unit = {
-    if ((n < 0) || (n >= size))
+    if ((n < 0) || (n >= size0))
       throw new IndexOutOfBoundsException("cannot update element at " + n);
     else {
       val res = array(n)
@@ -134,18 +134,18 @@ class ArrayBuffer[A] extends Buffer[A] with ResizableArray[A] {
    *  @throws Predef.IndexOutOfBoundsException if <code>n</code> is out of bounds.
    */
   def remove(n: Int): A = {
-    if ((n < 0) || (n >= size))
+    if ((n < 0) || (n >= size0))
       throw new IndexOutOfBoundsException("cannot remove element at " + n);
     val res = array(n);
-    copy(n + 1, n, size - n - 1);
-    size = size - 1;
+    copy(n + 1, n, size0 - n - 1);
+    size0 = size0 - 1;
     res
   }
 
   /** Clears the buffer contents.
    */
   def clear(): Unit = {
-    size = 0
+    size0 = 0
   }
 
   /** Return a clone of this buffer.
diff --git a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
index 76159a9e6f..52df82c0ad 100644
--- a/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
+++ b/src/library/scala/collection/mutable/ImmutableSetAdaptor.scala
@@ -36,7 +36,7 @@ class ImmutableSetAdaptor[A](protected var set: immutable.Set[A]) extends Set[A]
 
   override def toList: List[A] = set.toList
 
-  override def toString() = set.toString()
+  override def toString = set.toString
 
   def elements: Iterator[A] = set.elements
 
diff --git a/src/library/scala/collection/mutable/PriorityQueue.scala b/src/library/scala/collection/mutable/PriorityQueue.scala
index b4e35aebb3..6e86a2f818 100644
--- a/src/library/scala/collection/mutable/PriorityQueue.scala
+++ b/src/library/scala/collection/mutable/PriorityQueue.scala
@@ -24,7 +24,7 @@ package scala.collection.mutable
 
 @serializable @cloneable
 class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] {
-  size = size + 1 // we do not use array(0)
+  size0 = size0 + 1 // we do not use array(0)
 
   protected def fixUp(as: Array[A], m: Int): Unit = {
     var k: Int = m
@@ -56,17 +56,17 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] {
    *
    *  @return true, iff there is no element in the queue.
    */
-  override def isEmpty: Boolean = size < 2
+  override def isEmpty: Boolean = size0 < 2
 
   /** Inserts a single element into the priority queue.
    *
    *  @param  elem        the element to insert
    */
   def +=(elem: A): Unit = {
-    ensureSize(size+1)
-    array(size) = elem
-    fixUp(array, size)
-    size = size + 1
+    ensureSize(size0+1)
+    array(size0) = elem
+    fixUp(array, size0)
+    size0 = size0 + 1
   }
 
   def +(elem: A): PriorityQueue[A] = { this += elem; this }
@@ -110,11 +110,11 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] {
    *  @return   the element with the highest priority.
    */
   def dequeue(): A =
-    if (size > 1) {
-      size = size - 1
-      swap(1, size)
-      fixDown(array, 1, size - 1)
-      array(size)
+    if (size0 > 1) {
+      size0 = size0 - 1
+      swap(1, size0)
+      fixDown(array, 1, size0 - 1)
+      array(size0)
     } else
       throw new NoSuchElementException("no element to remove from heap")
 
@@ -123,12 +123,12 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] {
    *
    *  @return   the element with the highest priority.
    */
-  def max: A = if (size > 1) array(1) else throw new NoSuchElementException("queue is empty")
+  def max: A = if (size0 > 1) array(1) else throw new NoSuchElementException("queue is empty")
 
   /** Removes all elements from the queue. After this operation is completed,
    *  the queue will be empty.
    */
-  def clear(): Unit = { size = 1 }
+  def clear(): Unit = { size0 = 1 }
 
   /** Returns an iterator which yiels all the elements of the priority
    *  queue in descending priority order.
@@ -136,9 +136,9 @@ class PriorityQueue[A <% Ordered[A]] extends ResizableArray[A] {
    *  @return  an iterator over all elements sorted in descending order.
    */
   override def elements: Iterator[A] = new Iterator[A] {
-    val as: Array[A] = new Array[A](size)
-    Array.copy(array, 0, as, 0, size)
-    var i = size - 1
+    val as: Array[A] = new Array[A](size0)
+    Array.copy(array, 0, as, 0, size0)
+    var i = size0 - 1
     def hasNext: Boolean = i > 0
     def next(): A = {
       val res = as(1)
diff --git a/src/library/scala/collection/mutable/ResizableArray.scala b/src/library/scala/collection/mutable/ResizableArray.scala
index daf3888ade..21f8783bea 100644
--- a/src/library/scala/collection/mutable/ResizableArray.scala
+++ b/src/library/scala/collection/mutable/ResizableArray.scala
@@ -22,14 +22,14 @@ trait ResizableArray[A] extends Seq[A] {
 
   protected val initialSize: Int = 16
   protected var array: Array[A] = new Array[A](initialSize)
-  protected var size: Int = 0
+  protected var size0: Int = 0
 
   //##########################################################################
   // implement/override methods of Seq[A]
 
   /** Returns the length of this resizable array.
    */
-  def length: Int = size
+  def length: Int = size0
 
   def apply(i: Int) = array(i)
 
@@ -40,19 +40,19 @@ trait ResizableArray[A] extends Seq[A] {
    *  @param  start starting index.
    */
   override def copyToArray[B >: A](xs: Array[B], start: Int): Unit =
-    Array.copy(array, 0, xs, start, size)
+    Array.copy(array, 0, xs, start, size0)
 
   /** Copy all elements to a buffer
    *  @param   The buffer to which elements are copied
    */
   override def copyToBuffer[B >: A](dest: Buffer[B]): Unit =
-    dest.++=(array.asInstanceOf[Array[B]], 0, size)
+    dest.++=(array.asInstanceOf[Array[B]], 0, size0)
 
   /** Returns a new iterator over all elements of this resizable array.
    */
   def elements: Iterator[A] = new Iterator[A] {
     var i = 0
-    def hasNext: Boolean = i < size
+    def hasNext: Boolean = i < size0
     def next(): A = { i = i + 1; array(i - 1) }
   }
 
@@ -65,7 +65,7 @@ trait ResizableArray[A] extends Seq[A] {
       while (n > newsize)
         newsize = newsize * 2
       val newar: Array[A] = new Array(newsize)
-      Array.copy(array, 0, newar, 0, size)
+      Array.copy(array, 0, newar, 0, size0)
       array = newar
     }
 
diff --git a/src/library/scala/collection/mutable/SynchronizedSet.scala b/src/library/scala/collection/mutable/SynchronizedSet.scala
index 69726b1bc9..ce07cd94c0 100644
--- a/src/library/scala/collection/mutable/SynchronizedSet.scala
+++ b/src/library/scala/collection/mutable/SynchronizedSet.scala
@@ -92,8 +92,8 @@ trait SynchronizedSet[A] extends Set[A] {
     super.toList
   }
 
-  override def toString() = synchronized {
-    super.toString()
+  override def toString = synchronized {
+    super.toString
   }
 
   override def <<(cmd: Message[A]): Unit = synchronized {
diff --git a/src/library/scala/collection/mutable/SynchronizedStack.scala b/src/library/scala/collection/mutable/SynchronizedStack.scala
index ffc1105fbd..28b21251a2 100644
--- a/src/library/scala/collection/mutable/SynchronizedStack.scala
+++ b/src/library/scala/collection/mutable/SynchronizedStack.scala
@@ -107,5 +107,5 @@ class SynchronizedStack[A] extends Stack[A] {
    *
    *  @return the string representation of this stack.
    */
-  override def toString() = synchronized { super.toString() }
+  override def toString = synchronized { super.toString }
 }
diff --git a/src/library/scala/runtime/RichString.scala b/src/library/scala/runtime/RichString.scala
index e5f275d71d..375e096631 100644
--- a/src/library/scala/runtime/RichString.scala
+++ b/src/library/scala/runtime/RichString.scala
@@ -20,7 +20,7 @@ final class RichString(val self: String) extends Proxy with Seq[Char] with Order
   def compare(other: String) = self compareTo other
 
   // Seq[Char]
-  def length = self.length()
+  def length = self.length
   def elements = Iterator.fromString(self)
 
   /** Retrieve the n-th character of the string
diff --git a/src/library/scala/testing/UnitTest.scala b/src/library/scala/testing/UnitTest.scala
index 10cade8a88..b6975a8e22 100644
--- a/src/library/scala/testing/UnitTest.scala
+++ b/src/library/scala/testing/UnitTest.scala
@@ -48,7 +48,7 @@ object UnitTest {
     if (actual.sameElements(expected))
       report.ok
     else
-      report.fail(actual.toString(), expected.toString())
+      report.fail(actual.toString, expected.toString)
 
   /**
    *  @param actual   ...
diff --git a/src/library/scala/util/automata/NondetWordAutom.scala b/src/library/scala/util/automata/NondetWordAutom.scala
index 660ebc1c99..4580706031 100644
--- a/src/library/scala/util/automata/NondetWordAutom.scala
+++ b/src/library/scala/util/automata/NondetWordAutom.scala
@@ -85,7 +85,7 @@ abstract class NondetWordAutom[T <: AnyRef] {
     x.toImmutable;
   }
 
-  override def toString() = {
+  override def toString = {
     val sb = new compat.StringBuilder()
     sb.append("[NondetWordAutom  nstates=")
     sb.append(nstates)
@@ -96,16 +96,16 @@ abstract class NondetWordAutom[T <: AnyRef] {
         map = map.update(j, finals(j));
       j = j + 1
     }
-    sb.append(map.toString())
+    sb.append(map.toString)
     sb.append("  delta=\n")
     for (val i <- 0 until nstates) {
       sb.append("    ")
       sb.append( i )
       sb.append("->")
-      sb.append(delta(i).toString())
+      sb.append(delta(i).toString)
       sb.append("\n    ")
       sb.append(" _>")
-      sb.append(default(i).toString())
+      sb.append(default(i).toString)
       sb.append('\n')
     }
     sb.toString()
diff --git a/src/library/scala/xml/MetaData.scala b/src/library/scala/xml/MetaData.scala
index b75e9a9e8b..8a98bc547c 100644
--- a/src/library/scala/xml/MetaData.scala
+++ b/src/library/scala/xml/MetaData.scala
@@ -26,7 +26,7 @@ import compat.StringBuilder
  * @todo _vlue should be a normalized attribute value
  */
 @serializable
-abstract class MetaData extends Iterable[MetaData] {
+abstract class MetaData extends Collection[MetaData] {
 
   /** appends given MetaData items to this MetaData list.
    *
@@ -111,6 +111,9 @@ abstract class MetaData extends Iterable[MetaData] {
       y
     }
   }
+  def size : Int = 1 + {
+    if (Null == next) 0 else next.size
+  }
 
   /** shallow equals method */
   def equals1(that: MetaData): Boolean
diff --git a/src/library/scala/xml/dtd/ElementValidator.scala b/src/library/scala/xml/dtd/ElementValidator.scala
index 645caa66eb..a841e5e76a 100644
--- a/src/library/scala/xml/dtd/ElementValidator.scala
+++ b/src/library/scala/xml/dtd/ElementValidator.scala
@@ -93,7 +93,7 @@ class ElementValidator() extends Function1[Node,Boolean] {
           exc = fromUndefinedAttribute( attr.key ) :: exc;
 
         case AttrDecl(_, tpe, DEFAULT(true, fixedValue)) if(attr.value != fixedValue) =>
-          exc = fromFixedAttribute( attr.key, fixedValue, attr.value.toString()) :: exc;
+          exc = fromFixedAttribute( attr.key, fixedValue, attr.value.toString) :: exc;
 
         case s =>
           //Console.println("s: "+s);