renamed BuilderFactory[El, To, From] -> CanBuil...

renamed BuilderFactory[El, To, From] -> CanBuildFrom[From, El, To] and
added apply() overload to create collections from scratch generically

added def apply() overload to BuilderFactory so that we can also create collections from scratch generically
(see test test/files/pos/collectGenericCC.scala)

renaming:
- BuilderFactory[El, To, From] -> CanBuildFrom[From, El, To]
    bulk type-param reordering using: s/CanBuildFrom\[\s*([^,()\s]*)\s*,(\s+[^\s,()]*)\s*,\s+([^\s,()]*)\s*\]/CanBuildFrom[$3, $1,$2]/
    some argument lists got mixed up because they contained 4 comma's...
- builderFactory -> canBuildFrom

removed explicit implicit value in DocDriver that was
renamed renamed collection/generic/BuilderFactory.scala ->
collection/generic/CanBuildFrom.scala

tested with clean build using ant strap.done -- everything went well on my machine

1 files changed, 6 insertions, 6 deletions

diff --git a/src/library/scala/collection/TraversableViewLike.scala b/src/library/scala/collection/TraversableViewLike.scala
index 9303e473fd..2f33776b74 100644
--- a/src/library/scala/collection/TraversableViewLike.scala
+++ b/src/library/scala/collection/TraversableViewLike.scala
@@ -24,7 +24,7 @@ import TraversableView.NoBuilder
  *  @note Methods such as map/flatMap on this will not invoke the implicitly passed
  *        Builder factory, but will return a new view directly, to preserve by-name behavior.
  *        The new view is then cast to the factory's result type.
- *        This means that every BuilderFactory that takes a
+ *        This means that every CanBuildFrom 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.
  *
@@ -42,7 +42,7 @@ self =>
 
   protected def underlying: Coll
 
-  def force[B >: A, That](implicit bf: BuilderFactory[B, That, Coll]) = {
+  def force[B >: A, That](implicit bf: CanBuildFrom[Coll, B, That]) = {
     val b = bf(underlying)
     b ++= this
     b.result()
@@ -143,23 +143,23 @@ self =>
   protected def newDroppedWhile(p: A => Boolean): Transformed[A] = new DroppedWhile { val pred = p }
   protected def newTakenWhile(p: A => Boolean): Transformed[A] = new TakenWhile { val pred = p }
 
-  override def ++[B >: A, That](that: Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = {
+  override def ++[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[This, B, That]): That = {
     newAppended(that).asInstanceOf[That]
 // was:    val b = bf(repr)
 //     if (b.isInstanceOf[NoBuilder[_]]) newAppended(that).asInstanceOf[That]
 //    else super.++[B, That](that)(bf)
   }
 
-  override def ++[B >: A, That](that: Iterator[B])(implicit bf: BuilderFactory[B, That, This]): That = ++[B, That](that.toStream)
+  override def ++[B >: A, That](that: Iterator[B])(implicit bf: CanBuildFrom[This, B, That]): That = ++[B, That](that.toStream)
 
-  override def map[B, That](f: A => B)(implicit bf: BuilderFactory[B, That, This]): That = {
+  override def map[B, That](f: A => B)(implicit bf: CanBuildFrom[This, B, That]): That = {
     newMapped(f).asInstanceOf[That]
 // was:        val b = bf(repr)
 //          if (b.isInstanceOf[NoBuilder[_]]) newMapped(f).asInstanceOf[That]
 //    else super.map[B, That](f)(bf)
   }
 
-  override def flatMap[B, That](f: A => Traversable[B])(implicit bf: BuilderFactory[B, That, This]): That = {
+  override def flatMap[B, That](f: A => Traversable[B])(implicit bf: CanBuildFrom[This, B, That]): That = {
     newFlatMapped(f).asInstanceOf[That]
 // was:    val b = bf(repr)
 //     if (b.isInstanceOf[NoBuilder[_]]) newFlatMapped(f).asInstanceOf[That]