From 412801fc54fb19c01b16155fc81350916b49f50d Mon Sep 17 00:00:00 2001 From: kenji yoshida <6b656e6a69@gmail.com> Date: Sun, 10 May 2026 13:58:24 +0900 Subject: [PATCH] [2.x] refactor: Use scala.jdk.OptionConverters instead of JavaInterfaceUtil (#9200) --- main/src/main/scala/sbt/Defaults.scala | 32 +++++++++---------- .../internal/server/BuildServerReporter.scala | 20 ++++++------ .../sbt/internal/server/Definition.scala | 6 ++-- main/src/main/scala/sbt/nio/FileStamp.scala | 4 +-- 4 files changed, 31 insertions(+), 31 deletions(-) diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index 261826f28..b49511f0e 100644 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/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]) } diff --git a/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala b/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala index 4c512f9c8..c7748ee71 100644 --- a/main/src/main/scala/sbt/internal/server/BuildServerReporter.scala +++ b/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))) diff --git a/main/src/main/scala/sbt/internal/server/Definition.scala b/main/src/main/scala/sbt/internal/server/Definition.scala index 0521d580b..9c3aa6730 100644 --- a/main/src/main/scala/sbt/internal/server/Definition.scala +++ b/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) diff --git a/main/src/main/scala/sbt/nio/FileStamp.scala b/main/src/main/scala/sbt/nio/FileStamp.scala index 8987cdf41..6c01af39e 100644 --- a/main/src/main/scala/sbt/nio/FileStamp.scala +++ b/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"))