Merge pull request #240 from som-snytt/update/latest

Improvements to the Scala 3 crossbuild

Author: SethTisue

build.sbt

@@ -20,8 +20,23 @@ lazy val collectionContrib = crossProject(JVMPlatform, JSPlatform, NativePlatfor
     scalaModuleAutomaticModuleName := Some("scala.collection.contrib"),
     Compile / compile / scalacOptions ++= {
       CrossVersion.partialVersion(scalaVersion.value) match {
-        case Some((2, _)) => Seq("-opt-warnings", "-Werror", "-Wconf:origin=scala.collection.IterableOps.toIterable:s")
-        case _            => Seq("-Xfatal-warnings", "-Wconf:cat=deprecation:s")
+        case Some((2, _)) => Seq(
+          "-Wconf:origin=scala.collection.IterableOps.toIterable:s", // internal usage; annotating @nowarn is clutter
+          "-Werror",
+          "-Wnonunit-statement",
+          "-Wopt",
+          "-opt:inline:<sources>",
+          "-opt:inline:scala.util.package$chaining$,scala.util.ChainingSyntax,scala.util.ChainingOps$",
+          "-Wvalue-discard",
+          "-Xlint",
+          "-Xsource:3-cross",
+          )
+        case _            => Seq(
+          "-Wconf:cat=deprecation:s", // Scala 3 lacks origin, src arrives in 3.3.4 & 3.5
+          "-Wconf:id=E175:s",
+          "-Werror",
+          "-Wnonunit-statement", // warns on uni-limbed if
+          )
       }
     },
     Compile / doc / scalacOptions ++= {

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

@@ -13,7 +13,7 @@ trait MultiDict[K, V]
     with MultiDictOps[K, V, MultiDict, MultiDict[K, V]]
     with Equals {
 
-  override protected[this] def className: String = "MultiDict"
+  override protected def className: String = "MultiDict"
 
   def multiDictFactory: MapFactory[MultiDict] = MultiDict
   override protected def fromSpecific(coll: IterableOnce[(K, V)]): MultiDict[K, V] = multiDictFactory.from(coll)
@@ -26,14 +26,11 @@ trait MultiDict[K, V]
   override def equals(o: Any): Boolean = o match {
     case that: MultiDict[K @unchecked, _] =>
       (this eq that) ||
-        (that canEqual this) &&
-          (this.size == that.size) && {
-          try {
-            sets forall { case (k, vs) => that.sets.get(k).contains(vs) }
-          } catch {
-            case _: ClassCastException => false
-          }
-        }
+        that.canEqual(this) &&
+        this.size == that.size && (
+          try sets.forall { case (k, vs) => that.sets.get(k).contains(vs) }
+          catch { case _: ClassCastException => false }
+        )
     case _ => false
   }
 
@@ -205,7 +202,7 @@ trait MultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K, V]]
 object MultiDictOps {
 
   class WithFilter[K, V, +IterableCC[_], +CC[X, Y] <: MultiDict[X, Y]](
-    `this`: MultiDictOps[K, V, CC, _] with IterableOps[(K, V), IterableCC, _],
+    `this`: MultiDictOps[K, V, CC, ?] & IterableOps[(K, V), IterableCC, ?],
     p: ((K, V)) => Boolean
   ) extends IterableOps.WithFilter[(K, V), IterableCC](`this`, p) {
 

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

@@ -12,7 +12,7 @@ trait MultiSet[A]
     with MultiSetOps[A, MultiSet, MultiSet[A]]
     with Equals {
 
-  override protected[this] def className: String = "MultiSet"
+  override protected def className: String = "MultiSet"
 
   override def iterableFactory: IterableFactory[MultiSet] = MultiSet
   override protected def fromSpecific(coll: IterableOnce[A]): MultiSet[A] = iterableFactory.from(coll)
@@ -24,14 +24,11 @@ trait MultiSet[A]
   override def equals(o: Any): Boolean = o match {
     case that: MultiSet[A @unchecked] =>
       (this eq that) ||
-        (that canEqual this) &&
-          (this.size == that.size) && {
-          try {
-            occurrences forall { case (elem, n) => that.get(elem) == n }
-          } catch {
-            case _: ClassCastException => false
-          }
-        }
+        that.canEqual(this) &&
+        this.size == that.size && (
+          try occurrences.forall { case (elem, n) => that.get(elem) == n }
+          catch { case _: ClassCastException => false }
+        )
     case _ => false
   }
 
@@ -42,10 +39,10 @@ trait MultiSet[A]
 trait MultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
   extends IterableOps[A, CC, C] {
 
-  protected[this] def fromSpecificOccurrences(it: Iterable[(A, Int)]): C =
+  protected def fromSpecificOccurrences(it: Iterable[(A, Int)]): C =
     fromSpecific(it.view.flatMap { case (e, n) => new View.Fill(n)(e) })
 
-  protected[this] def fromOccurrences[E](it: Iterable[(E, Int)]): CC[E] =
+  protected def fromOccurrences[E](it: Iterable[(E, Int)]): CC[E] =
     // Note new MultiSet(it.to(Map)) would be more efficient but would also loose duplicates
     iterableFactory.from(it.view.flatMap { case (e, n) => new View.Fill(n)(e) })
 

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

@@ -25,8 +25,8 @@ trait SortedMultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K,
 
   def sortedMultiDictFactory: SortedMapFactory[CC]
 
-  protected[this] def sortedFromIterable[L : Ordering, W](it: Iterable[(L, W)]): CC[L, W] = sortedMultiDictFactory.from(it)
-  protected[this] def sortedFromSets[L : Ordering, W](it: Iterable[(L, Set[W])]): CC[L, W] =
+  protected def sortedFromIterable[L : Ordering, W](it: Iterable[(L, W)]): CC[L, W] = sortedMultiDictFactory.from(it)
+  protected def sortedFromSets[L : Ordering, W](it: Iterable[(L, Set[W])]): CC[L, W] =
     sortedFromIterable(it.view.flatMap { case (l, ws) => ws.map(w => (l, w)) })
 
   /** `this` sorted multidict upcasted to an unsorted multidict */
@@ -126,7 +126,7 @@ trait SortedMultiDictOps[K, V, +CC[X, Y] <: MultiDict[X, Y], +C <: MultiDict[K,
 object SortedMultiDictOps {
 
   class WithFilter[K, V, +IterableCC[_], +MultiDictCC[X, Y] <: MultiDict[X, Y], +CC[X, Y] <: MultiDict[X, Y]](
-    `this`: SortedMultiDictOps[K, V, CC, _] with MultiDictOps[K, V, MultiDictCC, _] with IterableOps[(K, V), IterableCC, _],
+    `this`: SortedMultiDictOps[K, V, CC, ?] & MultiDictOps[K, V, MultiDictCC, ?] & IterableOps[(K, V), IterableCC, ?],
     p: ((K, V)) => Boolean
   ) extends MultiDictOps.WithFilter[K, V, IterableCC, MultiDictCC](`this`, p) {
 

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

@@ -118,7 +118,7 @@ trait SortedMultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
     *         is the minimum of the lengths of `this` and `that`
     */
   def zip[B](that: Iterable[B])(implicit ev: Ordering[B]): CC[(A @uncheckedVariance, B)] = // sound bcs of VarianceNote
-    sortedFromIterable(new View.Zip(toIterable, that))(Ordering.Tuple2(ordering, implicitly))
+    sortedFromIterable(new View.Zip(toIterable, that))(using Ordering.Tuple2(ordering, implicitly))
 
   /**
     * @return a new collection resulting from applying the given partial
@@ -147,7 +147,7 @@ trait SortedMultiSetOps[A, +CC[X] <: MultiSet[X], +C <: MultiSet[A]]
   // --- Override return type of methods that returned an unsorted MultiSet
 
   override def zipWithIndex: CC[(A, Int)] =
-    sortedFromIterable(new View.ZipWithIndex(toIterable))(Ordering.Tuple2(ordering, implicitly))
+    sortedFromIterable(new View.ZipWithIndex(toIterable))(using Ordering.Tuple2(ordering, implicitly))
 
 }
 
@@ -158,7 +158,7 @@ object SortedMultiSetOps {
     * @define coll sorted collection
     */
   class WithFilter[A, +IterableCC[_], +CC[X] <: MultiSet[X]](
-    `this`: SortedMultiSetOps[A, CC, _] with IterableOps[A, IterableCC, _],
+    `this`: SortedMultiSetOps[A, CC, ?] & IterableOps[A, IterableCC, ?],
     p: A => Boolean
   ) extends IterableOps.WithFilter[A, IterableCC](`this`, p) {
 

src/main/scala/scala/collection/decorators/BitSetDecorator.scala

@@ -2,7 +2,7 @@ package scala.collection.decorators
 
 import scala.collection.{BitSet, BitSetOps}
 
-class BitSetDecorator[+C <: BitSet with BitSetOps[C]](protected val bs: C) {
+class BitSetDecorator[+C <: BitSet & BitSetOps[C]](protected val bs: C) {
 
   import BitSetDecorator._
   import BitSetOps._

src/main/scala/scala/collection/decorators/IteratorDecorator.scala

@@ -2,6 +2,7 @@ package scala.collection
 package decorators
 
 import scala.annotation.tailrec
+import scala.util.chaining.*
 import scala.util.control.NonFatal
 
 /** Enriches Iterator with additional methods.
@@ -188,8 +189,8 @@ class IteratorDecorator[A](val `this`: Iterator[A]) extends AnyVal {
     */
   def splitBy[K](f: A => K): Iterator[immutable.Seq[A]] =
     new AbstractIterator[immutable.Seq[A]] {
-      private var hd: A = _
-      private var hdKey: K = _
+      private var hd: A = null.asInstanceOf[A] // todo uninitialized
+      private var hdKey: K = null.asInstanceOf[K] // todo uninitialized
       private var hdDefined: Boolean = false
 
       override def hasNext: Boolean = hdDefined || `this`.hasNext
@@ -240,32 +241,26 @@ class IteratorDecorator[A](val `this`: Iterator[A]) extends AnyVal {
   }
 
   /** Gives elements from the source iterator until the source iterator ends or throws a NonFatal exception.
-    *
-    * @param  exceptionCaught a callback invoked from `hasNext` when the source iterator throws a NonFatal exception
-    * @return an iterator that takes items until the wrapped iterator ends or throws a NonFatal exception
-    * @see    scala.util.control.NonFatal
-    * @note   Reuse: $consumesAndProducesIterator
-    */
-  def takeUntilException(exceptionCaught: Throwable => Unit): Iterator[A] = {
+   *
+   *  @param  exceptionCaught a callback invoked from `hasNext` when the source iterator throws a NonFatal exception
+   *  @return an iterator that takes items until the wrapped iterator ends or throws a NonFatal exception
+   *  @see    scala.util.control.NonFatal
+   *  @note   Reuse: $consumesAndProducesIterator
+   */
+  def takeUntilException(exceptionCaught: Throwable => Unit): Iterator[A] =
     new AbstractIterator[A] {
       private val wrapped = `this`.buffered
 
-      override def hasNext: Boolean = {
-        try {
-          val n = wrapped.hasNext
-          // By already invoking `head` (and therefore also `next` on `this`),
-          // we are sure that `wrapped.next` will not throw when it is used from
-          // `next`.
-          if (n) wrapped.head
-          n
-        } catch {
+      override def hasNext: Boolean =
+        // By already invoking `head` (and therefore also `next` on `this`),
+        // we are sure that `wrapped.next` will not throw when it is used from `next`.
+        try wrapped.hasNext.tap(if(_) wrapped.head)
+        catch {
           case NonFatal(t) =>
             exceptionCaught(t)
             false
         }
-      }
 
       override def next(): A = wrapped.next()
     }
-  }
 }

src/main/scala/scala/collection/decorators/package.scala

@@ -17,7 +17,7 @@ package object decorators {
   implicit def mapDecorator[C](coll: C)(implicit map: IsMap[C]): MapDecorator[C, map.type] =
     new MapDecorator(coll)(map)
 
-  implicit def bitSetDecorator[C <: BitSet with BitSetOps[C]](bs: C): BitSetDecorator[C] =
+  implicit def bitSetDecorator[C <: BitSet & BitSetOps[C]](bs: C): BitSetDecorator[C] =
     new BitSetDecorator(bs)
 
   implicit def mutableBitSetDecorator(bs: mutable.BitSet): MutableBitSetDecorator =

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

@@ -4,7 +4,7 @@ package decorators
 /** Views used by decorators */
 object View {
 
-  type SomeIterableOps[+A] = IterableOps[A, AnyConstr, _]
+  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)
@@ -21,4 +21,4 @@ object View {
       else underlying.knownSize
   }
 
-}
+}

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

@@ -2,11 +2,10 @@ package scala
 package collection
 package mutable
 
-/**
-  * A mutable multidict
-  * @tparam K the type of keys
-  * @tparam V the type of values
-  */
+/** A mutable multidict.
+ *  @tparam K the type of keys
+ *  @tparam V the type of values
+ */
 class MultiDict[K, V] private (elems: Map[K, Set[V]])
   extends collection.MultiDict[K, V]
     with Iterable[(K, V)]
@@ -27,20 +26,18 @@ class MultiDict[K, V] private (elems: Map[K, Set[V]])
 
   def addOne(elem: (K, V)): this.type = {
     val (k, v) = elem
-    elems.updateWith(k) {
-      case None     => Some(Set(v))
-      case Some(vs) => Some(vs += v)
-    }
+    val vs = elems.getOrElseUpdate(k, Set.empty[V])
+    vs.addOne(v)
     this
   }
 
   def subtractOne(elem: (K, V)): this.type = {
     val (k, v) = elem
-    elems.updateWith(k) {
+    elems.get(k) match {
       case Some(vs) =>
-        vs -= v
-        if (vs.nonEmpty) Some(vs) else None
-      case None => None
+        vs.subtractOne(v)
+        if (vs.isEmpty) elems.subtractOne(k)
+      case _ =>
     }
     this
   }
@@ -50,7 +47,7 @@ class MultiDict[K, V] private (elems: Map[K, Set[V]])
     * @return the collection itself
     */
   def removeKey(key: K): this.type = {
-    elems -= key
+    elems.subtractOne(key)
     this
   }
 
@@ -69,4 +66,4 @@ object MultiDict extends MapFactory[MultiDict] {
 
   def newBuilder[K, V]: Builder[(K, V), MultiDict[K, V]] = new GrowableBuilder[(K, V), MultiDict[K, V]](empty)
 
-}
+}