Update scalaVersion to 2.13.0-M4

Author: julienrf

build.sbt

@@ -1,6 +1,6 @@
 // TODO Make it a cross project when Scala.js is released for 2.13.0-M4
 
-scalaVersion := "2.13.0-M4-pre-20d3c21"
+scalaVersion := "2.13.0-M4"
 
 organization := "org.scala-lang"
 

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

@@ -1,6 +1,7 @@
 package scala.collection
 
 import annotation.unchecked.uncheckedVariance
+import scala.util.hashing.MurmurHash3
 
 /**
   * A multidict is a map that can associate a set of values to a given key.
@@ -16,7 +17,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 newSpecificBuilder(): mutable.Builder[(K, V), MultiDictCC[K, V]] = multiMapFactory.newBuilder[K, V]()
+  override protected[this] def newSpecificBuilder: mutable.Builder[(K, V), MultiDictCC[K, V]] = multiMapFactory.newBuilder[K, V]
 
   def canEqual(that: Any): Boolean = true
 
@@ -34,7 +35,7 @@ trait MultiDict[K, V]
     case _ => false
   }
 
-  override def hashCode(): Int = Set.unorderedHash(sets, "MultiMap".##)
+  override def hashCode(): Int = MurmurHash3.unorderedHash(sets, "MultiMap".##)
 
 }
 
@@ -60,8 +61,8 @@ trait MultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K, V]]
     */
   def sets: Map[K, Set[V]]
 
-  def iterator(): Iterator[(K, V)] =
-    sets.iterator().flatMap { case (k, vs) => vs.view.map(v => (k, v)) }
+  def iterator: Iterator[(K, V)] =
+    sets.iterator.flatMap { case (k, vs) => vs.view.map(v => (k, v)) }
 
   /**
     * @return The set of values associated with the given `key`, or the empty

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

@@ -1,5 +1,7 @@
 package scala.collection
 
+import scala.util.hashing.MurmurHash3
+
 /**
   * A multiset is a set that can contain multiple occurrences of a same value.
   *
@@ -26,7 +28,7 @@ trait MultiSet[A]
     case _ => false
   }
 
-  override def hashCode(): Int = collection.Set.unorderedHash(occurrences, "MultiSet".##)
+  override def hashCode(): Int = MurmurHash3.unorderedHash(occurrences, "MultiSet".##)
 
 }
 
@@ -45,8 +47,8 @@ trait MultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
     */
   def occurrences: Map[A, Int]
 
