scalafmt: set rewrite.scala3.convertToNewSyntax = true

Author: satorg

.scalafmt.conf

@@ -4,6 +4,7 @@ runner.dialect = scala213source3
 docstrings.style = asterisk
 maxColumn = 180
 rewrite.rules = [RedundantBraces, RedundantParens, SortImports]
+rewrite.scala3.convertToNewSyntax = true
 spaces.inImportCurlyBraces = true
 indentOperator.preset = spray
 

cats/src/main/scala/org/mockito/cats/CatsStubbing.scala

@@ -338,7 +338,7 @@ case class CatsStubbing[F[_], T](delegate: OngoingStubbing[F[T]]) {
 //             |""".stripMargin)
 //  }
 
-  def thenFailWith[E](error: E)(implicit F: ApplicativeError[F, _ >: E]): CatsStubbing[F, T] =
+  def thenFailWith[E](error: E)(implicit F: ApplicativeError[F, ? >: E]): CatsStubbing[F, T] =
     delegate thenReturn F.raiseError[T](error)
 
   def getMock[M]: M = delegate.getMock[M]
@@ -688,7 +688,7 @@ case class CatsStubbing2[F[_], G[_], T](delegate: OngoingStubbing[F[G[T]]]) {
 //             |""".stripMargin)
 //  }
 
-  def thenFailWith[E](error: E)(implicit ae: Applicative[F], ag: ApplicativeError[G, _ >: E]): CatsStubbing2[F, G, T] =
+  def thenFailWith[E](error: E)(implicit ae: Applicative[F], ag: ApplicativeError[G, ? >: E]): CatsStubbing2[F, G, T] =
     delegate thenReturn ae.pure(ag.raiseError[T](error))
 
   def getMock[M]: M = delegate.getMock[M]

cats/src/main/scala/org/mockito/cats/EqToEquality.scala

@@ -1,7 +1,7 @@
 package org.mockito.cats
 
 import cats.Eq
-import cats.syntax.eq._
+import cats.syntax.eq.*
 import org.scalactic.Equality
 
 class EqToEquality[T: Eq] extends Equality[T] {

cats/src/main/scala/org/mockito/cats/IdiomaticMockitoCats.scala

@@ -1,13 +1,13 @@
 package org.mockito.cats
 
 import cats.{ Applicative, ApplicativeError, Eq }
-import org.mockito._
+import org.mockito.*
 import org.scalactic.Equality
 
 import scala.reflect.ClassTag
 
 trait IdiomaticMockitoCats extends ScalacticSerialisableHack {
-  import org.mockito.cats.IdiomaticMockitoCats._
+  import org.mockito.cats.IdiomaticMockitoCats.*
 
   implicit class StubbingOpsCats[F[_], T](stubbing: F[T]) {
     def shouldReturnF: ReturnActions[F, T] = macro WhenMacro.shouldReturn[T]
@@ -128,12 +128,12 @@ object IdiomaticMockitoCats extends IdiomaticMockitoCats {
 
   object Raised
   case class Raised[T]() {
-    def by[F[_], E](stubbing: F[E])(implicit F: ApplicativeError[F, _ >: T]): F[E] = macro DoSomethingMacro.raised[E]
+    def by[F[_], E](stubbing: F[E])(implicit F: ApplicativeError[F, ? >: T]): F[E] = macro DoSomethingMacro.raised[E]
   }
 
   object RaisedG
   case class RaisedG[T]() {
-    def by[F[_], G[_], E](stubbing: F[G[E]])(implicit F: Applicative[F], G: ApplicativeError[G, _ >: T]): F[G[E]] =
+    def by[F[_], G[_], E](stubbing: F[G[E]])(implicit F: Applicative[F], G: ApplicativeError[G, ? >: T]): F[G[E]] =
       macro DoSomethingMacro.raisedG[E]
   }
 
@@ -146,11 +146,11 @@ object IdiomaticMockitoCats extends IdiomaticMockitoCats {
   }
 
   class ThrowActions[F[_], T](os: CatsStubbing[F, T]) {
-    def apply[E](error: E)(implicit ae: ApplicativeError[F, _ >: E]): CatsStubbing[F, T] = os thenFailWith error
+    def apply[E](error: E)(implicit ae: ApplicativeError[F, ? >: E]): CatsStubbing[F, T] = os thenFailWith error
   }
 
   class ThrowActions2[F[_], G[_], T](os: CatsStubbing2[F, G, T]) {
-    def apply[E](error: E)(implicit ae: Applicative[F], ag: ApplicativeError[G, _ >: E]): CatsStubbing2[F, G, T] = os thenFailWith error
+    def apply[E](error: E)(implicit ae: Applicative[F], ag: ApplicativeError[G, ? >: E]): CatsStubbing2[F, G, T] = os thenFailWith error
   }
 
   class AnswerActions[F[_], T](os: CatsStubbing[F, T]) {

cats/src/main/scala/org/mockito/cats/MockitoCats.scala

@@ -1,7 +1,7 @@
 package org.mockito.cats
 
 import cats.{ Applicative, ApplicativeError, Eq }
-import org.mockito._
+import org.mockito.*
 import org.mockito.invocation.InvocationOnMock
 import org.mockito.stubbing.Stubber
 import org.scalactic.Equality
@@ -16,33 +16,33 @@ trait MockitoCats extends ScalacticSerialisableHack {
   def doReturnF[F[_]: Applicative, T](toBeReturned: T, toBeReturnedNext: T*): Stubber =
     Mockito.doReturn(
       Applicative[F].pure(toBeReturned),
-      toBeReturnedNext.map(Applicative[F].pure).map(_.asInstanceOf[Object]): _*
+      toBeReturnedNext.map(Applicative[F].pure).map(_.asInstanceOf[Object])*
     )
 
   def doReturnFG[F[_]: Applicative, G[_]: Applicative, T](toBeReturned: T, toBeReturnedNext: T*): Stubber =
     Mockito.doReturn(
       Applicative[F].compose[G].pure(toBeReturned),
-      toBeReturnedNext.map(Applicative[F].compose[G].pure(_)).map(_.asInstanceOf[Object]): _*
+      toBeReturnedNext.map(Applicative[F].compose[G].pure(_)).map(_.asInstanceOf[Object])*
     )
 
   def doFailWith[F[_], E, T](error: E, errors: E*)(implicit ae: ApplicativeError[F, E]): Stubber =
     Mockito.doReturn(
       ae.raiseError[T](error),
-      errors.map(e => ae.raiseError[T](e)).map(_.asInstanceOf[Object]): _*
+      errors.map(e => ae.raiseError[T](e)).map(_.asInstanceOf[Object])*
     )
 
   def doFailWithG[F[_]: Applicative, G[_], E, T](error: E, errors: E*)(implicit ae: ApplicativeError[G, E]): Stubber =
     Mockito.doReturn(
       Applicative[F].pure(ae.raiseError[T](error)),
-      errors.map(e => ae.raiseError[T](e)).map(Applicative[F].pure).map(_.asInstanceOf[Object]): _*
+      errors.map(e => ae.raiseError[T](e)).map(Applicative[F].pure).map(_.asInstanceOf[Object])*
     )
 
   def doAnswerF[F[_]: Applicative, R](l: => R): Stubber =
     Mockito.doAnswer(invocationToAnswer { _ =>
       // Store the param so we don't evaluate the by-name twice
       val _l = l
       _l match {
-        case f: Function0[_] => f()
+        case f: Function0[?] => f()
         case _               => _l
       }
     }.andThen(Applicative[F].pure))
@@ -79,7 +79,7 @@ trait MockitoCats extends ScalacticSerialisableHack {
       // Store the param so we don't evaluate the by-name twice
       val _l = l
       _l match {
-        case f: Function0[_] => f()
+        case f: Function0[?] => f()
         case _               => _l
       }
     }.andThen(Applicative[F].compose[G].pure))

cats/src/main/scala/org/mockito/cats/instances/argumentMatcher.scala

@@ -1,8 +1,8 @@
 package org.mockito.cats
 
-import cats._
+import cats.*
 import org.mockito.ArgumentMatcher
-import org.mockito.matchers._
+import org.mockito.matchers.*
 
 trait ArgumentMatcherInstances {
   implicit val argumentMatcherInstance: ContravariantMonoidal[ArgumentMatcher] with MonoidK[ArgumentMatcher] =

cats/src/test/scala/org/mockito/cats/DoSomethingCatsTest.scala

@@ -1,7 +1,7 @@
 package org.mockito.cats
 
 import org.mockito.invocation.InvocationOnMock
-import org.mockito._
+import org.mockito.*
 import org.scalatest.concurrent.ScalaFutures
 import org.scalatest.{ EitherValues, OptionValues }
 

cats/src/test/scala/org/mockito/cats/IdiomaticMockitoCatsTest.scala

@@ -2,7 +2,7 @@ package org.mockito.cats
 
 import cats.Eq
 import org.mockito.invocation.InvocationOnMock
-import org.mockito._
+import org.mockito.*
 import org.scalatest.concurrent.ScalaFutures
 import org.scalatest.{ EitherValues, OptionValues }
 

cats/src/test/scala/org/mockito/cats/MockitoCatsTest.scala

@@ -3,7 +3,7 @@ package org.mockito.cats
 import cats.Eq
 import cats.data.{ EitherT, OptionT }
 import org.mockito.invocation.InvocationOnMock
-import org.mockito._
+import org.mockito.*
 import org.scalatest.concurrent.ScalaFutures
 import org.scalatest.{ EitherValues, OptionValues }
 

cats/src/test/scala/org/mockito/cats/instances/ArgumentMatcherInstancesTest.scala

@@ -2,12 +2,12 @@ package org.mockito.cats
 package instances
 
 import cats.{ Contravariant, Eq }
-import cats.implicits._
-import cats.laws.discipline._
-import cats.laws.discipline.arbitrary._
-import cats.laws.discipline.eq._
+import cats.implicits.*
+import cats.laws.discipline.*
+import cats.laws.discipline.arbitrary.*
+import cats.laws.discipline.eq.*
 import org.mockito.{ ArgumentMatcher, ArgumentMatchers, ArgumentMatchersSugar, IdiomaticMockito }
-import org.mockito.internal.matchers._
+import org.mockito.internal.matchers.*
 import org.mockito.matchers.{ EqTo, Generators }
 import org.scalacheck.Arbitrary
 import org.scalatest.matchers.should.Matchers
@@ -16,7 +16,7 @@ import org.scalatest.prop.Configuration
 import org.typelevel.discipline.scalatest.FunSuiteDiscipline
 
 class ArgumentMatcherInstancesTest extends AnyFunSuiteLike with FunSuiteDiscipline with Configuration with ArgumentMatchersSugar with IdiomaticMockito with Matchers {
-  import Generators._
+  import Generators.*
 
   implicit def eqArgumentMatcherExhaustive[A: ExhaustiveCheck]: Eq[ArgumentMatcher[A]] =
     Eq.instance((f, g) => ExhaustiveCheck[A].allValues.forall(a => f.matches(a) == g.matches(a)))