Changes to make MiMa happy

Author: lrytz

doc/UserGuide.md

@@ -873,15 +873,15 @@ object CounterSpecification extends Commands {
    *  (a singleton [[Sut]]), implement this method the following way:
    *
    *  {{{
-   *  def canCreateNewSut(newState: State, initSuts: Iterable[State]
-   *    runningSuts: Iterable[Sut]
+   *  def canCreateNewSut(newState: State, initSuts: Traversable[State]
+   *    runningSuts: Traversable[Sut]
    *  ) = {
    *    initSuts.isEmpty && runningSuts.isEmpty
    *  }
    *  }}}
    */
-  def canCreateNewSut(newState: State, initSuts: Iterable[State],
-    runningSuts: Iterable[Sut]): Boolean = true
+  def canCreateNewSut(newState: State, initSuts: Traversable[State],
+    runningSuts: Traversable[Sut]): Boolean = true
 
   /** The precondition for the initial state, when no commands yet have
    *  run. This is used by ScalaCheck when command sequences are shrinked

examples/commands-leveldb/src/test/scala/CommandsLevelDB.scala

@@ -30,8 +30,8 @@ object LevelDBSpec extends Commands {
     def path = s"db_$name"
   }
 
-  def canCreateNewSut(newState: State, initSuts: Iterable[State],
-    runningSuts: Iterable[Sut]
+  def canCreateNewSut(newState: State, initSuts: Traversable[State],
+    runningSuts: Traversable[Sut]
   ) = {
     !initSuts.exists(_.name == newState.name) &&
     !runningSuts.exists(_.name == newState.name)

examples/commands-nix/src/test/scala/CommandsNix.scala

@@ -100,8 +100,8 @@ object MachineSpec extends Commands {
   type Sut = Map[String, org.libvirt.Domain]
 
   // TODO we should check for example total amount of memory used here
-  def canCreateNewSut(newState: State, initSuts: Iterable[State],
-    runningSuts: Iterable[Sut]
+  def canCreateNewSut(newState: State, initSuts: Traversable[State],
+    runningSuts: Traversable[Sut]
   ): Boolean = true
 
   def newSut(state: State): Sut = {

examples/commands-redis/src/test/scala/CommandsRedis.scala

@@ -26,8 +26,8 @@ object RedisSpec extends Commands {
     connected: Boolean
   )
 
-  def canCreateNewSut(newState: State, initSuts: Iterable[State],
-    runningSuts: Iterable[Sut]
+  def canCreateNewSut(newState: State, initSuts: Traversable[State],
+    runningSuts: Traversable[Sut]
   ): Boolean = {
     initSuts.isEmpty && runningSuts.isEmpty
   }

jvm/src/test/scala/org/scalacheck/commands/CommandsSpecification.scala

@@ -30,8 +30,8 @@ object CommandsSpecification extends Properties("Commands") {
 
     override def shrinkState: Shrink[Int] = implicitly
 
-    def canCreateNewSut(newState: State, initSuts: Iterable[State],
-      runningSuts: Iterable[Sut]) = true
+    def canCreateNewSut(newState: State, initSuts: Traversable[State],
+      runningSuts: Traversable[Sut]) = true
 
     def newSut(state: State): Sut = Counter(state)
 

src/main/scala-2.13+/org/scalacheck/ScalaVersionSpecific.scala

@@ -48,7 +48,7 @@ private[scalacheck] trait GenVersionSpecific {
 private[scalacheck] trait GenSpecificationVersionSpecific
 
 private[scalacheck] trait CogenVersionSpecific {
-  implicit def cogenStream[A: Cogen]: Cogen[Stream[A]] =
+  implicit def cogenLazyList[A: Cogen]: Cogen[LazyList[A]] =
     Cogen.it(_.iterator)
 }
 

src/main/scala/org/scalacheck/Cogen.scala

@@ -16,7 +16,6 @@ import scala.util.{Failure, Success, Try}
 import scala.concurrent.duration.{Duration, FiniteDuration}
 import java.math.BigInteger
 import rng.Seed
-import ScalaVersionSpecific._
 
 sealed trait Cogen[T] extends Serializable {
 
@@ -124,7 +123,7 @@ object Cogen extends CogenArities with CogenLowPriority with CogenVersionSpecifi
   implicit def cogenVector[A: Cogen]: Cogen[Vector[A]] =
     Cogen.it(_.iterator)
 
-  implicit def cogenLazyList[A: Cogen]: Cogen[LazyList[A]] =
+  implicit def cogenStream[A: Cogen]: Cogen[Stream[A]] =
     Cogen.it(_.iterator)
 
   implicit def cogenSet[A: Cogen: Ordering]: Cogen[Set[A]] =

src/main/scala/org/scalacheck/Gen.scala

@@ -450,7 +450,7 @@ object Gen extends GenArities with GenVersionSpecific {
 
   /** Sequences generators. If any of the given generators fails, the
    *  resulting generator will also fail. */
-  def sequence[C,T](gs: Iterable[Gen[T]])(implicit b: Buildable[T,C]): Gen[C] = {
+  def sequence[C,T](gs: Traversable[Gen[T]])(implicit b: Buildable[T,C]): Gen[C] = {
     val g = gen { (p, seed) =>
       gs.foldLeft(r(Some(Vector.empty[T]), seed)) {
         case (rs,g) =>

src/main/scala/org/scalacheck/commands/Commands.scala

@@ -56,15 +56,15 @@ trait Commands {
    *  (a singleton [[Sut]]), implement this method the following way:
    *
    *  {{{
-   *  def canCreateNewSut(newState: State, initSuts: Iterable[State]
-   *    runningSuts: Iterable[Sut]
+   *  def canCreateNewSut(newState: State, initSuts: Traversable[State]
+   *    runningSuts: Traversable[Sut]
    *  ) = {
    *    initSuts.isEmpty && runningSuts.isEmpty
    *  }
    *  }}}
    */
-  def canCreateNewSut(newState: State, initSuts: Iterable[State],
-    runningSuts: Iterable[Sut]): Boolean
+  def canCreateNewSut(newState: State, initSuts: Traversable[State],
+    runningSuts: Traversable[Sut]): Boolean
 
   /** Create a new [[Sut]] instance with an internal state that
    *  corresponds to the provided abstract state instance. The provided state

src/main/scala/org/scalacheck/util/Buildable.scala

@@ -15,7 +15,7 @@ import ScalaVersionSpecific._
 
 trait Buildable[T,C] extends Serializable {
   def builder: mutable.Builder[T,C]
-  def fromIterable(it: Iterable[T]): C = {
+  def fromIterable(it: Traversable[T]): C = {
     val b = builder
     b ++= it
     b.result()
@@ -27,14 +27,15 @@ trait Buildable[T,C] extends Serializable {
   * serializable too.
   */
 object SerializableCanBuildFroms {
-  implicit def listFactory[T]: Factory[T, List[T]] = ScalaVersionSpecific.listFactory
-  implicit def bitsetFactory[T]: Factory[Int, BitSet] = ScalaVersionSpecific.bitsetFactory
-  implicit def mapFactory[T, U]: Factory[(T, U), Map[T, U]] = ScalaVersionSpecific.mapFactory
+  // Names are `..CanBuildFrom` for binary compatibility. Change to `..Factory` in a major release.
+  implicit def listCanBuildFrom[T]: Factory[T, List[T]] = ScalaVersionSpecific.listFactory
+  implicit def bitsetCanBuildFrom[T]: Factory[Int, BitSet] = ScalaVersionSpecific.bitsetFactory
+  implicit def mapCanBuildFrom[T, U]: Factory[(T, U), Map[T, U]] = ScalaVersionSpecific.mapFactory
 }
 
 object Buildable {
-
-  implicit def buildableFactory[T,C](implicit f: Factory[T,C]) =
+  // Names is `..CanBuildFrom` for binary compatibility. Change to `..Factory` in a major release.
+  implicit def buildableCanBuildFrom[T,C](implicit f: Factory[T,C]) =
     new Buildable[T,C] {
       def builder = f.newBuilder
     }