-  def iterator(): Iterator[A] =
-    occurrences.iterator().flatMap { case (elem, n) => new View.Fill(n)(elem) }
+  def iterator: Iterator[A] =
+    occurrences.iterator.flatMap { case (elem, n) => new View.Fill(n)(elem) }
 
   /**
     * @return The number of occurrences of `elem` in this multiset

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

@@ -14,14 +14,14 @@ 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 newSpecificBuilder(): mutable.Builder[(K, V), SortedMultiDictCC[K, V]] = sortedMultiMapFactory.newBuilder[K, V]()
+  override protected[this] def newSpecificBuilder: mutable.Builder[(K, V), SortedMultiDictCC[K, V]] = sortedMultiMapFactory.newBuilder[K, V]
 }
 
 trait SortedMultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K, V]]
   extends MultiDictOps[K, V, MultiDict, C]
     with SortedOps[K, C] {
 
-  protected[this] type SortedMultiDictCC[K, V] = CC[K, V] @uncheckedVariance
+  protected[this] type SortedMultiDictCC[X, Y] = CC[X, Y] @uncheckedVariance
 
   def sortedMultiMapFactory: SortedMapFactory[SortedMultiDictCC]
 
@@ -42,14 +42,14 @@ trait SortedMultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K,
   def lastKey: K = sets.lastKey
 
   def rangeTo(to: K): C = {
-    val i = from(to).iterator()
+    val i = rangeFrom(to).iterator
     if (i.isEmpty) return coll
     val next = i.next()._1
     if (ordering.compare(next, to) == 0)
       if (i.isEmpty) coll
-      else until(i.next()._1)
+      else rangeUntil(i.next()._1)
     else
-      until(next)
+      rangeUntil(next)
   }
 
   override def withFilter(p: ((K, V)) => Boolean): SortedMultiDictOps.WithFilter[K, V, IterableCC, MultiDictCC, CC] =

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

@@ -13,7 +13,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 newSpecificBuilder(): mutable.Builder[A, SortedIterableCC[A]] = sortedIterableFactory.newBuilder[A]()
+  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)
 
@@ -52,14 +52,14 @@ trait SortedMultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
   def lastKey: A = occurrences.lastKey
 
   def rangeTo(to: A): C = {
-    val i = from(to).iterator()
+    val i = rangeFrom(to).iterator
     if (i.isEmpty) return coll
     val next = i.next()
     if (ordering.compare(next, to) == 0)
       if (i.isEmpty) coll
-      else until(i.next())
+      else rangeUntil(i.next())
     else
-      until(next)
+      rangeUntil(next)
   }
 
   override def withFilter(p: A => Boolean): SortedMultiSetOps.WithFilter[A, IterableCC, CC] =

src/main/scala/scala/collection/decorators/HasSeqOps.scala

@@ -1,7 +1,7 @@
 package scala.collection
 package decorators
 
-import scala.collection.immutable.{ImmutableArray, Range}
+import scala.collection.immutable.{ArraySeq, Range}
 
 /** Type class witnessing that a collection type `C` has
   * elements of type `A` and has a conversion to `SeqOps[A, _, _]`.
@@ -31,7 +31,7 @@ object HasSeqOps {
   implicit def stringHasSeqOps: HasSeqOps[String] { type A = Char } =
     new HasSeqOps[String] {
       type A = Char
-      def apply(c: String): SeqOps[Char, AnyConstr, _] = stringToStringOps(c)
+      def apply(c: String): SeqOps[Char, AnyConstr, _] = c: Seq[Char]
     }
 
   // 3. StringView
@@ -45,7 +45,7 @@ object HasSeqOps {
   implicit def arrayHasSeqOps[A0]: HasSeqOps[Array[A0]] { type A = A0 } =
     new HasSeqOps[Array[A0]] {
       type A = A0
-      def apply(c: Array[A0]): SeqOps[A0, AnyConstr, _] = ImmutableArray.unsafeWrapArray(c)
+      def apply(c: Array[A0]): SeqOps[A0, AnyConstr, _] = mutable.ArraySeq.make(c)
     }
 
   // 5. Range collections

src/main/scala/scala/collection/decorators/IterableDecorator.scala

@@ -15,7 +15,7 @@ class IterableDecorator[C, I <: HasIterableOps[C]](coll: C)(implicit val it: I)
     *         all the elements have been traversed or earlier if the operator returns `None`
     */
   def foldSomeLeft[B](z: B)(op: (B, it.A) => Option[B]): B =
-    it(coll).iterator().foldSomeLeft(z)(op)
+    it(coll).iterator.foldSomeLeft(z)(op)
 
   /**
     * Right to left fold that can be interrupted before traversing the whole collection.
@@ -29,6 +29,6 @@ class IterableDecorator[C, I <: HasIterableOps[C]](coll: C)(implicit val it: I)
     *         `f` is applied to the previous result to produce the new result and the fold continues.
     */
   def lazyFoldRight[B](z: B)(op: it.A => Either[B, B => B]): B =
-    it(coll).iterator().lazyFoldRight(z)(op)
+    it(coll).iterator.lazyFoldRight(z)(op)
 
 }

src/main/scala/scala/collection/decorators/views.scala

