Merge remote-tracking branch 'origin/2.10.x' into merge/2.10.x-to-master

Conflicts:
	src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala

5 files changed, 44 insertions, 39 deletions

diff --git a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
index 6a09f9f07c..751f0bd95e 100644
--- a/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
+++ b/src/compiler/scala/tools/nsc/ast/parser/Parsers.scala
@@ -2802,6 +2802,8 @@ self =>
             case tdef @ TypeDef(mods, name, tparams, rhs) =>
               deprecationWarning(tdef.pos.point, "early type members are deprecated. Move them to the regular body: the semantics are the same.")
               List(treeCopy.TypeDef(tdef, mods | Flags.PRESUPER, name, tparams, rhs))
+            case docdef @ DocDef(comm, rhs) =>
+              List(treeCopy.DocDef(docdef, comm, rhs))
             case stat if !stat.isEmpty =>
               syntaxError(stat.pos, "only concrete field definitions allowed in early object initialization section", skipIt = false)
               List()
diff --git a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
index 56ec49e962..1c32721444 100644
--- a/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
+++ b/src/compiler/scala/tools/nsc/transform/ExtensionMethods.scala
@@ -230,9 +230,14 @@ abstract class ExtensionMethods extends Transform with TypingTransformers {
               .changeOwner(origMeth -> extensionMeth)
             new SubstututeRecursion(origMeth, extensionMeth, unit).transform(tree)
           }
+          val castBody =
+            if (extensionBody.tpe <:< extensionMono.finalResultType)
+              extensionBody
+            else
+              gen.mkCastPreservingAnnotations(extensionBody, extensionMono.finalResultType) // SI-7818 e.g. mismatched existential skolems        
 
           // Record the extension method. Later, in `Extender#transformStats`, these will be added to the companion object.
-          extensionDefs(companion) += atPos(tree.pos)(DefDef(extensionMeth, extensionBody))
+          extensionDefs(companion) += atPos(tree.pos)(DefDef(extensionMeth, castBody))
 
           // These three lines are assembling Foo.bar$extension[T1, T2, ...]($this)
           // which leaves the actual argument application for extensionCall.
diff --git a/src/library/scala/collection/mutable/MapLike.scala b/src/library/scala/collection/mutable/MapLike.scala
index dbe32fdb79..6230fc23aa 100644
--- a/src/library/scala/collection/mutable/MapLike.scala
+++ b/src/library/scala/collection/mutable/MapLike.scala
@@ -208,8 +208,8 @@ trait MapLike[A, B, +This <: MapLike[A, B, This] with Map[A, B]]
    * @param p  The test predicate
    */
   def retain(p: (A, B) => Boolean): this.type = {
-    for ((k, v) <- this.seq ; if !p(k, v))
-      this -= k
+    for ((k, v) <- this.toList) // SI-7269 toList avoids ConcurrentModificationException
+      if (!p(k, v)) this -= k
 
     this
   }
diff --git a/src/library/scala/collection/mutable/SetLike.scala b/src/library/scala/collection/mutable/SetLike.scala
index 073bc59f61..c7618fcf3c 100644
--- a/src/library/scala/collection/mutable/SetLike.scala
+++ b/src/library/scala/collection/mutable/SetLike.scala
@@ -121,7 +121,9 @@ trait SetLike[A, +This <: SetLike[A, This] with Set[A]]
    *             which `p` returns `true` are retained in the set; all others
    *             are removed.
    */
-  def retain(p: A => Boolean): Unit = for (elem <- this.toList) if (!p(elem)) this -= elem
+  def retain(p: A => Boolean): Unit =
+    for (elem <- this.toList) // SI-7269 toList avoids ConcurrentModificationException
+      if (!p(elem)) this -= elem
 
   /** Removes all elements from the set. After this operation is completed,
    *  the set will be empty.
diff --git a/src/library/scala/runtime/ScalaRunTime.scala b/src/library/scala/runtime/ScalaRunTime.scala
index 315f56bd4e..5fb24f2a36 100644
--- a/src/library/scala/runtime/ScalaRunTime.scala
+++ b/src/library/scala/runtime/ScalaRunTime.scala
@@ -32,21 +32,13 @@ object ScalaRunTime {
     clazz.isArray && (atLevel == 1 || isArrayClass(clazz.getComponentType, atLevel - 1))
 
   def isValueClass(clazz: jClass[_]) = clazz.isPrimitive()
-  def isTuple(x: Any) = x != null && tupleNames(x.getClass.getName)
+
+  // includes specialized subclasses and future proofed against hypothetical TupleN (for N > 22)
+  def isTuple(x: Any) = x != null && x.getClass.getName.startsWith("scala.Tuple")
   def isAnyVal(x: Any) = x match {
     case _: Byte | _: Short | _: Char | _: Int | _: Long | _: Float | _: Double | _: Boolean | _: Unit => true
     case _                                                                                             => false
   }
-  // Avoiding boxing which messes up the specialized tests.  Don't ask.
-  private val tupleNames = {
-    var i = 22
-    var names: List[String] = Nil
-    while (i >= 1) {
-      names ::= ("scala.Tuple" + String.valueOf(i))
-      i -= 1
-    }
-    names.toSet
-  }
 
   // A helper method to make my life in the pattern matcher a lot easier.
   def drop[Repr](coll: Repr, num: Int)(implicit traversable: IsTraversableLike[Repr]): Repr =
@@ -77,33 +69,37 @@ object ScalaRunTime {
     classTag[T].runtimeClass.asInstanceOf[jClass[T]]
 
   /** Retrieve generic array element */
