Clean compile warnings

build.sbt

@@ -445,7 +445,6 @@ lazy val compilerInterface = (projectMatrix in internalPath / "compiler-interfac
       exclude[InheritedNewAbstractMethodProblem]("xsbti.InteractiveConsoleInterface.close"),
     ),
   )
-  .defaultAxes(VirtualAxis.jvm, VirtualAxis.scalaPartialVersion(scala212))
   .jvmPlatform(autoScalaLibrary = false)
   .configure(addSbtUtilInterface(_))
 
@@ -532,8 +531,7 @@ lazy val compilerBridgeTest = (projectMatrix in internalPath / "compiler-bridge-
     Test / javaOptions += s"-Dzinc.build.compilerbridge.scalaVersion=${scala213}",
     publish / skip := true,
   )
-  .defaultAxes(VirtualAxis.jvm, VirtualAxis.scalaPartialVersion(scala212))
-  .jvmPlatform(scalaVersions = scala212_213)
+  .jvmPlatform(scalaVersions = scala3_only)
 
 val scalaPartialVersion = Def.setting(CrossVersion.partialVersion(scalaVersion.value))
 
@@ -679,7 +677,7 @@ val publishBridges = taskKey[Unit]("")
 val crossTestBridges = taskKey[Unit]("")
 
 publishBridges := Def.task(()).dependsOn(bridges: _*).value
