Fix some warnings under Scala >=3.4

These are automatic rewrites using `-rewrite -source:3.4-migration`

Author: mbovel

algebra-core/src/main/scala/algebra/Priority.scala

@@ -44,7 +44,7 @@ sealed trait Priority[+P, +F] {
       case Fallback(y)  => f2(y)
     }
 
-  def join[U >: P with F]: U =
+  def join[U >: P & F]: U =
     fold(_.asInstanceOf[U])(_.asInstanceOf[U])
 
   def bimap[P2, F2](f1: P => P2)(f2: F => F2): Priority[P2, F2] =

algebra-core/src/main/scala/algebra/ring/Additive.scala

@@ -38,7 +38,7 @@ trait AdditiveSemigroup[@sp(Int, Long, Float, Double) A] extends Any with Serial
     if (n > 0) positiveSumN(a, n)
     else throw new IllegalArgumentException("Illegal non-positive exponent to sumN: %s".format(n))
 
-  protected[this] def positiveSumN(a: A, n: Int): A = {
+  protected def positiveSumN(a: A, n: Int): A = {
     @tailrec def loop(b: A, k: Int, extra: A): A =
       if (k == 1) plus(b, extra)
       else {

algebra-core/src/main/scala/algebra/ring/Multiplicative.scala

@@ -34,7 +34,7 @@ trait MultiplicativeSemigroup[@sp(Int, Long, Float, Double) A] extends Any with
     if (n > 0) positivePow(a, n)
     else throw new IllegalArgumentException("Illegal non-positive exponent to pow: %s".format(n))
 
-  protected[this] def positivePow(a: A, n: Int): A = {
+  protected def positivePow(a: A, n: Int): A = {
     @tailrec def loop(b: A, k: Int, extra: A): A =
       if (k == 1) times(b, extra)
       else {

algebra-core/src/main/scala/algebra/ring/Signed.scala

@@ -156,7 +156,7 @@ object Signed extends SignedFunctions[Signed] {
     def apply(i: Int): Sign =
       if (i == 0) Zero else if (i > 0) Positive else Negative
 
-    private val instance: CommutativeMonoid[Sign] with MultiplicativeCommutativeMonoid[Sign] with Eq[Sign] =
+    private val instance: CommutativeMonoid[Sign] & MultiplicativeCommutativeMonoid[Sign] & Eq[Sign] =
       new CommutativeMonoid[Sign] with MultiplicativeCommutativeMonoid[Sign] with Eq[Sign] {
         def eqv(x: Sign, y: Sign): Boolean = x == y
         def empty: Sign = Positive

algebra-laws/shared/src/main/scala/algebra/laws/LatticeLaws.scala

@@ -92,14 +92,14 @@ trait LatticeLaws[A] extends GroupLaws[A] {
     meet = Some(boundedSemilattice(A.meetSemilattice))
   )
 
-  def boundedJoinLattice(implicit A: Lattice[A] with BoundedJoinSemilattice[A]) = new LatticeProperties(
+  def boundedJoinLattice(implicit A: Lattice[A] & BoundedJoinSemilattice[A]) = new LatticeProperties(
     name = "boundedJoinLattice",
     parents = Seq(boundedJoinSemilattice, lattice),
     join = Some(boundedSemilattice(A.joinSemilattice)),
     meet = Some(semilattice(A.meetSemilattice))
   )
 
-  def boundedMeetLattice(implicit A: Lattice[A] with BoundedMeetSemilattice[A]) = new LatticeProperties(
+  def boundedMeetLattice(implicit A: Lattice[A] & BoundedMeetSemilattice[A]) = new LatticeProperties(
     name = "boundedMeetLattice",
     parents = Seq(boundedMeetSemilattice, lattice),
     join = Some(semilattice(A.joinSemilattice)),

algebra-laws/shared/src/main/scala/algebra/laws/LatticePartialOrderLaws.scala

@@ -80,13 +80,13 @@ trait LatticePartialOrderLaws[A] extends Laws {
       "lteqv+one" -> forAll { (x: A) => x ?<= A.one }
     )
 
-  def boundedBelowLatticePartialOrder(implicit A: Lattice[A] with BoundedJoinSemilattice[A], P: PartialOrder[A]) =
+  def boundedBelowLatticePartialOrder(implicit A: Lattice[A] & BoundedJoinSemilattice[A], P: PartialOrder[A]) =
     new LatticePartialOrderProperties(
       name = "boundedBelowLatticePartialOrder",
       parents = Seq(boundedJoinSemilatticePartialOrder, latticePartialOrder)
     )
 
-  def boundedAboveLatticePartialOrder(implicit A: Lattice[A] with BoundedMeetSemilattice[A], P: PartialOrder[A]) =
+  def boundedAboveLatticePartialOrder(implicit A: Lattice[A] & BoundedMeetSemilattice[A], P: PartialOrder[A]) =
     new LatticePartialOrderProperties(
       name = "boundedAboveLatticePartialOrder",
       parents = Seq(boundedMeetSemilatticePartialOrder, latticePartialOrder)

algebra-laws/shared/src/main/scala/algebra/laws/OrderLaws.scala

@@ -243,6 +243,6 @@ trait OrderLaws[A] extends Laws {
     name: String,
     parent: Option[RuleSet],
     props: (String, Prop)*
-  ) extends DefaultRuleSet(name, parent, props: _*)
+  ) extends DefaultRuleSet(name, parent, props*)
 
 }

algebra-laws/shared/src/main/scala/algebra/laws/RingLaws.scala

@@ -66,7 +66,7 @@ trait RingLaws[A] extends GroupLaws[A] { self =>
     new nonZeroLaws.GroupProperties(
       name = props.name,
       parents = parents,
-      props = props.props: _*
+      props = props.props*
     )
 
   implicit def Arb: Arbitrary[A]
@@ -398,7 +398,7 @@ trait RingLaws[A] extends GroupLaws[A] { self =>
 
   object RingProperties {
     def fromParent(name: String, parent: RingProperties, props: (String, Prop)*) =
-      new RingProperties(name, parent.al, parent.ml, Seq(parent), props: _*)
+      new RingProperties(name, parent.al, parent.ml, Seq(parent), props*)
   }
 
   class RingProperties(

algebra-laws/shared/src/test/scala/algebra/laws/LawTests.scala

@@ -141,7 +141,7 @@ class LawTests extends munit.DisciplineSuite {
 
   {
     implicit val arbBitSet: Arbitrary[BitSet] =
-      Arbitrary(arbitrary[List[Byte]].map(s => BitSet(s.map(_ & 0xff): _*)))
+      Arbitrary(arbitrary[List[Byte]].map(s => BitSet(s.map(_ & 0xff)*)))
     checkAll("BitSet", LogicLaws[BitSet].generalizedBool)
   }
 

algebra-laws/shared/src/test/scala/algebra/laws/Rat.scala

@@ -121,7 +121,7 @@ object Rat {
     DistributiveLattice.minMax[Rat](using ratAlgebra)
 
   // Is this horrible? Yes. Am I ashamed? Yes.
-  private[this] def genNonZero: Gen[BigInt] =
+  private def genNonZero: Gen[BigInt] =
     arbitrary[BigInt].flatMap { x =>
       if (x != 0) Gen.const(x)
       else genNonZero

alleycats-core/src/main/scala/alleycats/ReferentialEq.scala

@@ -32,7 +32,7 @@ trait ReferentialEq[A <: AnyRef] extends Eq[A] {
 }
 
 object ReferentialEq {
-  private[this] val referentialEq: Eq[AnyRef] = new ReferentialEq[AnyRef] {}
+  private val referentialEq: Eq[AnyRef] = new ReferentialEq[AnyRef] {}
 
   def apply[A <: AnyRef]: Eq[A] = referentialEq.asInstanceOf[Eq[A]]
 }

alleycats-core/src/main/scala/alleycats/SystemIdentityHash.scala

@@ -32,7 +32,7 @@ trait SystemIdentityHash[A <: AnyRef] extends ReferentialEq[A] with Hash[A] {
 }
 
 object SystemIdentityHash {
-  private[this] val identityHash: Hash[AnyRef] = new SystemIdentityHash[AnyRef] {}
+  private val identityHash: Hash[AnyRef] = new SystemIdentityHash[AnyRef] {}
 
   def apply[A <: AnyRef]: Hash[A] = identityHash.asInstanceOf[Hash[A]]
 }

alleycats-laws/shared/src/main/scala/alleycats/laws/discipline/FlatMapRecTests.scala

@@ -35,7 +35,7 @@ trait FlatMapRecTests[F[_]] extends Laws {
     new DefaultRuleSet(
       name = "flatMapTailRec",
       parent = None,
-      "tailRecM consistent flatMap" -> forAll(laws.tailRecMConsistentFlatMap[A] _)
+      "tailRecM consistent flatMap" -> forAll(laws.tailRecMConsistentFlatMap[A])
     )
 }
 

alleycats-laws/shared/src/main/scala/alleycats/laws/discipline/ReferentialEqTests.scala

@@ -36,9 +36,9 @@ trait ReferentialEqTests[A] extends Laws {
     new DefaultRuleSet(
       "referentialEq",
       None,
-      "reflexivity eq" -> forAll(laws.reflexivityEq _),
-      "symmetry eq" -> forAll(laws.symmetryEq _),
-      "transitivity eq" -> forAll(laws.transitivityEq _)
+      "reflexivity eq" -> forAll(laws.reflexivityEq),
+      "symmetry eq" -> forAll(laws.symmetryEq),
+      "transitivity eq" -> forAll(laws.transitivityEq)
     )
   }
 }

alleycats-laws/shared/src/main/scala/alleycats/laws/discipline/SystemIdentityHashTests.scala

@@ -36,8 +36,8 @@ trait SystemIdentityHashTests[A] extends ReferentialEqTests[A] {
     new DefaultRuleSet(
       "systemIdentityHash",
       Some(eqv),
-      "hash compatibility" -> forAll(laws.hashCompatibility _),
-      "same as universal hash" -> forAll(laws.sameAsUniversalHash _),
+      "hash compatibility" -> forAll(laws.hashCompatibility),
+      "same as universal hash" -> forAll(laws.sameAsUniversalHash),
       "same as scala hashing" -> forAll((x: A, y: A) => laws.sameAsScalaHashing(x, y, hashA))
     )
 }

alleycats-laws/shared/src/test/scala/alleycats/tests/MapSuite.scala

@@ -34,7 +34,7 @@ class MapSuite extends AlleycatsSuite {
   checkAll("Map[Int, *]", ShortCircuitingTests[Map[Int, *]].traverseFilter[Int])
 
   test("traverse is stack-safe") {
-    val items = Map((0 until 100000).map { i => (i.toString, i) }: _*)
+    val items = Map((0 until 100000).map { i => (i.toString, i) }*)
     val sumAll = Traverse[Map[String, *]]
       .traverse(items) { i => () => i }
       .apply()

bench/src/main/scala/cats/bench/StateTBench.scala

@@ -34,7 +34,7 @@ import org.openjdk.jmh.annotations._
 @BenchmarkMode(Array(Mode.Throughput))
 class StateTBench {
   @Param(Array("10"))
-  var count: Int = _
+  var count: Int = scala.compiletime.uninitialized
 
   @Benchmark
   def single(): Long =

bench/src/main/scala/cats/bench/TraverseBench.scala

@@ -38,16 +38,16 @@ class TraverseBench {
   val chainT: Traverse[Chain] = Traverse[Chain]
 
   // the unit of CPU work per iteration
-  private[this] val Work: Long = 10
+  private val Work: Long = 10
 
-  private[this] case object Failure extends RuntimeException
+  private case object Failure extends RuntimeException
 
   @Param(Array("10000"))
-  var length: Int = _
+  var length: Int = scala.compiletime.uninitialized
 
-  var list: List[Int] = _
-  var vector: Vector[Int] = _
-  var chain: Chain[Int] = _
+  var list: List[Int] = scala.compiletime.uninitialized
+  var vector: Vector[Int] = scala.compiletime.uninitialized
+  var chain: Chain[Int] = scala.compiletime.uninitialized
 
   @Setup
   def setup(): Unit = {

core/src/main/scala-2.13+/cats/data/NonEmptyLazyList.scala

@@ -475,7 +475,7 @@ class NonEmptyLazyListOps[A](private val value: NonEmptyLazyList[A])
    * }}}
    */
   final def toNem[T, U](implicit ev: A <:< (T, U), order: Order[T]): NonEmptyMap[T, U] =
-    NonEmptyMap.fromMapUnsafe(SortedMap(toLazyList.map(ev): _*)(order.toOrdering))
+    NonEmptyMap.fromMapUnsafe(SortedMap(toLazyList.map(ev)*)(order.toOrdering))
 
   /**
    * Creates new `NonEmptySet`, similarly to List#toSet from scala standard library.
@@ -488,7 +488,7 @@ class NonEmptyLazyListOps[A](private val value: NonEmptyLazyList[A])
    * }}}
    */
   final def toNes[B >: A](implicit order: Order[B]): NonEmptySet[B] =
-    NonEmptySet.of(head, tail: _*)
+    NonEmptySet.of(head, tail*)
 
   /**
    * Creates new `NonEmptyVector`, similarly to List#toVector from scala standard library.

core/src/main/scala-2.13+/cats/evidence/AsSupport.scala

@@ -22,7 +22,7 @@
 package cats.evidence
 
 private[evidence] trait AsSupport {
-  @inline implicit def asFromPredef[A, B](implicit ev: A <:< B): A As B = {
+  @inline implicit def asFromPredef[A, B](implicit ev: A <:< B): A `As` B = {
     // we need F to be covariant, and the type lambda loses that
     // if we write As[A, *]
     type F[+Z] = As[A, Z]

core/src/main/scala-2.13+/cats/evidence/IsSupport.scala

@@ -22,6 +22,6 @@
 package cats.evidence
 
 private[evidence] trait IsSupport {
-  @inline implicit def isFromPredef[A, B](implicit ev: A =:= B): A Is B =
+  @inline implicit def isFromPredef[A, B](implicit ev: A =:= B): A `Is` B =
     ev.substituteCo[Is[A, *]](Is.refl[A])
 }

core/src/main/scala/cats/Align.scala

@@ -149,8 +149,8 @@ object Align extends ScalaVersionSpecificAlignInstances {
 
   private[cats] def alignWithIterator[A, B, C](fa: Iterable[A], fb: Iterable[B])(f: Ior[A, B] => C): Iterator[C] =
     new Iterator[C] {
-      private[this] val iterA = fa.iterator
-      private[this] val iterB = fb.iterator
+      private val iterA = fa.iterator
+      private val iterB = fb.iterator
       def hasNext: Boolean = iterA.hasNext || iterB.hasNext
       def next(): C =
         f(

core/src/main/scala/cats/ApplicativeError.scala

@@ -196,7 +196,7 @@ trait ApplicativeError[F[_], E] extends Applicative[F] {
    * having originally been included in the `MonadError` API and syntax.
    */
   def adaptError[A](fa: F[A])(pf: PartialFunction[E, E]): F[A] =
-    recoverWith(fa)(pf.andThen(raiseError[A] _))
+    recoverWith(fa)(pf.andThen(raiseError[A]))
 
   /**
    * Returns a new value that transforms the result of the source,

core/src/main/scala/cats/Eval.scala

@@ -158,7 +158,7 @@ final case class Now[+A](value: A) extends Eval.Leaf[A] {
  * garbage collection.
  */
 final class Later[+A](f: () => A) extends Eval.Leaf[A] {
-  private[this] var thunk: () => A = f
+  private var thunk: () => A = f
 
   // The idea here is that `f` may have captured very large
   // structures, but produce a very small result. In this case, once

core/src/main/scala/cats/MonadError.scala

@@ -126,7 +126,7 @@ trait MonadError[F[_], E] extends ApplicativeError[F, E] with Monad[F] {
     rethrow(flatTap(attempt(fa))(f))
 
   override def adaptError[A](fa: F[A])(pf: PartialFunction[E, E]): F[A] =
-    recoverWith(fa)(pf.andThen(raiseError[A] _))
+    recoverWith(fa)(pf.andThen(raiseError[A]))
 }
 
 object MonadError {

core/src/main/scala/cats/NotNull.scala

@@ -42,9 +42,9 @@ object NotNull {
    * Since NotNull is just a marker trait with no functionality, it's safe to
    * reuse a single instance of it. This helps prevent unnecessary allocations.
    */
-  private[this] val singleton: NotNull[Any] = new NotNull[Any] {}
+  private val singleton: NotNull[Any] = new NotNull[Any] {}
 
-  private[this] def ambiguousException: Exception =
+  private def ambiguousException: Exception =
     new Exception(
       "An instance of NotNull[Null] was used. This should never happen. Both ambiguous NotNull[Null] instances should always be in scope if one of them is."
     )

core/src/main/scala/cats/SemigroupK.scala

@@ -146,7 +146,7 @@ trait SemigroupK[F[_]] extends Serializable { self =>
   /**
    * Return `a` combined with itself more than once.
    */
-  protected[this] def repeatedCombineNK[A](a: F[A], n: Int): F[A] = {
+  protected def repeatedCombineNK[A](a: F[A], n: Int): F[A] = {
     @tailrec def loop(b: F[A], k: Int, extra: F[A]): F[A] =
       if (k == 1) combineK(b, extra)
       else {

core/src/main/scala/cats/Show.scala

@@ -76,7 +76,7 @@ object Show extends ScalaVersionSpecificShowInstances with ShowInstances {
   }
 
   final case class ShowInterpolator(_sc: StringContext) extends AnyVal {
-    def show(args: Shown*): String = _sc.s(args: _*)
+    def show(args: Shown*): String = _sc.s(args*)
   }
 
   implicit val catsContravariantForShow: Contravariant[Show] = new Contravariant[Show] {

core/src/main/scala/cats/data/AndThen.scala

@@ -272,7 +272,7 @@ abstract private[data] class AndThenInstances0 extends AndThenInstances1 {
   implicit def catsDataMonadForAndThen[T]: Monad[AndThen[T, *]] =
     new Monad[AndThen[T, *]] {
       // Piggybacking on the instance for Function1
-      private[this] val fn1 = instances.all.catsStdMonadForFunction1[T]
+      private val fn1 = instances.all.catsStdMonadForFunction1[T]
 
       def pure[A](x: A): AndThen[T, A] =
         AndThen(fn1.pure[A](x))
@@ -293,7 +293,7 @@ abstract private[data] class AndThenInstances0 extends AndThenInstances1 {
   implicit def catsDataContravariantMonoidalForAndThen[R: Monoid]: ContravariantMonoidal[AndThen[*, R]] =
     new ContravariantMonoidal[AndThen[*, R]] {
       // Piggybacking on the instance for Function1
-      private[this] val fn1 = instances.all.catsStdContravariantMonoidalForFunction1[R]
+      private val fn1 = instances.all.catsStdContravariantMonoidalForFunction1[R]
 
       def unit: AndThen[Unit, R] =
         AndThen(fn1.unit)
@@ -313,7 +313,7 @@ abstract private[data] class AndThenInstances0 extends AndThenInstances1 {
   implicit val catsDataArrowForAndThen: ArrowChoice[AndThen] & CommutativeArrow[AndThen] =
     new ArrowChoice[AndThen] with CommutativeArrow[AndThen] {
       // Piggybacking on the instance for Function1
-      private[this] val fn1 = instances.all.catsStdInstancesForFunction1
+      private val fn1 = instances.all.catsStdInstancesForFunction1
 
       def choose[A, B, C, D](f: AndThen[A, C])(g: AndThen[B, D]): AndThen[Either[A, B], Either[C, D]] =
         AndThen(fn1.choose(f)(g))

core/src/main/scala/cats/data/Chain.scala

@@ -1292,9 +1292,9 @@ object Chain extends ChainInstances with ChainCompanionCompat {
         case _                => null: NonEmpty[A]
       })
 
-    private[this] var c: NonEmpty[A] = self
-    private[this] var rights: List[NonEmpty[A]] = Nil
-    private[this] var currentIterator: Iterator[A] = null
+    private var c: NonEmpty[A] = self
+    private var rights: List[NonEmpty[A]] = Nil
+    private var currentIterator: Iterator[A] = null
 
     override def hasNext: Boolean = (c ne null) || ((currentIterator ne null) && currentIterator.hasNext)
 
@@ -1345,9 +1345,9 @@ object Chain extends ChainInstances with ChainCompanionCompat {
         case _                => null: NonEmpty[A]
       })
 
-    private[this] var c: NonEmpty[A] = self
-    private[this] var lefts: List[NonEmpty[A]] = Nil
-    private[this] var currentIterator: Iterator[A] = null
+    private var c: NonEmpty[A] = self
+    private var lefts: List[NonEmpty[A]] = Nil
+    private var currentIterator: Iterator[A] = null
 
     override def hasNext: Boolean = (c ne null) || ((currentIterator ne null) && currentIterator.hasNext)
 
@@ -1612,7 +1612,7 @@ sealed abstract private[data] class ChainInstances extends ChainInstances1 {
 
   }
 
-  private[this] val theMonoid: Monoid[Chain[Any]] = new Monoid[Chain[Any]] {
+  private val theMonoid: Monoid[Chain[Any]] = new Monoid[Chain[Any]] {
     def empty: Chain[Any] = Chain.nil
 
     def combine(c: Chain[Any], c2: Chain[Any]): Chain[Any] = Chain.concat(c, c2)

core/src/main/scala/cats/data/Const.scala

@@ -96,9 +96,9 @@ sealed abstract private[data] class ConstInstances extends ConstInstances0 {
       override def minBound: Const[A, B] = Const(A.minBound)
     }
 
-  implicit def catsDataOrderForConst[A: Order, B]: Order[Const[A, B]] = _ compare _
+  implicit def catsDataOrderForConst[A: Order, B]: Order[Const[A, B]] = _ `compare` _
 
-  implicit def catsDataPartialOrderForConst[A: PartialOrder, B]: PartialOrder[Const[A, B]] = _ partialCompare _
+  implicit def catsDataPartialOrderForConst[A: PartialOrder, B]: PartialOrder[Const[A, B]] = _ `partialCompare` _
 
   implicit def catsDataAlignForConst[A: Semigroup]: Align[Const[A, *]] =
     new Align[Const[A, *]] {
@@ -159,7 +159,7 @@ sealed abstract private[data] class ConstInstances extends ConstInstances0 {
         x.combine(y)
     }
 
-  implicit def catsDataSemigroupForConst[A: Semigroup, B]: Semigroup[Const[A, B]] = _ combine _
+  implicit def catsDataSemigroupForConst[A: Semigroup, B]: Semigroup[Const[A, B]] = _ `combine` _
 
   implicit val catsDataBifoldableForConst: Bifoldable[Const] =
     new Bifoldable[Const] {

core/src/main/scala/cats/data/IndexedStateT.scala

@@ -530,7 +530,7 @@ sealed abstract private[data] class IndexedStateTMonadError[F[_], S, E]
     IndexedStateT(s => F.handleErrorWith(fa.run(s))(e => f(e).run(s)))
 }
 
-private[this] trait IndexedStateTFunctorFilter[F[_], SA, SB] extends FunctorFilter[IndexedStateT[F, SA, SB, *]] {
+private trait IndexedStateTFunctorFilter[F[_], SA, SB] extends FunctorFilter[IndexedStateT[F, SA, SB, *]] {
 
   implicit def F0: Monad[F]
   def FF: FunctorFilter[F]