@@ -7,13 +7,13 @@ object View {
   type SomeIterableOps[+A] = IterableOps[A, AnyConstr, _]
 
   class Intersperse[A](underlying: SomeIterableOps[A], sep: A) extends View[A] {
-    def iterator(): Iterator[A] = underlying.iterator().intersperse(sep)
+    def iterator: Iterator[A] = underlying.iterator.intersperse(sep)
 
     override def knownSize: Int = if (underlying.knownSize > 0) (2 * underlying.knownSize - 1) else underlying.knownSize
   }
 
   class IntersperseSurround[A](underlying: SomeIterableOps[A], start: A, sep: A, end: A) extends View[A] {
-    def iterator(): Iterator[A] = underlying.iterator().intersperse(start, sep, end)
+    def iterator: Iterator[A] = underlying.iterator.intersperse(start, sep, end)
 
     override def knownSize: Int =
       if (underlying.knownSize > 0) (2 * underlying.knownSize + 1)

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

@@ -65,10 +65,10 @@ object MultiDict extends MapFactory[MultiDict] {
   def from[K, V](source: IterableOnce[(K, V)]): MultiDict[K, V] =
     source match {
       case mm: MultiDict[K, V] => mm
-      case _ => (newBuilder[K, V]() ++= source).result()
+      case _ => (newBuilder[K, V] ++= source).result()
     }
 
-  def newBuilder[K, V](): Builder[(K, V), MultiDict[K, V]] =
+  def newBuilder[K, V]: Builder[(K, V), MultiDict[K, V]] =
     new ImmutableBuilder[(K, V), MultiDict[K, V]](empty[K, V]) {
       def addOne(elem: (K, V)): this.type = { elems = elems + elem; this }
     }

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

@@ -76,12 +76,12 @@ object MultiSet extends IterableFactory[MultiSet] {
   def from[A](source: IterableOnce[A]): MultiSet[A] =
     source match {
       case ms: MultiSet[A] => ms
-      case _ => (newBuilder[A]() ++= source).result()
+      case _ => (newBuilder[A] ++= source).result()
     }
 
   def empty[A] = new MultiSetImpl[A](Map.empty)
 
-  def newBuilder[A](): Builder[A, MultiSet[A]] =
+  def newBuilder[A]: Builder[A, MultiSet[A]] =
     new ImmutableBuilder[A, MultiSet[A]](empty[A]) {
       def addOne(elem: A): this.type = { elems = elems + elem; this }
     }

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

@@ -70,10 +70,10 @@ object SortedMultiDict extends SortedMapFactory[SortedMultiDict] {
   def from[K: Ordering, V](it: IterableOnce[(K, V)]): SortedMultiDict[K, V] =
     it match {
       case smm: SortedMultiDict[K, V] => smm
-      case _ => (newBuilder[K, V]() ++= it).result()
+      case _ => (newBuilder[K, V] ++= it).result()
     }
 
-  def newBuilder[K: Ordering, V](): Builder[(K, V), SortedMultiDict[K, V]] =
+  def newBuilder[K: Ordering, V]: Builder[(K, V), SortedMultiDict[K, V]] =
     new ImmutableBuilder[(K, V), SortedMultiDict[K, V]](empty[K, V]) {
       def addOne(elem: (K, V)): this.type = { elems = elems + elem; this }
     }

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

@@ -52,12 +52,12 @@ object SortedMultiSet extends SortedIterableFactory[SortedMultiSet] {
   def from[A: Ordering](source: IterableOnce[A]): SortedMultiSet[A] =
     source match {
       case sms: SortedMultiSet[A] => sms
-      case _ => (newBuilder[A]() ++= source).result()
+      case _ => (newBuilder[A] ++= source).result()
     }
 
   def empty[A: Ordering]: SortedMultiSet[A] = new SortedMultiSet[A](TreeMap.empty)
 
-  def newBuilder[A: Ordering](): Builder[A, SortedMultiSet[A]] =
+  def newBuilder[A: Ordering]: Builder[A, SortedMultiSet[A]] =
     new ImmutableBuilder[A, SortedMultiSet[A]](empty) {
       def addOne(elem: A): this.type = { elems = elems + elem; this }
     }

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

@@ -58,8 +58,8 @@ object MultiDict extends MapFactory[MultiDict] {
 
   def empty[K, V]: MultiDict[K, V] = new MultiDict(Map.empty)
 
-  def from[K, V](source: IterableOnce[(K, V)]): MultiDict[K, V] = (newBuilder[K, V]() ++= source).result()
+  def from[K, V](source: IterableOnce[(K, V)]): MultiDict[K, V] = (newBuilder[K, V] ++= source).result()
 
-  def newBuilder[K, V](): Builder[(K, V), MultiDict[K, V]] = new GrowableBuilder[(K, V), MultiDict[K, V]](empty)
+  def newBuilder[K, V]: Builder[(K, V), MultiDict[K, V]] = new GrowableBuilder[(K, V), MultiDict[K, V]](empty)
 
 }

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

@@ -40,10 +40,10 @@ class MultiSetImpl[A] private[mutable] (val elems: Map[A, Int]) extends MultiSet
 
 object MultiSet extends IterableFactory[MultiSet] {
 
-  def from[A](source: IterableOnce[A]): MultiSet[A] = (newBuilder[A]() ++= source).result()
+  def from[A](source: IterableOnce[A]): MultiSet[A] = (newBuilder[A] ++= source).result()
 
   def empty[A]: MultiSet[A] = new MultiSetImpl[A](Map.empty)
 
-  def newBuilder[A](): Builder[A, MultiSet[A]] = new GrowableBuilder[A, MultiSet[A]](empty)
+  def newBuilder[A]: Builder[A, MultiSet[A]] = new GrowableBuilder[A, MultiSet[A]](empty)
 
 }

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

@@ -65,9 +65,9 @@ object SortedMultiDict extends SortedMapFactory[SortedMultiDict] {
     new SortedMultiDict(SortedMap.empty)
 
   def from[K: Ordering, V](it: IterableOnce[(K, V)]): SortedMultiDict[K, V] =
-    (newBuilder[K, V]() ++= it).result()
+    (newBuilder[K, V] ++= it).result()
 
-  def newBuilder[K: Ordering, V](): Builder[(K, V), SortedMultiDict[K, V]] =
+  def newBuilder[K: Ordering, V]: Builder[(K, V), SortedMultiDict[K, V]] =
     new GrowableBuilder[(K, V), SortedMultiDict[K, V]](empty)
 
 }

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

@@ -44,10 +44,10 @@ class SortedMultiSet[A] private (elems: SortedMap[A, Int])(implicit val ordering
 
 object SortedMultiSet extends SortedIterableFactory[SortedMultiSet] {
 
-  def from[E: Ordering](it: IterableOnce[E]): SortedMultiSet[E] = (newBuilder[E]() ++= it).result()
+  def from[E: Ordering](it: IterableOnce[E]): SortedMultiSet[E] = (newBuilder[E] ++= it).result()
 
   def empty[A: Ordering]: SortedMultiSet[A] = new SortedMultiSet[A](SortedMap.empty[A, Int])
 
-  def newBuilder[A: Ordering](): Builder[A, SortedMultiSet[A]] = new GrowableBuilder[A, SortedMultiSet[A]](empty)
+  def newBuilder[A: Ordering]: Builder[A, SortedMultiSet[A]] = new GrowableBuilder[A, SortedMultiSet[A]](empty)
 
 }

src/test/scala/scala/collection/SortedMultiMapTest.scala

@@ -13,7 +13,7 @@ class SortedMultiMapTest {
     Assert.assertEquals(Set(0, 1), smm.get(2))
     Assert.assertEquals(1, smm.firstKey)
     Assert.assertEquals(3, smm.lastKey)
-    Assert.assertEquals(SortedMultiDict(3 -> 2, 2 -> 1, 2 -> 0), smm.from(2))
+    Assert.assertEquals(SortedMultiDict(3 -> 2, 2 -> 1, 2 -> 0), smm.rangeFrom(2))
   }
 
   @Test def run(): Unit = {

src/test/scala/scala/collection/SortedMultiSetTest.scala

@@ -13,7 +13,7 @@ class SortedMultiSetTest {
     Assert.assertEquals(2, sms.get(2))
     Assert.assertEquals(1, sms.firstKey)
     Assert.assertEquals(3, sms.lastKey)
-    Assert.assertEquals(SortedMultiSet(3, 2, 2), sms.from(2))
+    Assert.assertEquals(SortedMultiSet(3, 2, 2), sms.rangeFrom(2))
   }
 
   @Test def run(): Unit = {

src/test/scala/scala/collection/immutable/SortedMultiMapTest.scala

@@ -17,7 +17,7 @@ class SortedMultiMapTest {
     Assert.assertEquals("a", smm.firstKey)
     Assert.assertEquals("c", smm.lastKey)
 
-    Assert.assertEquals(SortedMultiDict("c" -> 1), smm.from("c"))
+    Assert.assertEquals(SortedMultiDict("c" -> 1), smm.rangeFrom("c"))
 
     val smm2 = smm + ("a" -> 2)
     Assert.assertEquals(Set(1, 2), smm2.get("a"))

src/test/scala/scala/collection/immutable/SortedMultiSetTest.scala

@@ -14,7 +14,7 @@ class SortedMultiSetTest {
     Assert.assertEquals(2, sms.get(2))
     Assert.assertEquals(1, sms.firstKey)
     Assert.assertEquals(3, sms.lastKey)
-    Assert.assertEquals(SortedMultiSet(3, 2, 2), sms.from(2))
+    Assert.assertEquals(SortedMultiSet(3, 2, 2), sms.rangeFrom(2))
     val sms2 = sms + 2
     Assert.assertEquals(3, sms2.get(2))
     val sms3 = sms2 - 3

src/test/scala/scala/collection/mutable/SortedMultiMapTest.scala

@@ -23,7 +23,7 @@ class SortedMultiMapTest {
     Assert.assertEquals("a", smm.firstKey)
     Assert.assertEquals("c", smm.lastKey)
 
-    Assert.assertEquals(SortedMultiDict("c" -> 1), smm.from("c"))
+    Assert.assertEquals(SortedMultiDict("c" -> 1), smm.rangeFrom("c"))
 
     smm += "a" -> 2
     Assert.assertEquals(Set(1, 2), smm.get("a"))