Merge branch 2.10.1 into master

Conflicts:
	src/compiler/scala/tools/nsc/ast/Trees.scala
	src/library/scala/concurrent/impl/ExecutionContextImpl.scala

3 files changed, 17 insertions, 17 deletions

diff --git a/src/library/scala/collection/Iterator.scala b/src/library/scala/collection/Iterator.scala
index 77baad71d3..43db7c55e0 100644
--- a/src/library/scala/collection/Iterator.scala
+++ b/src/library/scala/collection/Iterator.scala
@@ -1109,7 +1109,7 @@ trait Iterator[+A] extends TraversableOnce[A] {
    *    $willNotTerminateInf
    */
   def copyToArray[B >: A](xs: Array[B], start: Int, len: Int): Unit = {
-    require(start >= 0 && start < xs.length, s"start $start out of range ${xs.length}")
+    require(start >= 0 && (start < xs.length || xs.length == 0), s"start $start out of range ${xs.length}")
     var i = start
     val end = start + math.min(len, xs.length - start)
     while (i < end && hasNext) {
diff --git a/src/library/scala/concurrent/impl/ExecutionContextImpl.scala b/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
index 77625e381c..e4a0f464f9 100644
--- a/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
+++ b/src/library/scala/concurrent/impl/ExecutionContextImpl.scala
@@ -19,16 +19,16 @@ import scala.util.control.NonFatal
 
 
 private[scala] class ExecutionContextImpl private[impl] (es: Executor, reporter: Throwable => Unit) extends ExecutionContextExecutor {
+  // Placed here since the creation of the executor needs to read this val
+  private[this] val uncaughtExceptionHandler: Thread.UncaughtExceptionHandler = new Thread.UncaughtExceptionHandler {
+    def uncaughtException(thread: Thread, cause: Throwable): Unit = reporter(cause)
+  }
 
   val executor: Executor = es match {
     case null => createExecutorService
     case some => some
   }
 
-  private val uncaughtExceptionHandler: Thread.UncaughtExceptionHandler = new Thread.UncaughtExceptionHandler {
-    def uncaughtException(thread: Thread, cause: Throwable): Unit = reporter(cause)
-  }
-
   // Implement BlockContext on FJP threads
   class DefaultThreadFactory(daemonic: Boolean) extends ThreadFactory with ForkJoinPool.ForkJoinWorkerThreadFactory { 
     def wire[T <: Thread](thread: T): T = {
@@ -116,18 +116,18 @@ private[scala] class ExecutionContextImpl private[impl] (es: Executor, reporter:
 private[concurrent] object ExecutionContextImpl {
 
   final class AdaptedForkJoinTask(runnable: Runnable) extends ForkJoinTask[Unit] {
-    final override def setRawResult(u: Unit): Unit = ()
-    final override def getRawResult(): Unit = ()
-    final override def exec(): Boolean = try { runnable.run(); true } catch {
-      case anything: Throwable ⇒
-        val t = Thread.currentThread
-        t.getUncaughtExceptionHandler match {
-          case null ⇒ 
-          case some ⇒ some.uncaughtException(t, anything)
+          final override def setRawResult(u: Unit): Unit = ()
+          final override def getRawResult(): Unit = ()
+          final override def exec(): Boolean = try { runnable.run(); true } catch {
+            case anything: Throwable ⇒
+              val t = Thread.currentThread
+              t.getUncaughtExceptionHandler match {
+                case null ⇒
+                case some ⇒ some.uncaughtException(t, anything)
+              }
+              throw anything
+          }
         }
-        throw anything
-    }
-  }
 
   def fromExecutor(e: Executor, reporter: Throwable => Unit = ExecutionContext.defaultReporter): ExecutionContextImpl = new ExecutionContextImpl(e, reporter)
   def fromExecutorService(es: ExecutorService, reporter: Throwable => Unit = ExecutionContext.defaultReporter): ExecutionContextImpl with ExecutionContextExecutorService =
diff --git a/src/library/scala/xml/Utility.scala b/src/library/scala/xml/Utility.scala
index 06fd46701a..fff27c6e30 100755
--- a/src/library/scala/xml/Utility.scala
+++ b/src/library/scala/xml/Utility.scala
@@ -64,7 +64,7 @@ object Utility extends AnyRef with parsing.TokenTests {
     val key = md.key
     val smaller = sort(md.filter { m => m.key < key })
     val greater = sort(md.filter { m => m.key > key })
-    smaller.copy(md.copy ( greater ))
+    smaller.foldRight (md copy greater) ((x, xs) => x copy xs)
   }
 
   /** Return the node with its attribute list sorted alphabetically