Add "-Xsource:3" compiler option

.scalafmt.conf

@@ -1,11 +1,11 @@
 style = defaultWithAlign
 
-runner.dialect = scala213
+runner.dialect = scala213source3
 docstrings.style = asterisk
 maxColumn = 180
 rewrite.rules = [RedundantBraces, RedundantParens, SortImports]
+rewrite.scala3.convertToNewSyntax = true
 spaces.inImportCurlyBraces = true
 indentOperator.preset = spray
 
-version=3.9.9
-
+version = 3.9.9

build.sbt

@@ -23,13 +23,12 @@ lazy val commonSettings =
       "-encoding",
       "UTF-8",
       "-Xfatal-warnings",
+      "-Xsource:3",
 //      "-Xmacro-settings:mockito-print-when,mockito-print-do-something,mockito-print-verify,mockito-print-expect,mockito-print-captor,mockito-print-matcher,mockito-print-extractor,mockito-print-wrapper,mockito-print-lenient",
       "-language:reflectiveCalls,implicitConversions,experimental.macros,higherKinds"
     ),
     scalacOptions ++= {
       CrossVersion.partialVersion(scalaVersion.value) match {
-        case Some((2, 11)) =>
-          Seq("-Xsource:2.12", "-Ypartial-unification")
         case Some((2, 12)) =>
           Seq("-Ypartial-unification", "-Ywarn-unused:locals")
         case Some((2, 13)) =>

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)))

common/src/main/scala-2.12/org/mockito/internal/handler/package.scala

@@ -5,7 +5,7 @@ import scala.collection.mutable
 package object handler {
   def unwrapVarargs(args: Array[Any]): Array[Any] =
     args.lastOption match {
-      case Some(arg: mutable.WrappedArray[_]) => args.init ++ arg
+      case Some(arg: mutable.WrappedArray[?]) => args.init ++ arg
       case _                                  => args
     }
 }

common/src/main/scala-2.12/org/mockito/stubbing/ReturnsEmptyValues.scala

