[2.x] refactor: Use scala.jdk.OptionConverters instead of JavaInterfaceUtil (#9200)

main/src/main/scala/sbt/Defaults.scala

@@ -28,7 +28,6 @@ import sbt.internal.CommandStrings.ExportStream
 import sbt.internal.CompileDebugLogger
 import sbt.internal.*
 import sbt.internal.classpath.AlternativeZincUtil
-import sbt.internal.inc.JavaInterfaceUtil.*
 import sbt.internal.inc.classpath.ClasspathFilter
 import sbt.internal.inc.{ CompileOutput, MappedFileConverter, Stamps, ZincLmUtil, ZincUtil }
 import sbt.internal.librarymanagement.mavenint.{
@@ -77,6 +76,7 @@ import sjsonnew.*
 import scala.annotation.nowarn
 import scala.collection.immutable.ListMap
 import scala.concurrent.duration.*
+import scala.jdk.OptionConverters.*
 import scala.util.control.NonFatal
 import scala.xml.NodeSeq
 
@@ -509,7 +509,7 @@ object Defaults extends BuildCommon with DefExtra {
               Some(path.toFile.getAbsoluteFile)
             } catch {
               case NonFatal(_) => None
-            }).toOptional
+            }).toJava
 
           override def startOffset(): Optional[Integer] = pos.startOffset()
 
@@ -1083,7 +1083,7 @@ object Defaults extends BuildCommon with DefExtra {
                   crossTarget.value / s"${prefix(configuration.value.name)}classes.bak",
                   streams.value.log
                 ): ClassFileManagerType
-            ).toOptional
+            ).toJava
           )
           .withPipelining(usePipelining.value)
       },
