fix warnings. avoid IterableOnce deprecated methods

Author: xuwei-k

src/library/scala/collection/immutable/LazyList.scala

@@ -351,7 +351,7 @@ final class LazyList[+A] private(private[this] var lazyState: () => LazyList.Sta
 
   override def prependedAll[B >: A](prefix: scala.IterableOnce[B]): LazyList[B] =
     newLL {
-      if (prefix.isEmpty) state
+      if (prefix.iterator.isEmpty) state
       else stateFromIteratorConcatSuffix(prefix.iterator)(state)
     }
 
@@ -396,7 +396,7 @@ final class LazyList[+A] private(private[this] var lazyState: () => LazyList.Sta
 
   override def zip[B](that: collection.IterableOnce[B]): LazyList[(A, B)] =
     newLL {
-      if (this.isEmpty || that.isEmpty) State.Empty
+      if (this.isEmpty || that.iterator.isEmpty) State.Empty
       else {
         val thatIterable = that match {
           case that: collection.Iterable[B] => that

src/library/scala/collection/immutable/Vector.scala

@@ -176,7 +176,7 @@ final class Vector[+A] private[immutable] (private[collection] val startIndex: I
   // appendAll (suboptimal but avoids worst performance gotchas)
   override def appendedAll[B >: A](suffix: collection.IterableOnce[B]): Vector[B] = {
     import Vector.{Log2ConcatFaster, TinyAppendFaster}
-    if (suffix.isEmpty) this
+    if (suffix.iterator.isEmpty) this
     else {
       suffix match {
         case suffix: collection.Iterable[B] =>
@@ -202,12 +202,12 @@ final class Vector[+A] private[immutable] (private[collection] val startIndex: I
     // Implementation similar to `appendAll`: when of the collections to concatenate (either `this` or `prefix`)
     // has a small number of elements compared to the other, then we add them using `:+` or `+:` in a loop
     import Vector.{Log2ConcatFaster, TinyAppendFaster}
-    if (prefix.isEmpty) this
+    if (prefix.iterator.isEmpty) this
     else {
-      prefix.size match {
+      prefix.iterator.size match {
         case n if n <= TinyAppendFaster || n < (this.size >>> Log2ConcatFaster) =>
           var v: Vector[B] = this
-          val it = prefix.toIndexedSeq.reverseIterator
+          val it = prefix.iterator.toIndexedSeq.reverseIterator
           while (it.hasNext) v = it.next() +: v
           v
         case n if this.size < (n >>> Log2ConcatFaster) && prefix.isInstanceOf[Vector[_]] =>

src/library/scala/collection/mutable/AnyRefMap.scala

@@ -79,7 +79,7 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K => V, initi
     var sz = coll.knownSize
     if(sz < 0) sz = 4
     val arm = new AnyRefMap[K, V](sz * 2)
-    coll.foreach{ case (k,v) => arm(k) = v }
+    coll.iterator.foreach{ case (k,v) => arm(k) = v }
     if (arm.size < (sz>>3)) arm.repack()
     arm
   }
@@ -375,7 +375,7 @@ class AnyRefMap[K <: AnyRef, V] private[collection] (defaultEntry: K => V, initi
 
   override def concat[V2 >: V](xs: scala.collection.IterableOnce[(K, V2)]): AnyRefMap[K, V2] = {
     val arm = clone().asInstanceOf[AnyRefMap[K, V2]]
-    xs.foreach(kv => arm += kv)
+    xs.iterator.foreach(kv => arm += kv)
     arm
   }
 

src/library/scala/collection/mutable/LongMap.scala

@@ -446,7 +446,7 @@ final class LongMap[V] private[collection] (defaultEntry: Long => V, initialBuff
 
   override def concat[V1 >: V](xs: scala.collection.IterableOnce[(Long, V1)]): LongMap[V1] = {
     val lm = clone().asInstanceOf[LongMap[V1]]
-    xs.foreach(kv => lm += kv)
+    xs.iterator.foreach(kv => lm += kv)
     lm
   }
 

src/library/scala/concurrent/Future.scala

@@ -688,7 +688,7 @@ object Future {
    * @return          the `Future` of the resulting collection
    */
   final def sequence[A, CC[X] <: IterableOnce[X], To](in: CC[Future[A]])(implicit bf: BuildFrom[CC[Future[A]], A, To], executor: ExecutionContext): Future[To] =
-    in.foldLeft(successful(bf.newBuilder(in))) {
+    in.iterator.foldLeft(successful(bf.newBuilder(in))) {
       (fr, fa) => fr.zipWith(fa)(Future.addToBuilderFun)
     }.map(_.result())(InternalCallbackExecutor)
 
@@ -700,7 +700,7 @@ object Future {
    * @return          the `Future` holding the result of the future that is first to be completed
    */
   final def firstCompletedOf[T](futures: IterableOnce[Future[T]])(implicit executor: ExecutionContext): Future[T] =
-    if (futures.isEmpty) Future.never
+    if (futures.iterator.isEmpty) Future.never
     else {
       val p = Promise[T]()
       val firstCompleteHandler = new AtomicReference[Promise[T]](p) with (Try[T] => Unit) {
@@ -837,7 +837,7 @@ object Future {
    * @return          the `Future` of the `IterableOnce` of results
    */
   final def traverse[A, B, M[X] <: IterableOnce[X]](in: M[A])(fn: A => Future[B])(implicit bf: BuildFrom[M[A], B, M[B]], executor: ExecutionContext): Future[M[B]] =
-    in.foldLeft(successful(bf.newBuilder(in))) {
+    in.iterator.foldLeft(successful(bf.newBuilder(in))) {
       (fr, a) => fr.zipWith(fn(a))(Future.addToBuilderFun)
     }.map(_.result())(InternalCallbackExecutor)