Add "-Xsource:3" compiler option (#587)

* add "-Xsource:3" compiler option;
address compatibility warnings

* scalafmt: set `runner.dialect = scala213source3`

* scalafmt: set `rewrite.scala3.convertToNewSyntax = true`

Author: satorg

.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 }