Refactor proxies: IterableProxy, SeqProxy, Rand...

Refactor proxies: IterableProxy, SeqProxy, RandomAccessSeqProxy,
MapProxy: not all methods were proxied previously; proxy methods are now
declared in the same order as in proxied traits (to make maintaining
easier)

4 files changed, 120 insertions, 43 deletions

diff --git a/src/library/scala/IterableProxy.scala b/src/library/scala/IterableProxy.scala
index 361113a7a4..ee86728647 100644
--- a/src/library/scala/IterableProxy.scala
+++ b/src/library/scala/IterableProxy.scala
@@ -24,31 +24,56 @@ import scala.collection.mutable.Buffer
 trait IterableProxy[+A] extends Iterable[A] with Proxy {
 
   override def self: Iterable[A]
-  override def elements: Iterator[A] = self.elements
+
+  override def elements = self.elements
   @deprecated
-  override def concat [B >: A](that: Iterable[B]): Collection[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): Collection[A] = self dropWhile p
-  @deprecated override def take(n: Int): Collection[A] = self take n
-  @deprecated 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
-  override def find(p: A => Boolean): Option[A] = self find p
-  override def findIndexOf(p: A => Boolean): Int = self findIndexOf p
-  override def indexOf[B >: A](elem: B): Int = self indexOf elem
-  override def foldLeft[B](z: B)(op: (B, A) => B): B = (self foldLeft z)(op)
-  override def foldRight[B](z: B)(op: (A, B) => B): B = (self foldRight z)(op)
-  override def /:[B](z: B)(op: (B, A) => B): B = (z /: self)(op)
-  override def :\[B](z: B)(op: (A, B) => B): B = (self :\ z)(op)
-  override def reduceLeft[B >: A](op: (B, A) => B): B = self reduceLeft op
-  override def reduceRight[B >: A](op: (A, B) => B): B = self reduceRight op
-  override def sameElements[B >: A](that: Iterable[B]): Boolean = self sameElements that
-  override def copyToBuffer[B >: A](dest: Buffer[B]): Unit = self copyToBuffer dest
-  override def toList: List[A] = self.toList
-  override def mkString(start: String, sep: String, end: String): String = self.mkString(start, sep, end)
-  override def addString(buf: StringBuilder, start: String, sep: String, end: String): StringBuilder = self.addString(buf, start, sep, end)
+  override def concat [B >: A](that: Iterable[B]) = self concat that
+  override def ++[B >: A](that: Iterable[B]) = self ++ that
+  override def map[B](f: A => B) = self map f
+  override def flatMap[B](f: A => Iterable[B]) = self flatMap f
+  override def filter(p: A => Boolean) = self filter p
+  override def partition(p: A => Boolean) = self partition p
+  override def takeWhile(p: A => Boolean) = self takeWhile p
+  override def dropWhile(p: A => Boolean) = self dropWhile p
+  @deprecated override def take(n: Int) = self take n
+  @deprecated override def drop(n: Int) = self drop n
+  override def foreach(f: A => Unit) = self foreach f
+  override def forall(p: A => Boolean) = self forall p
+  override def exists(p: A => Boolean) = self exists p
+  override def find(p: A => Boolean) = self find p
+  @deprecated override def findIndexOf(p: A => Boolean) = self findIndexOf p
+  @deprecated override def indexOf[B >: A](elem: B): Int = self indexOf elem
+  override def foldLeft[B](z: B)(op: (B, A) => B) = (self foldLeft z)(op)
+  override def foldRight[B](z: B)(op: (A, B) => B) = (self foldRight z)(op)
+  override def /:[B](z: B)(op: (B, A) => B) = (z /: self)(op)
+  override def :\[B](z: B)(op: (A, B) => B) = (self :\ z)(op)
+  override def reduceLeft[B >: A](op: (B, A) => B) = self reduceLeft op
+  override def reduceRight[B >: A](op: (A, B) => B) = self reduceRight op
+  override def copyToBuffer[B >: A](dest: Buffer[B]) = self copyToBuffer dest
+  override def sameElements[B >: A](that: Iterable[B]) = self sameElements that
+
+  override def toList = self.toList
+  override def toSeq = self.toSeq
+  override def toStream = self.toStream
+
+  override def mkString(start: String, sep: String, end: String) = self.mkString(start, sep, end)
+  override def mkString(sep: String) = self.mkString(sep)
+  override def mkString = self.mkString
+
+  override def addString(buf: StringBuilder, start: String, sep: String, end: String) =
+    self.addString(buf, start, sep, end)
+
+  override def addString(buf: StringBuilder, sep: String) =
+    self.addString(buf, sep)
+
+  override def addString(buf: StringBuilder) =
+    self.addString(buf)
+
+  override def copyToArray[B >: A](xs: Array[B], start: Int) = self.copyToArray(xs, start)
+
+  override def isEmpty = self.isEmpty
+
+  override def projection = self.projection
+
+  override def hasDefiniteSize = self.hasDefiniteSize
 }
