From ba8f02e4536854a9a2fb41c36286b390fa122e86 Mon Sep 17 00:00:00 2001 From: friendseeker <66892505+Friendseeker@users.noreply.github.com> Date: Sun, 13 Oct 2024 15:16:37 -0700 Subject: [PATCH] Clean compile warnings --- build.sbt | 6 ++-- .../scala/xsbt/GlobalBenchmarkSetup.scala | 2 +- .../src/test/scala/xsbt/ZincBenchmark.scala | 2 +- .../inc/classpath/ClasspathUtilities.scala | 2 +- .../sbt/internal/inc/AnalyzingCompiler.scala | 6 ++-- .../sbt/internal/inc/FilteredReporter.scala | 7 +++-- .../sbt/internal/inc/javac/ForkedJava.scala | 22 +++++++++++++-- .../sbt/internal/inc/javac/LocalJava.scala | 2 -- .../internal/inc/javac/JavaCompilerSpec.scala | 2 +- .../sbt/internal/inc/WrappedSet.scala | 28 ------------------- .../main/scala/sbt/internal/inc/Changes.scala | 1 - .../sbt/internal/inc/FileValueCache.scala | 2 +- .../scala/sbt/internal/inc/Incremental.scala | 4 +-- .../main/scala/sbt/internal/inc/Locate.scala | 6 ++-- .../scala/sbt/internal/inc/SourceInfo.scala | 13 +++++---- .../main/scala/sbt/internal/inc/Stamp.scala | 14 ++++------ .../scala/sbt/internal/inc/UsedName.scala | 2 +- .../sbt/internal/inc/consistent/Compat.scala | 5 ---- .../sbt/internal/inc/consistent/Compat.scala | 5 ---- .../consistent/ConsistentAnalysisFormat.scala | 6 ++-- .../internal/inc/consistent/Serializer.scala | 2 +- .../inc/text/TextAnalysisFormat.scala | 19 +++++++++++-- .../scala/sbt/inc/AnalysisGenerators.scala | 2 +- .../ConsistentAnalysisFormatSuite.scala | 1 - .../scala/sbt/internal/inc/IncHandler.scala | 2 +- .../inc/IncrementalCompilerImpl.scala | 18 ++++++------ .../internal/inc/MixedAnalyzingCompiler.scala | 12 ++++---- .../inc/javac/AnalyzingJavaCompiler.scala | 2 +- .../sbt/inc/cached/CachedHashingSpec.scala | 6 ++-- 29 files changed, 95 insertions(+), 106 deletions(-) delete mode 100644 internal/zinc-core/src/main/scala-2.12/sbt/internal/inc/WrappedSet.scala delete mode 100644 internal/zinc-persist/src/main/scala-2.13/sbt/internal/inc/consistent/Compat.scala delete mode 100644 internal/zinc-persist/src/main/scala-3/sbt/internal/inc/consistent/Compat.scala diff --git a/build.sbt b/build.sbt index 1820a0edd..473e372f1 100644 --- a/build.sbt +++ b/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", { diff --git a/internal/zinc-benchmarks/src/test/scala/xsbt/GlobalBenchmarkSetup.scala b/internal/zinc-benchmarks/src/test/scala/xsbt/GlobalBenchmarkSetup.scala index 59eecf109..01f6757d3 100644 --- a/internal/zinc-benchmarks/src/test/scala/xsbt/GlobalBenchmarkSetup.scala +++ b/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)) diff --git a/internal/zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala b/internal/zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala index f7ac1540e..b03330308 100644 --- a/internal/zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala +++ b/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 diff --git a/internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath/ClasspathUtilities.scala b/internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath/ClasspathUtilities.scala index 944e15f7f..15984d3f2 100644 --- a/internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath/ClasspathUtilities.scala +++ b/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)) diff --git a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/AnalyzingCompiler.scala b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/AnalyzingCompiler.scala index 2bc26682d..5329a51f4 100644 --- a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/AnalyzingCompiler.scala +++ b/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.") diff --git a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/FilteredReporter.scala b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/FilteredReporter.scala index 4c4856150..2312de34a 100644 --- a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/FilteredReporter.scala +++ b/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)) ) } diff --git a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/ForkedJava.scala b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/ForkedJava.scala index 412819dba..747269006 100644 --- a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/ForkedJava.scala +++ b/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, + ) } diff --git a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/LocalJava.scala b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/LocalJava.scala index f0dd3f8e0..cc8596a12 100644 --- a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/LocalJava.scala +++ b/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...") diff --git a/internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/JavaCompilerSpec.scala b/internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/JavaCompilerSpec.scala index b320c8a5d..ceb2a56ae 100644 --- a/internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/JavaCompilerSpec.scala +++ b/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)) () } diff --git a/internal/zinc-core/src/main/scala-2.12/sbt/internal/inc/WrappedSet.scala b/internal/zinc-core/src/main/scala-2.12/sbt/internal/inc/WrappedSet.scala deleted file mode 100644 index 7f0d83bba..000000000 --- a/internal/zinc-core/src/main/scala-2.12/sbt/internal/inc/WrappedSet.scala +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Zinc - The incremental compiler for Scala. - * Copyright Scala Center, Lightbend, and Mark Harrah - * - * Licensed under Apache License 2.0 - * SPDX-License-Identifier: Apache-2.0 - * - * See the NOTICE file distributed with this work for - * additional information regarding copyright ownership. - */ - -package sbt.internal.inc - -import xsbti.VirtualFileRef -import scala.collection.immutable.Set - -private[inc] class WrappedSet(s: java.util.Set[VirtualFileRef]) extends Set[VirtualFileRef] { - import scala.jdk.CollectionConverters._ - def iterator: Iterator[xsbti.VirtualFileRef] = s.asScala.iterator - def contains(elem: xsbti.VirtualFileRef): Boolean = s.contains(elem) - - def +(elem: xsbti.VirtualFileRef): Set[xsbti.VirtualFileRef] = - s.asScala.foldLeft(Set(elem)) { case (a, e) => a + e } - def -(elem: xsbti.VirtualFileRef): Set[xsbti.VirtualFileRef] = - s.asScala.foldLeft(Set.empty[VirtualFileRef]) { - case (a, e) => if (e != elem) a + e else a - } -} diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/Changes.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/Changes.scala index bc40d58f8..26e6a02da 100644 --- a/internal/zinc-core/src/main/scala/sbt/internal/inc/Changes.scala +++ b/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 -> _)) diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/FileValueCache.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/FileValueCache.scala index 8a1808657..aa7b805c8 100644 --- a/internal/zinc-core/src/main/scala/sbt/internal/inc/FileValueCache.scala +++ b/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)( diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/Incremental.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/Incremental.scala index ba2d75130..95a742024 100644 --- a/internal/zinc-core/src/main/scala/sbt/internal/inc/Incremental.scala +++ b/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( diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/Locate.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/Locate.scala index ca7758a4a..6f5cafcb8 100644 --- a/internal/zinc-core/src/main/scala/sbt/internal/inc/Locate.scala +++ b/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) } } diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/SourceInfo.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/SourceInfo.scala index 97b5d309e..247b6b071 100644 --- a/internal/zinc-core/src/main/scala/sbt/internal/inc/SourceInfo.scala +++ b/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 } } diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/Stamp.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/Stamp.scala index 609c31b37..447a37643 100644 --- a/internal/zinc-core/src/main/scala/sbt/internal/inc/Stamp.scala +++ b/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 diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/UsedName.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/UsedName.scala index 95a11b4dd..7ca3b9eac 100644 --- a/internal/zinc-core/src/main/scala/sbt/internal/inc/UsedName.scala +++ b/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 } diff --git a/internal/zinc-persist/src/main/scala-2.13/sbt/internal/inc/consistent/Compat.scala b/internal/zinc-persist/src/main/scala-2.13/sbt/internal/inc/consistent/Compat.scala deleted file mode 100644 index 8fa921934..000000000 --- a/internal/zinc-persist/src/main/scala-2.13/sbt/internal/inc/consistent/Compat.scala +++ /dev/null @@ -1,5 +0,0 @@ -package sbt.internal.inc.consistent - -object Compat { - type Factory[-A, +C] = scala.collection.Factory[A, C] -} diff --git a/internal/zinc-persist/src/main/scala-3/sbt/internal/inc/consistent/Compat.scala b/internal/zinc-persist/src/main/scala-3/sbt/internal/inc/consistent/Compat.scala deleted file mode 100644 index 8fa921934..000000000 --- a/internal/zinc-persist/src/main/scala-3/sbt/internal/inc/consistent/Compat.scala +++ /dev/null @@ -1,5 +0,0 @@ -package sbt.internal.inc.consistent - -object Compat { - type Factory[-A, +C] = scala.collection.Factory[A, C] -} diff --git a/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ConsistentAnalysisFormat.scala b/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ConsistentAnalysisFormat.scala index 744a7f12d..a5ca28543 100644 --- a/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ConsistentAnalysisFormat.scala +++ b/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) }) diff --git a/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/Serializer.scala b/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/Serializer.scala index 8f111a9b6..4eec2f28b 100644 --- a/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/Serializer.scala +++ b/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 { diff --git a/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/TextAnalysisFormat.scala b/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/TextAnalysisFormat.scala index 2bb72a63b..4051a060b 100644 --- a/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/TextAnalysisFormat.scala +++ b/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/TextAnalysisFormat.scala @@ -31,6 +31,7 @@ import xsbti.api._ import xsbti.compile._ import xsbti.compile.analysis.{ ReadWriteMappers, SourceInfo, Stamp } import scala.collection.Seq +import scala.collection.immutable.ArraySeq // A text-based serialization format for Analysis objects. // This code has been tuned for high performance, and therefore has non-idiomatic areas. @@ -483,9 +484,21 @@ class TextAnalysisFormat(val mappers: ReadWriteMappers) .map(fh => fh.withFile(writeMapper.mapClasspathEntry(fh.file))) writeSeq(out)(Headers.outputMode, mode :: Nil, identity[String]) writeMap(out)(Headers.outputDir, outputAsMap, sourceDirMapper.write, outputDirMapper.write) - writeSeq(out)(Headers.classpathHash, mappedClasspathHash, fileHashToString) - writeSeq(out)(Headers.compileOptions, setup.options.scalacOptions, soptionsMapper.write) - writeSeq(out)(Headers.javacOptions, setup.options.javacOptions, joptionsMapper.write) + writeSeq(out)( + Headers.classpathHash, + ArraySeq.unsafeWrapArray(mappedClasspathHash), + fileHashToString + ) + writeSeq(out)( + Headers.compileOptions, + ArraySeq.unsafeWrapArray(setup.options.scalacOptions), + soptionsMapper.write + ) + writeSeq(out)( + Headers.javacOptions, + ArraySeq.unsafeWrapArray(setup.options.javacOptions), + joptionsMapper.write + ) writeSeq(out)(Headers.compilerVersion, setup.compilerVersion :: Nil, identity[String]) writeSeq(out)(Headers.compileOrder, setup.order.name :: Nil, identity[String]) writeSeq(out)(Headers.skipApiStoring, setup.storeApis() :: Nil, (b: Boolean) => b.toString) diff --git a/internal/zinc-persist/src/test/scala/sbt/inc/AnalysisGenerators.scala b/internal/zinc-persist/src/test/scala/sbt/inc/AnalysisGenerators.scala index 0fb6cdbc4..8ec26c311 100644 --- a/internal/zinc-persist/src/test/scala/sbt/inc/AnalysisGenerators.scala +++ b/internal/zinc-persist/src/test/scala/sbt/inc/AnalysisGenerators.scala @@ -104,7 +104,7 @@ object AnalysisGenerators { private[this] def lzy[T <: AnyRef](x: T) = SafeLazyProxy.strict(x) def genNameHash(name: String): Gen[NameHash] = - for (scope <- oneOf(UseScope.values())) + for (scope <- oneOf(UseScope.values().toIndexedSeq)) yield NameHash.of(name, scope, (name, scope).hashCode()) def genClass(name: String): Gen[AnalyzedClass] = diff --git a/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ConsistentAnalysisFormatSuite.scala b/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ConsistentAnalysisFormatSuite.scala index a92fe2c6b..d9085323f 100644 --- a/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ConsistentAnalysisFormatSuite.scala +++ b/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ConsistentAnalysisFormatSuite.scala @@ -14,7 +14,6 @@ import scala.util.Random import org.scalatest.funsuite.AnyFunSuite import sbt.internal.inc.consistent._ import sbt.io.IO -import Compat._ import scala.concurrent.ExecutionContext diff --git a/internal/zinc-scripted/src/test/scala/sbt/internal/inc/IncHandler.scala b/internal/zinc-scripted/src/test/scala/sbt/internal/inc/IncHandler.scala index 4689ccfd4..5d52f655d 100644 --- a/internal/zinc-scripted/src/test/scala/sbt/internal/inc/IncHandler.scala +++ b/internal/zinc-scripted/src/test/scala/sbt/internal/inc/IncHandler.scala @@ -523,7 +523,7 @@ case class ProjectStructure( case Seq(mainClassName) => val jars = i.si.allJars.map(_.toPath) val cp = (jars ++ (unmanagedJars :+ output) ++ internalClasspath).map(_.toAbsolutePath) - val loader = ClasspathUtil.makeLoader(cp, i.si, baseDirectory) + val loader = ClasspathUtil.makeLoader(cp.toIndexedSeq, i.si, baseDirectory) val buffer = new ByteArrayOutputStream(8192) val oldOut = System.out try { diff --git a/zinc/src/main/scala/sbt/internal/inc/IncrementalCompilerImpl.scala b/zinc/src/main/scala/sbt/internal/inc/IncrementalCompilerImpl.scala index 75e54d8de..638c78aa2 100644 --- a/zinc/src/main/scala/sbt/internal/inc/IncrementalCompilerImpl.scala +++ b/zinc/src/main/scala/sbt/internal/inc/IncrementalCompilerImpl.scala @@ -58,15 +58,15 @@ class IncrementalCompilerImpl extends IncrementalCompiler { compileIncrementally( scalac, javacChosen, - sources, - classpath, + sources.toIndexedSeq, + classpath.toIndexedSeq, CompileOutput(classesDirectory), earlyOutput.toOption, earlyAnalysisStore.toOption, cache, progress().toOption, - scalacOptions, - javacOptions, + scalacOptions.toIndexedSeq, + javacOptions.toIndexedSeq, in.previousResult.analysis.toOption, in.previousResult.setup.toOption, perClasspathEntryLookup, @@ -113,15 +113,15 @@ class IncrementalCompilerImpl extends IncrementalCompiler { compileIncrementally( scalac, javacChosen, - sources, - classpath, + sources.toIndexedSeq, + classpath.toIndexedSeq, CompileOutput(classesDirectory), earlyOutput.toOption, earlyAnalysisStore.toOption, cache, progress().toOption, - scalacOptions, - javacOptions, + scalacOptions.toIndexedSeq, + javacOptions.toIndexedSeq, in.previousResult.analysis.toOption, in.previousResult.setup.toOption, perClasspathEntryLookup, @@ -295,7 +295,7 @@ class IncrementalCompilerImpl extends IncrementalCompiler { compileIncrementally( scalaCompiler, javaCompiler, - vs, + vs.toIndexedSeq, cp, output, earlyOutput.toOption, diff --git a/zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala b/zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala index 81ed0f88f..2d37b6658 100644 --- a/zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala +++ b/zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala @@ -79,7 +79,7 @@ final class MixedAnalyzingCompiler( javaSrcs, Seq(toVirtualFile(outputJar)), config.converter, - joptions, + joptions.toIndexedSeq, CompileOutput(outputDir), outputJarOpt, callback, @@ -95,7 +95,7 @@ final class MixedAnalyzingCompiler( javaSrcs, extraClasspath map toVirtualFile, config.converter, - joptions, + joptions.toIndexedSeq, output, outputJarOpt, callback, @@ -144,7 +144,8 @@ final class MixedAnalyzingCompiler( val incSrc = config.sources.filter(include) val (javaSrcs, scalaSrcs) = incSrc.partition(MixedAnalyzingCompiler.javaOnly) logInputs(log, javaSrcs.size, scalaSrcs.size, outputDirs) - val pickleJava = Incremental.isPickleJava(config.currentSetup.options.scalacOptions) + val pickleJava = + Incremental.isPickleJava(config.currentSetup.options.scalacOptions.toIndexedSeq) // Compile Scala sources. def compileScala(): Unit = @@ -241,7 +242,8 @@ final class MixedAnalyzingCompiler( private[this] def outputDirectories(output: Output): Seq[Path] = { output match { case single: SingleOutput => List(single.getOutputDirectoryAsPath) - case mult: MultipleOutput => mult.getOutputGroups map (_.getOutputDirectoryAsPath) + case mult: MultipleOutput => + mult.getOutputGroups.toIndexedSeq map (_.getOutputDirectoryAsPath) } } @@ -416,7 +418,7 @@ object MixedAnalyzingCompiler { val cArgs = new CompilerArguments(compiler.scalaInstance, compiler.classpathOptions) val searchClasspath: Seq[VirtualFile] = explicitBootClasspath( - scalacOptions, + scalacOptions.toIndexedSeq, converter ) ++ withBootclasspath( diff --git a/zinc/src/main/scala/sbt/internal/inc/javac/AnalyzingJavaCompiler.scala b/zinc/src/main/scala/sbt/internal/inc/javac/AnalyzingJavaCompiler.scala index da62d88ac..ed71d8053 100644 --- a/zinc/src/main/scala/sbt/internal/inc/javac/AnalyzingJavaCompiler.scala +++ b/zinc/src/main/scala/sbt/internal/inc/javac/AnalyzingJavaCompiler.scala @@ -142,7 +142,7 @@ final class AnalyzingJavaCompiler private[sbt] ( } // Memoize the known class files in the Javac output location - val memo = for { (Some(outputPath), srcs) <- chunks } yield { + val memo = for { case (Some(outputPath), srcs) <- chunks } yield { val classFinder = if (outputPath.toString.endsWith(".jar")) new JarClassFinder(outputPath) else new DirectoryClassFinder(outputPath) diff --git a/zinc/src/test/scala/sbt/inc/cached/CachedHashingSpec.scala b/zinc/src/test/scala/sbt/inc/cached/CachedHashingSpec.scala index 444383c9a..2e60c849b 100644 --- a/zinc/src/test/scala/sbt/inc/cached/CachedHashingSpec.scala +++ b/zinc/src/test/scala/sbt/inc/cached/CachedHashingSpec.scala @@ -62,13 +62,13 @@ class CachedHashingSpec extends BaseCompilerSpec { def genConfig = MixedAnalyzingCompiler.makeConfig( scalac, javac, - options.sources, + options.sources.toIndexedSeq, options.converter.toOption.get, giganticClasspath, setup.cache, setup.progress.toOption, - options.scalacOptions, - options.javacOptions, + options.scalacOptions.toIndexedSeq, + options.javacOptions.toIndexedSeq, Analysis.empty, previousResult.setup.toOption, setup.perClasspathEntryLookup,