@@ -13,27 +13,27 @@ import scala.util.{ Failure, Try }
 object ReturnsEmptyValues extends DefaultAnswer {
   private val javaEmptyValuesAndPrimitives = new ReturnsMoreEmptyValues
 
-  private[mockito] lazy val emptyValues: Map[Class[_], AnyRef] = Map(
-    classOf[Option[_]]      -> Option.empty,
-    classOf[List[_]]        -> List.empty,
-    classOf[Set[_]]         -> Set.empty,
-    classOf[Seq[_]]         -> Seq.empty,
-    classOf[Iterable[_]]    -> Iterable.empty,
-    classOf[Traversable[_]] -> Traversable.empty,
-    classOf[IndexedSeq[_]]  -> IndexedSeq.empty,
-    classOf[Iterator[_]]    -> Iterator.empty,
-    classOf[Stream[_]]      -> Stream.empty,
-    classOf[Vector[_]]      -> Vector.empty,
-    classOf[Try[_]]         -> Failure(new MockitoException("Auto stub provided by mockito-scala")),
-    classOf[Future[_]]      -> Future.failed(new MockitoException("Auto stub provided by mockito-scala")),
+  private[mockito] lazy val emptyValues: Map[Class[?], AnyRef] = Map(
+    classOf[Option[?]]      -> Option.empty,
+    classOf[List[?]]        -> List.empty,
+    classOf[Set[?]]         -> Set.empty,
+    classOf[Seq[?]]         -> Seq.empty,
+    classOf[Iterable[?]]    -> Iterable.empty,
+    classOf[Traversable[?]] -> Traversable.empty,
+    classOf[IndexedSeq[?]]  -> IndexedSeq.empty,
+    classOf[Iterator[?]]    -> Iterator.empty,
+    classOf[Stream[?]]      -> Stream.empty,
+    classOf[Vector[?]]      -> Vector.empty,
+    classOf[Try[?]]         -> Failure(new MockitoException("Auto stub provided by mockito-scala")),
+    classOf[Future[?]]      -> Future.failed(new MockitoException("Auto stub provided by mockito-scala")),
     classOf[BigDecimal]     -> BigDecimal(0),
     classOf[BigInt]         -> BigInt(0),
     classOf[StringBuilder]  -> StringBuilder.newBuilder,
-    classOf[Map[_, _]]      -> Map.empty,
-    classOf[ListBuffer[_]]  -> ListBuffer.empty,
-    classOf[mutable.Seq[_]] -> ListBuffer.empty,
-    classOf[mutable.Set[_]] -> mutable.HashSet.empty,
-    classOf[Either[_, _]]   -> Left("Auto stub provided by mockito-scala")
+    classOf[Map[?, ?]]      -> Map.empty,
+    classOf[ListBuffer[?]]  -> ListBuffer.empty,
+    classOf[mutable.Seq[?]] -> ListBuffer.empty,
+    classOf[mutable.Set[?]] -> mutable.HashSet.empty,
+    classOf[Either[?, ?]]   -> Left("Auto stub provided by mockito-scala")
   )
 
   override def apply(invocation: InvocationOnMock): Option[Any] =

common/src/main/scala-2.13/org/mockito/internal/handler/package.scala

@@ -5,7 +5,7 @@ import scala.collection.immutable.ArraySeq
 package object handler {
   def unwrapVarargs(args: Array[Any]): Array[Any] =
     args.lastOption match {
-      case Some(arg: ArraySeq[_]) => args.init ++ arg
+      case Some(arg: ArraySeq[?]) => args.init ++ arg
       case _                      => args
     }
 }

common/src/main/scala-2.13/org/mockito/stubbing/ReturnsEmptyValues.scala

@@ -13,26 +13,26 @@ import scala.util.{ Failure, Try }
 object ReturnsEmptyValues extends DefaultAnswer {
   private val javaEmptyValuesAndPrimitives = new ReturnsMoreEmptyValues
 
-  private[mockito] lazy val emptyValues: Map[Class[_], AnyRef] = Map(
-    classOf[Option[_]]      -> Option.empty,
-    classOf[List[_]]        -> List.empty,
-    classOf[Set[_]]         -> Set.empty,
-    classOf[Seq[_]]         -> Seq.empty,
-    classOf[Iterable[_]]    -> Iterable.empty,
-    classOf[IndexedSeq[_]]  -> IndexedSeq.empty,
-    classOf[Iterator[_]]    -> Iterator.empty,
-    classOf[LazyList[_]]    -> LazyList.empty,
-    classOf[Vector[_]]      -> Vector.empty,
-    classOf[Try[_]]         -> Failure(new MockitoException("Auto stub provided by mockito-scala")),
-    classOf[Future[_]]      -> Future.failed(new MockitoException("Auto stub provided by mockito-scala")),
+  private[mockito] lazy val emptyValues: Map[Class[?], AnyRef] = Map(
+    classOf[Option[?]]      -> Option.empty,
+    classOf[List[?]]        -> List.empty,
+    classOf[Set[?]]         -> Set.empty,
+    classOf[Seq[?]]         -> Seq.empty,
+    classOf[Iterable[?]]    -> Iterable.empty,
+    classOf[IndexedSeq[?]]  -> IndexedSeq.empty,
+    classOf[Iterator[?]]    -> Iterator.empty,
+    classOf[LazyList[?]]    -> LazyList.empty,
+    classOf[Vector[?]]      -> Vector.empty,
+    classOf[Try[?]]         -> Failure(new MockitoException("Auto stub provided by mockito-scala")),
+    classOf[Future[?]]      -> Future.failed(new MockitoException("Auto stub provided by mockito-scala")),
     classOf[BigDecimal]     -> BigDecimal(0),
     classOf[BigInt]         -> BigInt(0),
     classOf[StringBuilder]  -> new StringBuilder,
-    classOf[Map[_, _]]      -> Map.empty,
-    classOf[ListBuffer[_]]  -> ListBuffer.empty,
-    classOf[mutable.Seq[_]] -> ListBuffer.empty,
-    classOf[mutable.Set[_]] -> mutable.HashSet.empty,
-    classOf[Either[_, _]]   -> Left("Auto stub provided by mockito-scala")
+    classOf[Map[?, ?]]      -> Map.empty,
+    classOf[ListBuffer[?]]  -> ListBuffer.empty,
+    classOf[mutable.Seq[?]] -> ListBuffer.empty,
+    classOf[mutable.Set[?]] -> mutable.HashSet.empty,
+    classOf[Either[?, ?]]   -> Left("Auto stub provided by mockito-scala")
   )
 
   override def apply(invocation: InvocationOnMock): Option[Any] =

common/src/main/scala/org/mockito/JavaReflectionUtils.scala

@@ -11,7 +11,7 @@ import scala.util.control.NonFatal
  */
 object JavaReflectionUtils {
 
-  def resolveWithJavaGenerics(invocation: InvocationOnMock): Option[Class[_]] =
+  def resolveWithJavaGenerics(invocation: InvocationOnMock): Option[Class[?]] =
     try Some(GenericsResolver.resolve(invocation.getMock.getClass).`type`(invocation.method.getDeclaringClass).method(invocation.method).resolveReturnClass())
     catch {
       case _: Throwable => None
@@ -20,7 +20,7 @@ object JavaReflectionUtils {
   def setFinalStatic(field: Field, newValue: AnyRef): Unit =
     try {
       // Try to get Unsafe instance (works with both sun.misc.Unsafe and jdk.internal.misc.Unsafe)
-      val unsafeClass: Class[_] =
+      val unsafeClass: Class[?] =
         try
           Class.forName("sun.misc.Unsafe")
         catch {