Changes to compile with Scala 2.13.0-M4

Co-authored-by: julienrf

Author: lrytz

build.sbt

@@ -9,8 +9,8 @@ lazy val isRelease = false
 lazy val travisCommit = Option(System.getenv().get("TRAVIS_COMMIT"))
 
 lazy val scalaVersionSettings = Seq(
-  scalaVersion := "2.12.6",
-  crossScalaVersions := Seq("2.10.7", "2.11.12", "2.13.0-M3", scalaVersion.value)
+  scalaVersion := "2.13.0-M4",
+  crossScalaVersions := Seq("2.10.7", "2.11.12", "2.13.0-M4", scalaVersion.value)
 )
 
 lazy val sharedSettings = MimaSettings.settings ++ scalaVersionSettings ++ Seq(
@@ -56,7 +56,6 @@ lazy val sharedSettings = MimaSettings.settings ++ scalaVersionSettings ++ Seq(
     "-unchecked",
     "-Xfatal-warnings",
     "-Xfuture",
-    "-Yno-adapted-args",
     "-Ywarn-dead-code",
     "-Ywarn-inaccessible",
     "-Ywarn-nullary-override",

doc/UserGuide.md

@@ -471,14 +471,14 @@ responsible for generating the individual items. You can use it in the
 following way:
 
 ```scala
-val genIntList      = Gen.containerOf[List,Int](Gen.oneOf(1, 3, 5))
+val genIntList        = Gen.containerOf[List,Int](Gen.oneOf(1, 3, 5))
 
-val genStringStream = Gen.containerOf[Stream,String](Gen.alphaStr)
+val genStringLazyList = Gen.containerOf[LazyList,String](Gen.alphaStr)
 
-val genBoolArray    = Gen.containerOf[Array,Boolean](true)
+val genBoolArray      = Gen.containerOf[Array,Boolean](true)
 ```
 
-By default, ScalaCheck supports generation of `List`, `Stream`, `Set`, `Array`,
+By default, ScalaCheck supports generation of `List`, `LazyList`, `Set`, `Array`,
 and `ArrayList` (from `java.util`). You can add support for additional
 containers by adding implicit `Buildable` instances. See `Buildable.scala` for
 examples.
@@ -778,7 +778,7 @@ can also define default shrinking methods. This is done by defining an implicit
 method that returns a `Shrink[T]` instance. This is done by using the
 `Shrink(...)` factory method, which as its only parameter takes a function and
 returns an instance of `Shrink[T]`. In turn, the function should take a value
-of the given type `T`, and return a `Stream` of shrank variants of the given
+of the given type `T`, and return a `LazyList` of shrank variants of the given
 value. As an example, look at the implicit `Shrink` instance for a tuple as it
 is defined in ScalaCheck:
 
@@ -873,15 +873,15 @@ object CounterSpecification extends Commands {
    *  (a singleton [[Sut]]), implement this method the following way:
    *
    *  {{{
-   *  def canCreateNewSut(newState: State, initSuts: Traversable[State]
-   *    runningSuts: Traversable[Sut]
+   *  def canCreateNewSut(newState: State, initSuts: Iterable[State]
+   *    runningSuts: Iterable[Sut]
    *  ) = {
    *    initSuts.isEmpty && runningSuts.isEmpty
    *  }
    *  }}}
    */
-  def canCreateNewSut(newState: State, initSuts: Traversable[State],
-    runningSuts: Traversable[Sut]): Boolean = true
+  def canCreateNewSut(newState: State, initSuts: Iterable[State],
+    runningSuts: Iterable[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: Traversable[State],
-    runningSuts: Traversable[Sut]
+  def canCreateNewSut(newState: State, initSuts: Iterable[State],
+    runningSuts: Iterable[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: Traversable[State],
-    runningSuts: Traversable[Sut]
+  def canCreateNewSut(newState: State, initSuts: Iterable[State],
+    runningSuts: Iterable[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: Traversable[State],
-    runningSuts: Traversable[Sut]
+  def canCreateNewSut(newState: State, initSuts: Iterable[State],
+    runningSuts: Iterable[Sut]
   ): Boolean = {
     initSuts.isEmpty && runningSuts.isEmpty
   }

jvm/src/test/scala/org/scalacheck/CogenSpecification.scala

@@ -140,7 +140,7 @@ object CogenSpecification extends Properties("Cogen") {
   include(cogenLaws[String], "cogenString.")
   include(cogenLaws[List[Int]], "cogenList.")
   include(cogenLaws[Vector[Int]], "cogenVector.")
-  include(cogenLaws[Stream[Int]], "cogenStream.")
+  include(cogenLaws[LazyList[Int]], "cogenLazyList.")
   include(cogenLaws[Set[Int]], "cogenSet.")
   include(cogenLaws[Map[Int, Int]], "cogenMap.")
   include(cogenLaws[() => Int], "cogenFunction0.")

jvm/src/test/scala/org/scalacheck/GenSpecification.scala

@@ -179,7 +179,7 @@ object GenSpecification extends Properties("Gen") {
     l.length == 0
   }
 
-  property("infiniteStream") = forAll(infiniteStream(arbitrary[Int]), arbitrary[Short]) { (s, n) =>
+  property("infiniteLazyList") = forAll(infiniteLazyList(arbitrary[Int]), arbitrary[Short]) { (s, n) =>
     s.drop(n & 0xffff).nonEmpty
   }
 
@@ -201,7 +201,7 @@ object GenSpecification extends Properties("Gen") {
   property("distributed pick") = {
     val lst = (0 to 7).toIterable
     val n = 2
-    forAll(pick(n, lst)) { xs: Seq[Int] =>
+    forAll(pick(n, lst)) { xs: collection.Seq[Int] =>
       xs.map { x: Int =>
         Prop.collect(x) {
           xs.size == n

jvm/src/test/scala/org/scalacheck/PropertyFilterSpecification.scala

@@ -26,17 +26,17 @@ object PropertyFilterSpecification extends Properties("PropertyFilter") {
 
   val nl = System.lineSeparator
 
-  private def diff(filter: Option[String], actual: Seq[String],
-    expected: Seq[String]): String = {
+  private def diff(filter: Option[String], actual: collection.Seq[String],
+    expected: collection.Seq[String]): String = {
     s"filter: ${filter.getOrElse("not supplied")}" +
     s"${nl}expected values:$nl" +
     s"\t${expected.mkString(s"$nl\t")}" +
     s"${nl}actual values:$nl" +
     s"\t${actual.mkString(s"$nl\t")}"
   }
 
-  private def prop(filter: Option[String], actualNames: Seq[String],
-    expectedNames: Seq[String]): Prop = {
+  private def prop(filter: Option[String], actualNames: collection.Seq[String],
+    expectedNames: collection.Seq[String]): Prop = {
     def lengthProp = actualNames.length == expectedNames.length
 
     def props = actualNames.forall(expectedNames.contains)

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: Traversable[State],
-      runningSuts: Traversable[Sut]) = true
+    def canCreateNewSut(newState: State, initSuts: Iterable[State],
+      runningSuts: Iterable[Sut]) = true
 
     def newSut(state: State): Sut = Counter(state)
 

src/main/scala/org/scalacheck/Arbitrary.scala

@@ -357,22 +357,22 @@ private[scalacheck] sealed trait ArbitraryLowPriority {
     Arbitrary(Gen.oneOf(arbitrary[T].map(Success(_)), arbitrary[Throwable].map(Failure(_))))
 
   /** Arbitrary instance of any [[org.scalacheck.util.Buildable]] container
-   *  (such as lists, arrays, streams, etc). The maximum size of the container
+   *  (such as lists, arrays, lazy lists, etc). The maximum size of the container
    *  depends on the size generation parameter. */
   implicit def arbContainer[C[_],T](implicit
-    a: Arbitrary[T], b: Buildable[T,C[T]], t: C[T] => Traversable[T]
+    a: Arbitrary[T], b: Buildable[T,C[T]], t: C[T] => Iterable[T]
   ): Arbitrary[C[T]] = Arbitrary(buildableOf[C[T],T](arbitrary[T]))
 
   /** Arbitrary instance of any [[org.scalacheck.util.Buildable]] container
    *  (such as maps). The maximum size of the container depends on the size
    *  generation parameter. */
   implicit def arbContainer2[C[_,_],T,U](implicit
-    a: Arbitrary[(T,U)], b: Buildable[(T,U),C[T,U]], t: C[T,U] => Traversable[(T,U)]
+    a: Arbitrary[(T,U)], b: Buildable[(T,U),C[T,U]], t: C[T,U] => Iterable[(T,U)]
   ): Arbitrary[C[T,U]] = Arbitrary(buildableOf[C[T,U],(T,U)](arbitrary[(T,U)]))
 
   implicit def arbEnum[A <: java.lang.Enum[A]](implicit A: reflect.ClassTag[A]): Arbitrary[A] = {
     val values = A.runtimeClass.getEnumConstants.asInstanceOf[Array[A]]
-    Arbitrary(Gen.oneOf(values))
+    Arbitrary(Gen.oneOf(values.toIndexedSeq))
   }
 
   implicit def arbPartialFunction[A: Cogen, B: Arbitrary]: Arbitrary[PartialFunction[A, B]] =