diff --git a/src/library/scala/RandomAccessSeqProxy.scala b/src/library/scala/RandomAccessSeqProxy.scala
index a5fb245f97..2a6245ebb0 100644
--- a/src/library/scala/RandomAccessSeqProxy.scala
+++ b/src/library/scala/RandomAccessSeqProxy.scala
@@ -20,12 +20,16 @@ package scala
 trait RandomAccessSeqProxy[+A] extends RandomAccessSeq[A] with SeqProxy[A] {
   override def self: RandomAccessSeq[A]
 
+  override def projection = self.projection
+
   override def drop(from: Int): RandomAccessSeq[A] = self.drop(from)
   override def take(until: Int): RandomAccessSeq[A] = self.take(until)
   override def slice(from: Int, until: Int) : RandomAccessSeq[A] = self.slice(from, until)
+  override def reverse = self.reverse
   override def partition(p: A => Boolean): (RandomAccessSeq[A], RandomAccessSeq[A]) =
     self.partition(p)
-  // XXX: def patch, reverse, should not return projection
+  override def patch[B >: A](from0: Int, patch0: RandomAccessSeq[B], replaced0: Int) =
+    self.patch(from0, patch0, replaced0)
   override def ++[B >: A](that: Iterable[B]): RandomAccessSeq[B] = self ++ that
   override def toStream: Stream[A] = self.toStream
 }
diff --git a/src/library/scala/SeqProxy.scala b/src/library/scala/SeqProxy.scala
index b9385139fa..deb046b902 100644
--- a/src/library/scala/SeqProxy.scala
+++ b/src/library/scala/SeqProxy.scala
@@ -19,27 +19,67 @@ package scala
  *  @author  Matthias Zenger
  *  @version 2.0, 31/12/2006
  */
