Use scala version driven import on Captor macro (#361)

Author: ultrasecreth

.bsp/sbt.json

@@ -1 +1 @@
-{"name":"sbt","version":"1.4.6","bspVersion":"2.0.0-M5","languages":["scala"],"argv":["/Library/Java/JavaVirtualMachines/adoptopenjdk-11.jdk/Contents/Home/bin/java","-Xms100m","-Xmx100m","-classpath","/Users/bbonanno/Library/Application Support/JetBrains/IntelliJIdea2020.3/plugins/Scala/launcher/sbt-launch.jar","xsbt.boot.Boot","-bsp"]}
+{"name":"sbt","version":"1.4.7","bspVersion":"2.0.0-M5","languages":["scala"],"argv":["/Library/Java/JavaVirtualMachines/adoptopenjdk-11.jdk/Contents/Home/bin/java","-Xms100m","-Xmx100m","-classpath","/Users/bbonanno/Library/Application Support/JetBrains/IntelliJIdea2020.3/plugins/Scala/launcher/sbt-launch.jar","xsbt.boot.Boot","-bsp"]}

macro-common/src/main/scala/org/mockito/internal/ScalaVersion.scala

@@ -0,0 +1,18 @@
+package org.mockito.internal
+
+import scala.util.Properties
+
+sealed trait ScalaVersion
+object ScalaVersion {
+  case object V2_11 extends ScalaVersion
+  case object V2_12 extends ScalaVersion
+  case object V2_13 extends ScalaVersion
+
+  val Current: ScalaVersion = {
+    val version = Properties.scalaPropOrElse("version.number", "unknown")
+    if (version.startsWith("2.11")) ScalaVersion.V2_11
+    else if (version.startsWith("2.12")) ScalaVersion.V2_12
+    else if (version.startsWith("2.13")) ScalaVersion.V2_13
+    else throw new Exception(s"Unsupported scala version $version")
+  }
+}

macro-common/src/main/scala/org/mockito/internal/ValueClassExtractor.scala

@@ -1,9 +1,9 @@
 package org.mockito.internal
 
 import org.mockito.internal.MacroDebug.debugResult
+import org.mockito.internal.ScalaVersion.{ V2_11, V2_12, V2_13 }
 
 import scala.reflect.macros.blackbox
-import scala.util.Properties
 
 trait ValueClassExtractor[VC] extends Serializable {
   def isValueClass: Boolean = true
@@ -30,8 +30,6 @@ class ReflectionExtractor[VC] extends ValueClassExtractor[VC] {
 object ValueClassExtractor {
   def apply[T: ValueClassExtractor]: ValueClassExtractor[T] = implicitly[ValueClassExtractor[T]]
 
-  private val ScalaVersion = Properties.scalaPropOrElse("version.number", "unknown")
-
   implicit def instance[VC]: ValueClassExtractor[VC] = macro materialise[VC]
 
   def materialise[VC: c.WeakTypeTag](c: blackbox.Context): c.Expr[ValueClassExtractor[VC]] = {
@@ -41,24 +39,25 @@ object ValueClassExtractor {
     val isValueClass = typeSymbol.isClass && typeSymbol.asClass.isDerivedValueClass
 
     val r =
-      if (isValueClass)
-        if (ScalaVersion.startsWith("2.12") || ScalaVersion.startsWith("2.13"))
-          c.Expr[ValueClassExtractor[VC]](q"new _root_.org.mockito.internal.ReflectionExtractor[$tpe]")
-        else if (ScalaVersion.startsWith("2.11"))
-          c.Expr[ValueClassExtractor[VC]] {
-            val companion = typeSymbol.companion
+      if (isValueClass) {
+        ScalaVersion.Current match {
+          case V2_12 | V2_13 =>
+            c.Expr[ValueClassExtractor[VC]](q"new _root_.org.mockito.internal.ReflectionExtractor[$tpe]")
+          case V2_11 =>
+            c.Expr[ValueClassExtractor[VC]] {
+              val companion = typeSymbol.companion
 
-            if (companion.info.decls.exists(_.name.toString == "unapply"))
-              q"""
-            new _root_.org.mockito.internal.ValueClassExtractor[$tpe] {
-              override def extract(vc: $tpe): Any = $companion.unapply(vc).get
+              if (companion.info.decls.exists(_.name.toString == "unapply"))
+                q"""
+                  new _root_.org.mockito.internal.ValueClassExtractor[$tpe] {
+                    override def extract(vc: $tpe): Any = $companion.unapply(vc).get
+                  }
+                 """
+              else
+                q"new _root_.org.mockito.internal.NormalClassExtractor[$tpe]"
             }
-           """
-            else
-              q"new _root_.org.mockito.internal.NormalClassExtractor[$tpe]"
-          }
-        else throw new Exception(s"Unsupported scala version $ScalaVersion")
-      else
+        }
+      } else
         c.Expr[ValueClassExtractor[VC]](q"new _root_.org.mockito.internal.NormalClassExtractor[$tpe]")
 
     debugResult(c)("mockito-print-extractor")(r.tree)

macro/src/main/scala/org/mockito/captor/Captor.scala

@@ -1,17 +1,19 @@
 package org.mockito.captor
 
-import org.mockito.internal.MacroDebug.debugResult
+import org.mockito.exceptions.base.MockitoAssertionError
 import org.mockito.exceptions.verification.{ ArgumentsAreDifferent, TooFewActualInvocations, TooManyActualInvocations }
+import org.mockito.internal.MacroDebug.debugResult
+import org.mockito.internal.ScalaVersion
+import org.mockito.internal.ScalaVersion.{ V2_11, V2_12, V2_13 }
 import org.mockito.{ clazz, ArgumentCaptor }
 import org.scalactic.Equality
 import org.scalactic.TripleEquals._
+
 import scala.collection.JavaConverters._
 import scala.reflect.ClassTag
 import scala.reflect.macros.blackbox
 import scala.util.{ Failure, Try }
 
-import org.mockito.exceptions.base.MockitoAssertionError
-
 trait Captor[T] {
   def capture: T
 
@@ -75,10 +77,15 @@ object Captor {
         .head
       val paramType = tpe.decl(param.name).typeSignature.finalResultType
 
+      val collectionConverters = ScalaVersion.Current match {
+        case V2_11 | V2_12 => q"import _root_.scala.collection.JavaConverters._"
+        case V2_13         => q"import _root_.scala.jdk.CollectionConverters._"
+      }
+
       q"""
       new _root_.org.mockito.captor.Captor[$tpe] {
 
-        import _root_.scala.collection.JavaConverters._
+        $collectionConverters
 
         private val argumentCaptor = _root_.org.mockito.ArgumentCaptor.forClass(classOf[$paramType])