@@ -2141,7 +2141,7 @@ object Defaults extends BuildCommon with DefExtra {
     val contents = store.unsafeGet()
     if (exportP) {
       // this stores the early analysis (again) in case the subproject contains a macro
-      setup.earlyAnalysisStore.toOption map { earlyStore =>
+      setup.earlyAnalysisStore.toScala map { earlyStore =>
         earlyStore.set(contents)
       }
     }
@@ -2163,7 +2163,7 @@ object Defaults extends BuildCommon with DefExtra {
       earlyOutputPing.await.value
     }) {
       val store = analysisStore(earlyCompileAnalysisFile)
-      store.get.toOption match {
+      store.get.toScala match {
         case Some(contents) => contents.getAnalysis
         case _              => Analysis.empty
       }
@@ -2316,7 +2316,7 @@ object Defaults extends BuildCommon with DefExtra {
       Keys.classpathEntryDefinesClassVF.value
     val lookup = new PerClasspathEntryLookup:
       override def analysis(classpathEntry: VirtualFile): Optional[CompileAnalysis] =
-        cachedAnalysisMap.get(classpathEntry).toOptional
+        cachedAnalysisMap.get(classpathEntry).toJava
       override def definesClass(classpathEntry: VirtualFile): DefinesClass =
         cachedPerEntryDefinesClassLookup(classpathEntry)
     val extra = extraIncOptions.value.map(t2)
@@ -2329,8 +2329,8 @@ object Defaults extends BuildCommon with DefExtra {
       compilerCache.value,
       incOptions.value,
       (compile / bspReporter).value,
-      Some((compile / compileProgress).value).toOptional,
-      eaOpt.toOptional,
+      Some((compile / compileProgress).value).toJava,
+      eaOpt.toJava,
       extra.toArray,
     )
   }
@@ -2362,10 +2362,10 @@ object Defaults extends BuildCommon with DefExtra {
             foldMappers(sourcePositionMappers.value, reportAbsolutePath.value, fileConverter.value)
           ),
           compileOrder.value,
-          None.toOptional: Optional[NioPath],
-          Some(fileConverter.value).toOptional,
-          Some(reusableStamper.value).toOptional,
-          eoOpt.toOptional,
+          None.toJava: Optional[NioPath],
+          Some(fileConverter.value).toJava,
+          Some(reusableStamper.value).toJava,
+          eoOpt.toJava,
         )
       },
       compilerReporter := Def.uncached {
@@ -2431,15 +2431,15 @@ object Defaults extends BuildCommon with DefExtra {
   }
 
   private[sbt] def none[A]: Option[A] = (None: Option[A])
-  private[sbt] def jnone[A]: Optional[A] = none[A].toOptional
+  private[sbt] def jnone[A]: Optional[A] = none[A].toJava
   def compileAnalysisSettings: Seq[Setting[?]] = Seq(
     previousCompile := Def.uncached {
       val setup = compileIncSetup.value
       val store = analysisStore(compileAnalysisFile)
-      val prev = store.get().toOption match {
+      val prev = store.get().toScala match {
         case Some(contents) =>
-          val analysis = Option(contents.getAnalysis).toOptional
-          val setup = Option(contents.getMiniSetup).toOptional
+          val analysis = Option(contents.getAnalysis).toJava
+          val setup = Option(contents.getMiniSetup).toJava
           PreviousResult.of(analysis, setup)
         case None => PreviousResult.of(jnone[CompileAnalysis], jnone[MiniSetup])
       }

main/src/main/scala/sbt/internal/server/BuildServerReporter.scala

@@ -24,6 +24,7 @@ import xsbti.{
 }
 
 import scala.jdk.CollectionConverters.*
+import scala.jdk.OptionConverters.*
 import scala.collection.mutable
 import java.nio.file.Path
 
@@ -86,7 +87,6 @@ final class BuildServerReporterImpl(
     protected override val underlying: Reporter
 ) extends BuildServerReporter {
   import sbt.internal.bsp.codec.JsonProtocol.given
-  import sbt.internal.inc.JavaInterfaceUtil.*
 
   private lazy val exchange = StandardMain.exchange
   private val problemsByFile = mutable.Map[Path, Vector[Problem]]()
@@ -151,7 +151,7 @@ final class BuildServerReporterImpl(
 
   protected override def publishDiagnostic(problem: Problem): Unit = {
     for {
-      id <- problem.position.sourcePath.toOption
+      id <- problem.position.sourcePath.toScala
       (document, diagnostic) <- mapProblemToDiagnostic(problem)
     } {
       // Note: We're putting the real path in `fileRef` because the `id` String can take
@@ -196,13 +196,13 @@ final class BuildServerReporterImpl(
   ): Option[(TextDocumentIdentifier, Diagnostic)] = {
     val mappedPosition = sourcePositionMapper(problem.position)
     for {
-      mappedSource <- mappedPosition.sourcePath.toOption
+      mappedSource <- mappedPosition.sourcePath.toScala
       document <- toDocument(VirtualFileRef.of(mappedSource))
     } yield {
       val diagnostic = Diagnostic(
         toRange(mappedPosition),
         Option(toDiagnosticSeverity(problem.severity)),
-        problem.diagnosticCode().toOption.map(_.code),
+        problem.diagnosticCode().toScala.map(_.code),
         Option("sbt"),
         problem.message
       )
@@ -211,12 +211,12 @@ final class BuildServerReporterImpl(
   }
 
   private def toRange(position: xsbti.Position): Range = {
-    val startLineOpt = position.startLine.toOption.map(_.toLong - 1)
-    val startColumnOpt = position.startColumn.toOption.map(_.toLong)
-    val endLineOpt = position.endLine.toOption.map(_.toLong - 1)
-    val endColumnOpt = position.endColumn.toOption.map(_.toLong)
-    val lineOpt = position.line.toOption.map(_.toLong - 1)
-    val columnOpt = position.pointer.toOption.map(_.toLong)
+    val startLineOpt = position.startLine.toScala.map(_.toLong - 1)
+    val startColumnOpt = position.startColumn.toScala.map(_.toLong)
+    val endLineOpt = position.endLine.toScala.map(_.toLong - 1)
+    val endColumnOpt = position.endColumn.toScala.map(_.toLong)
+    val lineOpt = position.line.toScala.map(_.toLong - 1)
+    val columnOpt = position.pointer.toScala.map(_.toLong)
 
     def toPosition(lineOpt: Option[Long], columnOpt: Option[Long]): Option[Position] =
       lineOpt.map(line => Position(line, columnOpt.getOrElse(0L)))

main/src/main/scala/sbt/internal/server/Definition.scala

@@ -24,7 +24,6 @@ import sjsonnew.shaded.scalajson.ast.unsafe.JValue
 import sjsonnew.support.scalajson.unsafe.{ CompactPrinter, Converter }
 
 import sbt.internal.inc.Analysis
-import sbt.internal.inc.JavaInterfaceUtil.*
 import sbt.internal.parser.SbtParser
 import sbt.internal.protocol.JsonRpcResponseError
 import sbt.internal.protocol.codec.JsonRPCProtocol
@@ -34,6 +33,7 @@ import sbt.Keys.*
 import xsbti.{ FileConverter, VirtualFileRef }
 import com.github.benmanes.caffeine.cache.Cache
 import scala.concurrent.Promise
+import scala.jdk.OptionConverters.*
 import com.github.benmanes.caffeine.cache.Caffeine
 
 private[sbt] object Definition {
@@ -177,7 +177,7 @@ private[sbt] object Definition {
         useConsistent = useConsistent,
       )
       .get
-      .toOption
+      .toScala
       .map { _.getAnalysis }
       .collect { case a: Analysis => a }
 
@@ -269,7 +269,7 @@ private[sbt] object Definition {
           .lines(Paths.get(uri))
           .skip(definition.position.line)
           .findFirst
-          .toOption
+          .toScala
           .flatMap { line =>
             log.debug(s"$LspDefinitionLogHead found line: $line")
             textProcessor.identifier(line, definition.position.character.toInt)

main/src/main/scala/sbt/nio/FileStamp.scala

@@ -13,13 +13,13 @@ import java.nio.file.{ Path, Paths }
 import java.util.concurrent.ConcurrentHashMap
 
 import sbt.internal.inc.{ EmptyStamp, Stamper, Hash as IncHash, LastModified as IncLastModified }
-import sbt.internal.inc.JavaInterfaceUtil.given
 import sbt.io.IO
 import sbt.nio.file.FileAttributes
 import sbt.util.Digest
 import sjsonnew.{ Builder, JsonFormat, Unbuilder, deserializationError }
 import xsbti.compile.analysis.{ Stamp as XStamp }
 import xsbti.VirtualFileRef
+import scala.jdk.OptionConverters.*
 
 /**
  * A trait that indicates what file stamping implementation should be used to track the state of
@@ -102,7 +102,7 @@ object FileStamp {
 
   def toDigest(path: Path, stamp: FileStamp): Digest = stamp match
     case f: FileHashImpl =>
-      f.xstamp.getHash().toOption match
+      f.xstamp.getHash().toScala match
         case Some(hash) => Digest.sha256Hash(hash.getBytes("UTF-8"))
         case None       => Digest.sha256Hash(path)
     case FileStamp.Hash(hex)       => Digest.sha256Hash(hex.getBytes("UTF-8"))