-  def array_apply(xs: AnyRef, idx: Int): Any = xs match {
-    case x: Array[AnyRef]  => x(idx).asInstanceOf[Any]
-    case x: Array[Int]     => x(idx).asInstanceOf[Any]
-    case x: Array[Double]  => x(idx).asInstanceOf[Any]
-    case x: Array[Long]    => x(idx).asInstanceOf[Any]
-    case x: Array[Float]   => x(idx).asInstanceOf[Any]
-    case x: Array[Char]    => x(idx).asInstanceOf[Any]
-    case x: Array[Byte]    => x(idx).asInstanceOf[Any]
-    case x: Array[Short]   => x(idx).asInstanceOf[Any]
-    case x: Array[Boolean] => x(idx).asInstanceOf[Any]
-    case x: Array[Unit]    => x(idx).asInstanceOf[Any]
-    case null => throw new NullPointerException
+  def array_apply(xs: AnyRef, idx: Int): Any = {
+    xs match {
+      case x: Array[AnyRef]  => x(idx).asInstanceOf[Any]
+      case x: Array[Int]     => x(idx).asInstanceOf[Any]
+      case x: Array[Double]  => x(idx).asInstanceOf[Any]
+      case x: Array[Long]    => x(idx).asInstanceOf[Any]
+      case x: Array[Float]   => x(idx).asInstanceOf[Any]
+      case x: Array[Char]    => x(idx).asInstanceOf[Any]
+      case x: Array[Byte]    => x(idx).asInstanceOf[Any]
+      case x: Array[Short]   => x(idx).asInstanceOf[Any]
+      case x: Array[Boolean] => x(idx).asInstanceOf[Any]
+      case x: Array[Unit]    => x(idx).asInstanceOf[Any]
+      case null => throw new NullPointerException
+    }
   }
 
   /** update generic array element */
-  def array_update(xs: AnyRef, idx: Int, value: Any): Unit = xs match {
-    case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
-    case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
-    case x: Array[Double]  => x(idx) = value.asInstanceOf[Double]
-    case x: Array[Long]    => x(idx) = value.asInstanceOf[Long]
-    case x: Array[Float]   => x(idx) = value.asInstanceOf[Float]
-    case x: Array[Char]    => x(idx) = value.asInstanceOf[Char]
-    case x: Array[Byte]    => x(idx) = value.asInstanceOf[Byte]
-    case x: Array[Short]   => x(idx) = value.asInstanceOf[Short]
-    case x: Array[Boolean] => x(idx) = value.asInstanceOf[Boolean]
-    case x: Array[Unit]    => x(idx) = value.asInstanceOf[Unit]
-    case null => throw new NullPointerException
+  def array_update(xs: AnyRef, idx: Int, value: Any): Unit = {
+    xs match {
+      case x: Array[AnyRef]  => x(idx) = value.asInstanceOf[AnyRef]
+      case x: Array[Int]     => x(idx) = value.asInstanceOf[Int]
+      case x: Array[Double]  => x(idx) = value.asInstanceOf[Double]
+      case x: Array[Long]    => x(idx) = value.asInstanceOf[Long]
+      case x: Array[Float]   => x(idx) = value.asInstanceOf[Float]
+      case x: Array[Char]    => x(idx) = value.asInstanceOf[Char]
+      case x: Array[Byte]    => x(idx) = value.asInstanceOf[Byte]
+      case x: Array[Short]   => x(idx) = value.asInstanceOf[Short]
+      case x: Array[Boolean] => x(idx) = value.asInstanceOf[Boolean]
+      case x: Array[Unit]    => x(idx) = value.asInstanceOf[Unit]
+      case null => throw new NullPointerException
+    }
   }
 
   /** Get generic array length */