-crossTestBridges := (compilerBridgeTest.jvm(scala213) / Test / test).dependsOn(publishBridges).value
+crossTestBridges := (compilerBridgeTest.jvm(scala3) / Test / test).dependsOn(publishBridges).value
 
 addCommandAlias(
   "runBenchmarks", {

internal/zinc-benchmarks/src/test/scala/xsbt/GlobalBenchmarkSetup.scala

@@ -22,7 +22,7 @@ object GlobalBenchmarkSetup {
 
   def runSetup(setupDir: File, pattern: String): (Int, String) = {
     val projectsPreparation = projects
-      .filterKeys { _.matches(pattern) }
+      .view.filterKeys { _.matches(pattern) }
       .map { case (_, project) =>
         val benchmark = new ZincBenchmark(project)
         project -> benchmark.writeSetup(new File(setupDir, project.repo))

internal/zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala

@@ -185,7 +185,7 @@ private[xsbt] object ZincBenchmark {
          |  // Resolve project dynamically to avoid name clashes/overloading
          |  val project = LocalProject("$sbtProject")
          |  Def.task {
-         |    val file = new File("${outputFile.getAbsolutePath.replaceAllLiterally("\\", "/")}")
+         |    val file = new File("${outputFile.getAbsolutePath.replace("\\", "/")}")
          |    val rawSources = (sources in Compile in project).value
          |    val sourcesLine = rawSources.map(_.getCanonicalPath).mkString(" ")
          |    val rawClasspath = (dependencyClasspath in Compile in project).value

internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath/ClasspathUtilities.scala

@@ -151,7 +151,7 @@ object ClasspathUtil {
 
   /** Returns all entries in 'classpath' that correspond to a compiler plugin.*/
   private[sbt] def compilerPlugins(classpath: Seq[Path], isDotty: Boolean): Iterable[Path] = {
-    import collection.JavaConverters._
+    import scala.jdk.CollectionConverters._
     val loader = new URLClassLoader(toURLs(classpath).toArray)
     val metaFile = if (isDotty) "plugin.properties" else "scalac-plugin.xml"
     loader.getResources(metaFile).asScala.toList.flatMap(asFile(true))

internal/zinc-compile-core/src/main/scala/sbt/internal/inc/AnalyzingCompiler.scala

@@ -80,8 +80,8 @@ final class AnalyzingCompiler(
       log: xLogger
   ): Unit = {
     val progress = if (progressOpt.isPresent) progressOpt.get else IgnoreProgress
-    val cp = classpath.map(converter.toPath)
-    val arguments = compArgs.makeArguments(Nil, cp, options).toArray
+    val cp = classpath.map(converter.toPath).toIndexedSeq
+    val arguments = compArgs.makeArguments(Nil, cp, options.toIndexedSeq).toArray
     // hold reference to compiler bridge class loader to prevent its being evicted
     // from the compiler cache (sbt/zinc#914)
     val loader = getCompilerLoader(log)
@@ -454,7 +454,7 @@ object AnalyzingCompiler {
           val scalaLibraryJars = compiler.scalaInstance.libraryJars
           val restClasspath = xsbtiJars.toSeq ++ sourceJars
           val classpath = scalaLibraryJars.map(_.toPath) ++ restClasspath
-          compiler(sourceFiles, classpath, outputDirectory.toPath, "-nowarn" :: Nil)
+          compiler(sourceFiles, classpath.toIndexedSeq, outputDirectory.toPath, "-nowarn" :: Nil)
 
           val end = (System.currentTimeMillis - start) / 1000.0
           log.info(s"  Compilation completed in ${end}s.")

internal/zinc-compile-core/src/main/scala/sbt/internal/inc/FilteredReporter.scala

@@ -67,8 +67,11 @@ class FilteredReporter(
       filters.exists(f => f(value).booleanValue())
 
     severity != Severity.Error && (
-      (pos.sourceFile.isPresent && isFiltered(fileFilters, pos.sourceFile.get.toPath)) ||
-        (isFiltered(msgFilters, msg))
+      (pos.sourceFile.isPresent && isFiltered(
+        fileFilters.toIndexedSeq,
+        pos.sourceFile.get.toPath
+      )) ||
+        (isFiltered(msgFilters.toIndexedSeq, msg))
     )
   }
 

internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/ForkedJava.scala

@@ -78,7 +78,7 @@ object ForkedJava {
     }
   }
   // javac's argument file seems to allow naive space escaping with quotes.  escaping a quote with a backslash does not work
-  private def escapeSpaces(s: String): String = '\"' + normalizeSlash(s) + '\"'
+  private def escapeSpaces(s: String): String = s"\"${normalizeSlash(s)}\""
   private def normalizeSlash(s: String) = s.replace(File.separatorChar, '/')
 
   /** create the executable name for java */
@@ -100,7 +100,15 @@ final class ForkedJavaCompiler(javaHome: Option[Path]) extends XJavaCompiler {
       reporter: Reporter,
       log: XLogger
   ): Boolean =
-    ForkedJava.launch(javaHome, "javac", sources, options, output, log, reporter)
+    ForkedJava.launch(
+      javaHome,
+      "javac",
+      sources.toIndexedSeq,
+      options.toIndexedSeq,
+      output,
+      log,
+      reporter,
+    )
 }
 final class ForkedJavadoc(javaHome: Option[Path]) extends XJavadoc {
   def run(
@@ -111,5 +119,13 @@ final class ForkedJavadoc(javaHome: Option[Path]) extends XJavadoc {
       reporter: Reporter,
       log: XLogger
   ): Boolean =
-    ForkedJava.launch(javaHome, "javadoc", sources, options, output, log, reporter)
+    ForkedJava.launch(
+      javaHome,
+      "javadoc",
+      sources.toIndexedSeq,
+      options.toIndexedSeq,
+      output,
+      log,
+      reporter,
+    )
 }

internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/LocalJava.scala

@@ -104,7 +104,6 @@ object LocalJava {
   ): Int = {
     (javadocTool, standardDocletClass) match {
       case (Some(m), Some(clz)) =>
-        import scala.jdk.CollectionConverters._
         val task = m.getTask(
           out,
           null,
@@ -290,7 +289,6 @@ final class LocalJavaCompiler(compiler: javax.tools.JavaCompiler) extends XJavaC
       log0: XLogger
   ): Boolean = {
     val log: Logger = log0
-    import collection.JavaConverters._
     val logger = new LoggerWriter(log)
     val logWriter = new PrintWriter(logger)
     log.debug("Attempting to call " + compiler + " directly...")

internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/JavaCompilerSpec.scala

@@ -185,7 +185,7 @@ class JavaCompilerSpec extends UnitSpec with Diagrams {
     val leftAPI = compileWithPrimitive(leftType, left)
     val rightAPI = compileWithPrimitive(rightType, right)
     assert(leftAPI.size == rightAPI.size)
-    assert(((leftAPI, rightAPI).zipped forall SameAPI.apply) == (left == right))
+    assert(leftAPI.lazyZip(rightAPI).forall(SameAPI.apply) == (left == right))
     ()
   }
 

internal/zinc-core/src/main/scala/sbt/internal/inc/Changes.scala

@@ -91,7 +91,6 @@ final case class TraitPrivateMembersModified(modified: String) extends APIChange
 final case class ModifiedNames(names: Set[UsedName]) {
   def in(scope: UseScope): Set[UsedName] = names.filter(_.scopes.contains(scope))
 
-  import collection.JavaConverters._
   private lazy val lookupMap: Set[(String, UseScope)] =
     names.flatMap(n => n.scopes.asScala.map(n.name -> _))
 

internal/zinc-core/src/main/scala/sbt/internal/inc/FileValueCache.scala

@@ -29,7 +29,7 @@ sealed trait FileValueCache[T] {
 object FileValueCache {
   def apply[T](f: Path => T): FileValueCache[T] = make(Stamper.forLastModifiedP)(f)
   def make[T](stamp: Path => XStamp)(f: Path => T): FileValueCache[T] =
-    new FileValueCache0[T](stamp, f)
+    new FileValueCache0[T](stamp, f)(Equiv.universal)
 }
 
 private[this] final class FileValueCache0[T](getStamp: Path => XStamp, make: Path => T)(

internal/zinc-core/src/main/scala/sbt/internal/inc/Incremental.scala

@@ -201,7 +201,7 @@ object Incremental {
         earlyOutput,
         progress,
         log
-      )
+      )(Equiv.universal)
     } catch {
       case _: xsbti.CompileCancelled =>
         log.info("Compilation has been cancelled")
@@ -371,7 +371,7 @@ object Incremental {
           )
       }
     }
-    val pickleJava = isPickleJava(scalacOptions)
+    val pickleJava = isPickleJava(scalacOptions.toIndexedSeq)
     val hasModified = initialInvClasses.nonEmpty || initialInvSources0.nonEmpty
     if (javaSources.nonEmpty && earlyOutput.isDefined && !pickleJava) {
       log.warn(

internal/zinc-core/src/main/scala/sbt/internal/inc/Locate.scala

@@ -48,7 +48,7 @@ object Locate {
         case x           => x
       }
   }
-  def find[S](name: String, gets: Stream[String => Either[Boolean, S]]): Either[Boolean, S] =
+  def find[S](name: String, gets: LazyList[String => Either[Boolean, S]]): Either[Boolean, S] =
     find[S](name, gets.iterator)
 
   /**
@@ -102,7 +102,7 @@ object Locate {
   }
 
   private class JarDefinesClass(entry: Path) extends DefinesClass {
-    import collection.JavaConverters._
+    import scala.jdk.CollectionConverters._
     private val entries = {
       val jar =
         try {
@@ -148,6 +148,6 @@ object Locate {
   def components(className: String): (Seq[String], String) = {
     assume(!className.isEmpty)
     val parts = className.split("\\.")
-    if (parts.length == 1) (Nil, parts(0)) else (parts.init, parts.last)
+    if (parts.length == 1) (Nil, parts(0)) else (parts.init.toIndexedSeq, parts.last)
   }
 }

internal/zinc-core/src/main/scala/sbt/internal/inc/SourceInfo.scala

@@ -43,9 +43,12 @@ object SourceInfos {
 
   def merge1(info1: SourceInfo, info2: SourceInfo) = {
     makeInfo(
-      mergeProblems(info1.getReportedProblems, info2.getReportedProblems),
-      mergeProblems(info1.getUnreportedProblems, info2.getUnreportedProblems),
-      (info1.getMainClasses ++ info2.getMainClasses).distinct,
+      mergeProblems(info1.getReportedProblems.toIndexedSeq, info2.getReportedProblems.toIndexedSeq),
+      mergeProblems(
+        info1.getUnreportedProblems.toIndexedSeq,
+        info2.getUnreportedProblems.toIndexedSeq,
+      ),
+      (info1.getMainClasses ++ info2.getMainClasses).distinct.toIndexedSeq,
     )
   }
 
@@ -98,8 +101,8 @@ private final class MSourceInfos(val allInfos: Map[VirtualFileRef, SourceInfo])
     allInfos.getOrElse(file, SourceInfos.emptyInfo)
 
   override def getAllSourceInfos: java.util.Map[VirtualFileRef, SourceInfo] = {
-    import scala.collection.JavaConverters.mapAsJavaMapConverter
-    mapAsJavaMapConverter(allInfos).asJava
+    import scala.jdk.CollectionConverters._
+    allInfos.asJava
   }
 }
 

internal/zinc-core/src/main/scala/sbt/internal/inc/Stamp.scala

@@ -23,6 +23,7 @@ import xsbti.{ FileConverter, VirtualFile, VirtualFileRef }
 import xsbti.compile.analysis.{ ReadStamps, Stamp => XStamp }
 
 import scala.collection.immutable.TreeMap
+import scala.jdk.CollectionConverters._
 import scala.util.matching.Regex
 
 /**
@@ -241,7 +242,6 @@ object Stamper {
       converter: FileConverter,
       getStamp: VirtualFileRef => XStamp
   ): VirtualFileRef => XStamp = { (key: VirtualFileRef) =>
-    import scala.collection.JavaConverters._
     val p = converter.toPath(key)
     val ts =
       try IO.getModifiedTimeOrZero(p.toFile)
@@ -320,13 +320,12 @@ private class MStamps(
     val libraries: Map[VirtualFileRef, XStamp]
 ) extends Stamps {
 
-  import scala.collection.JavaConverters.mapAsJavaMapConverter
   override def getAllLibraryStamps: util.Map[VirtualFileRef, XStamp] =
-    mapAsJavaMapConverter(libraries).asJava
+    libraries.asJava
   override def getAllProductStamps: util.Map[VirtualFileRef, XStamp] =
-    mapAsJavaMapConverter(products).asJava
+    products.asJava
   override def getAllSourceStamps: util.Map[VirtualFileRef, XStamp] =
-    mapAsJavaMapConverter(sources).asJava
+    sources.asJava
 
   def allSources: collection.Set[VirtualFileRef] = sources.keySet
   def allLibraries: collection.Set[VirtualFileRef] = libraries.keySet
@@ -407,7 +406,6 @@ private class InitialStamps(
 ) extends ReadStamps {
   import collection.concurrent.Map
   import java.util.concurrent.ConcurrentHashMap
-  import scala.collection.JavaConverters._
 
   // cached stamps for files that do not change during compilation
   private val libraries: Map[VirtualFileRef, XStamp] = new ConcurrentHashMap().asScala
@@ -431,7 +429,6 @@ private class TimeWrapBinaryStamps(
 ) extends ReadStamps {
   import collection.concurrent.Map
   import java.util.concurrent.ConcurrentHashMap
-  import scala.collection.JavaConverters._
 
   // cached stamps for files that do not change during compilation
   private val libraries: Map[VirtualFileRef, (Long, XStamp)] = new ConcurrentHashMap().asScala
@@ -460,8 +457,7 @@ private class UncachedStamps(
     libStamp: VirtualFileRef => XStamp
 ) extends ReadStamps {
   import VirtualFileUtil._
-  import scala.collection.JavaConverters.mapAsJavaMapConverter
-  val eSt = mapAsJavaMapConverter(TreeMap.empty[VirtualFileRef, XStamp]).asJava
+  val eSt = TreeMap.empty[VirtualFileRef, XStamp].asJava
 
   override def getAllLibraryStamps: util.Map[VirtualFileRef, XStamp] = eSt
   override def getAllSourceStamps: util.Map[VirtualFileRef, XStamp] = eSt

internal/zinc-core/src/main/scala/sbt/internal/inc/UsedName.scala

@@ -35,7 +35,7 @@ object UsedName {
 
   private def escapeControlChars(name: String) = {
     if (name.indexOf('\n') > 0) // optimize for common case to regex overhead
-      name.replaceAllLiterally("\n", "\u26680A")
+      name.replace("\n", "\u26680A")
     else
       name
   }

internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ConsistentAnalysisFormat.scala

@@ -11,8 +11,8 @@ import xsbti.compile._
 import xsbti.compile.analysis.{ ReadWriteMappers, SourceInfo, Stamp }
 
 import scala.collection.immutable.TreeMap
+import scala.collection.immutable.ArraySeq
 import sbt.internal.inc.binary.converters.InternalApiProxy
-import Compat._
 
 /** A new implementation of zinc's incremental state serialization.
  * - Full structural serialization (like the existing protobuf format), no shortcuts with sbinary
@@ -277,8 +277,8 @@ class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
     ) {
       val file = readMapper.mapSourceFile(VirtualFileRef.of(in.string()))
       val mainClasses = in.readStringSeq()
-      val reportedProblems = in.readArray()(readProblem())
-      val unreportedProblems = in.readArray()(readProblem())
+      val reportedProblems = ArraySeq.unsafeWrapArray(in.readArray()(readProblem()))
+      val unreportedProblems = ArraySeq.unsafeWrapArray(in.readArray()(readProblem()))
       val info = SourceInfos.makeInfo(reportedProblems, unreportedProblems, mainClasses)
       (file, info)
     })

internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/Serializer.scala

@@ -17,7 +17,7 @@ import scala.annotation.tailrec
 import scala.collection.mutable.ArrayBuffer
 import scala.collection.mutable
 import scala.reflect.ClassTag
-import Compat._
+import scala.collection.Factory
 
 /** Structural serialization for text and binary formats. */
 abstract class Serializer {