Update Scala version to latest nightly

- Remove extensibility framework (fixes scala#5)
- Remove `ImmutableMapDecorator` and `MutableMapDecorator`, because
  `updatedWith` and `updateWith` have been merged upstream

Author: julienrf

build.sbt

@@ -1,6 +1,8 @@
 // TODO Make it a cross project including Scala.js
 
-scalaVersion := "2.13.0-M4"
+resolvers += "scala-integration" at "https://scala-ci.typesafe.com/artifactory/scala-integration/"
+
+scalaVersion := "2.13.0-pre-370f5c8"
 
 organization := "org.scala-lang"
 

src/main/scala/scala/collection/MultiDict.scala

@@ -16,7 +16,7 @@ trait MultiDict[K, V]
 
   def multiMapFactory: MapFactory[MultiDictCC] = MultiDict
 
-  override protected[this] def fromSpecificIterable(coll: Iterable[(K, V)]): MultiDictCC[K, V] = multiMapFactory.from(coll)
+  override protected[this] def fromSpecific(coll: IterableOnce[(K, V)]): MultiDictCC[K, V] = multiMapFactory.from(coll)
   override protected[this] def newSpecificBuilder: mutable.Builder[(K, V), MultiDictCC[K, V]] = multiMapFactory.newBuilder[K, V]
 
   def canEqual(that: Any): Boolean = true
@@ -51,7 +51,7 @@ trait MultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K, V]]
     multiMapFactory.from(it)
 
   protected[this] def fromSpecificSets(it: Iterable[(K, Set[V])]): C =
-    fromSpecificIterable(it.view.flatMap { case (k, vs) => vs.view.map(v => (k, v)) })
+    fromSpecific(it.view.flatMap { case (k, vs) => vs.view.map(v => (k, v)) })
 
   protected[this] def fromSets[L, W](it: Iterable[(L, Set[W])]): CC[L, W] =
     multiMapFromIterable(it.view.flatMap { case (k, vs) => vs.view.map(v => (k, v)) })
@@ -133,8 +133,10 @@ trait MultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K, V]]
     )
 
   /** Concatenate the entries given in `that` iterable to `this` multidict */
-  def concat(that: Iterable[(K, V)]): C =
-    fromSpecificIterable(new View.Concat(toIterable, that))
+  def concat(that: IterableOnce[(K, V)]): C = fromSpecific(that match {
+    case that: collection.Iterable[(K, V)] => new View.Concat(toIterable, that)
+    case _ => iterator ++ that.iterator
+  })
 
   override def withFilter(p: ((K, V)) => Boolean): MultiDictOps.WithFilter[K, V, IterableCC, CC] =
     new MultiDictOps.WithFilter(this, p)

src/main/scala/scala/collection/MultiSet.scala

@@ -36,11 +36,11 @@ trait MultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
   extends IterableOps[A, CC, C] {
 
   protected[this] def fromSpecificOccurrences(it: Iterable[(A, Int)]): C =
-    fromSpecificIterable(it.view.flatMap { case (e, n) => new View.Fill(n)(e) })
+    fromSpecific(it.view.flatMap { case (e, n) => new View.Fill(n)(e) })
 
   protected[this] def fromOccurrences[E](it: Iterable[(E, Int)]): CC[E] =
     // Note new MultiSet(it.to(Map)) would be more efficient but would also loose duplicates
-    fromIterable(it.view.flatMap { case (e, n) => new View.Fill(n)(e) })
+    iterableFactory.from(it.view.flatMap { case (e, n) => new View.Fill(n)(e) })
 
   /**
     * @return All the elements contained in this multiset and their number of occurrences
@@ -68,8 +68,10 @@ trait MultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
     *
     * @param that the collection of elements to add to this multiset
     */
-  def concat(that: Iterable[A]): C =
-    fromSpecificIterable(new View.Concat(toIterable, that))
+  def concat(that: IterableOnce[A]): C = fromSpecific(that match {
+    case that: collection.Iterable[A] => new View.Concat(this, that)
+    case _ => iterator.concat(that.iterator)
+  })
 
   /**
     * @return a new multiset summing the occurrences of this multiset

src/main/scala/scala/collection/SortedMultiDict.scala

@@ -13,7 +13,7 @@ trait SortedMultiDict[K, V]
 
   def unsorted: MultiDict[K, V] = this
 
-  override protected[this] def fromSpecificIterable(coll: Iterable[(K, V)]): SortedMultiDictCC[K, V] = sortedMultiMapFactory.from(coll)
+  override protected[this] def fromSpecific(coll: IterableOnce[(K, V)]): SortedMultiDictCC[K, V] = sortedMultiMapFactory.from(coll)
   override protected[this] def newSpecificBuilder: mutable.Builder[(K, V), SortedMultiDictCC[K, V]] = sortedMultiMapFactory.newBuilder[K, V]
 }
 

src/main/scala/scala/collection/SortedMultiSet.scala

@@ -12,7 +12,7 @@ trait SortedMultiSet[A]
 
   def unsorted: MultiSet[A] = this
 
-  override protected[this] def fromSpecificIterable(coll: Iterable[A]): SortedIterableCC[A] = sortedIterableFactory.from(coll)
+  override protected[this] def fromSpecific(coll: IterableOnce[A]): SortedIterableCC[A] = sortedIterableFactory.from(coll)
   override protected[this] def newSpecificBuilder: mutable.Builder[A, SortedIterableCC[A]] = sortedIterableFactory.newBuilder[A]
 
   protected[this] def sortedFromIterable[B : Ordering](it: scala.collection.Iterable[B]): SortedIterableCC[B] = sortedIterableFactory.from(it)
@@ -165,7 +165,7 @@ object SortedMultiSetOps {
   class WithFilter[A, +IterableCC[_], +CC[X] <: MultiSet[X]](
     `this`: SortedMultiSetOps[A, CC, _] with IterableOps[A, IterableCC, _],
     p: A => Boolean
-  ) extends IterableOps.WithFilter(`this`, p) {
+  ) extends IterableOps.WithFilter[A, IterableCC](`this`, p) {
 
     def map[B : Ordering](f: A => B): CC[B] =
       `this`.sortedIterableFactory.from(new View.Map(filtered, f))

src/main/scala/scala/collection/decorators/HasImmutableMapOps.scala

@@ -2,7 +2,9 @@ package scala
 package collection
 package decorators
 
-class IterableDecorator[C, I <: HasIterableOps[C]](coll: C)(implicit val it: I) {
+import scala.collection.generic.IsIterable
+
+class IterableDecorator[C, I <: IsIterable[C]](coll: C)(implicit val it: I) {
 
   /**
     * Left to right fold that stops if the combination function `op`

src/main/scala/scala/collection/decorators/HasIterableOps.scala

@@ -1,7 +1,9 @@
 package scala.collection
 package decorators
 
-class MapDecorator[C, M <: HasMapOps[C]](coll: C)(implicit val map: M) {
+import scala.collection.generic.IsMap
+
+class MapDecorator[C, M <: IsMap[C]](coll: C)(implicit val map: M) {
 
   /**
     * Combines entries of `this` Map with entries of `that` Map that have the same key,