-trait SeqProxy[+A] extends Seq[A] with IterableProxy[A] {
+trait SeqProxy[+A] extends Seq[A] with CollectionProxy[A] {
 
   override def self: Seq[A]
 
+  // PartialFunction delegates
+
   override def apply(i: Int): A = self(i)
+
+  // Seq delegates
+  // Seq methods could be printed by  cat Seq.scala | sed -n '/trait Seq/,$ p' | egrep '^  (override )?def'
+
   override def length: Int = self.length
-  override def isEmpty: Boolean = self.isEmpty
+  override def lengthCompare(l: Int) = self lengthCompare l
+  override def size = self.size
+  override def isEmpty = self.isEmpty
   @deprecated
   override def concat [B >: A](that: Iterable[B]): Seq[B] = self concat that
+  override def last = self.last
+  override def lastOption = self.lastOption
+  override def first = self.first
+  override def firstOption = self.firstOption
+  override def headOption = self.headOption
+
+  override def ++ [B >: A](that: Iterable[B]) = self ++ that
   override def isDefinedAt(x: Int): Boolean = self isDefinedAt x
+
   override def lastIndexOf[B >: A](elem: B): Int = self lastIndexOf elem
+  override def findIndexOf(p: A => Boolean): Int = self findIndexOf p
+
+  override def indexOf[B >: A](elem: B): Int = self indexOf elem
+
   override def map[B](f: A => B): Seq[B] = self map f
-  override def flatMap[B](f: A => Iterable[B]): Seq[B] = self flatMap f
+  override def flatMap[B](f: A => Iterable[B]) = self flatMap f
   override def filter(p: A => Boolean): Seq[A] = self filter p
   override def take(n: Int): Seq[A] = self take n
   override def drop(n: Int): Seq[A] = self drop n
+
+  override def slice(from: Int, len: Int): Seq[A] = self.slice(from, len)
+  override def slice(from: Int) = self slice from
+
   override def takeWhile(p: A => Boolean): Seq[A] = self takeWhile p
   override def dropWhile(p: A => Boolean): Seq[A] = self dropWhile p
+
   override def reverse: Seq[A] = self.reverse
+
   override def contains(elem: Any): Boolean = self contains elem
-  override def slice(from: Int, len: Int): Seq[A] = self.slice(from, len)
+
+  override def subseq(from: Int, end: Int) = self.subseq(from, end)
+
   override def toArray[B >: A]: Array[B] = self.toArray
-  override def copyToArray[B >: A](xs: Array[B], start: Int): Unit = self.copyToArray(xs, start)
+
+  override def toSeq = self.toSeq
+
+  override def projection = self.projection
+
+  override def equalsWith[B](that: Seq[B])(f: (A, B) => Boolean): Boolean = self.equalsWith(that)(f)
+
+  override def startsWith[B](that: Seq[B]) = self startsWith that
+  override def endsWith[B](that: Seq[B]) = self endsWith that
+
+  override def indexOf[B >: A](that: Seq[B]) = self indexOf that
+
+  override def containsSlice[B](that: Seq[B]) = self containsSlice that
 }
diff --git a/src/library/scala/collection/MapProxy.scala b/src/library/scala/collection/MapProxy.scala
index 617c3bc79a..6de1e30f15 100644
--- a/src/library/scala/collection/MapProxy.scala
+++ b/src/library/scala/collection/MapProxy.scala
@@ -20,18 +20,26 @@ package scala.collection
  *  @author  Matthias Zenger
  *  @version 1.0, 21/07/2003
  */
-trait MapProxy[A, +B] extends Map[A, B] with IterableProxy[(A, B)] {
+trait MapProxy[A, +B] extends Map[A, B] with CollectionProxy[(A, B)] {
 
-  def self: Map[A, B]
+  override def self: Map[A, B]
 
-  override def size: Int = self.size
-  override def get(key: A): Option[B] = self.get(key)
-  override def isEmpty: Boolean = self.isEmpty
-  override def apply(key: A): B = self.apply(key)
-  override def contains(key: A): Boolean = self.contains(key)
+  override def size = self.size
+  override def get(key: A) = self.get(key)
+  override def getOrElse[B2 >: B](key: A, default: => B2) = self.getOrElse(key, default)
+
+  override def isEmpty = self.isEmpty
+  override def apply(key: A) = self.apply(key)
+  override def contains(key: A) = self.contains(key)
   override def isDefinedAt(key: A) = self.isDefinedAt(key)
-  override def keys: Iterator[A] = self.keys
-  override def keySet: Set[A] = self.keySet
-  override def values: Iterator[B] = self.values
-  override def default(key: A): B = self.default(key)
+  override def keys = self.keys
+  override def keySet = self.keySet
+  override def values = self.values
+  override def equals(that: Any) = self equals that
+  override def hashCode() = self.hashCode()
+  override def toString() = self.toString()
+  override def default(key: A) = self.default(key)
+  override def projection = self.projection
+  override def filterKeys(p: A => Boolean) = self filterKeys p
+  override def mapElements[C](f: B => C) = self mapElements f
 }