From b3a83c2a1526364bf154e9da9322e844be0acc94 Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Fri, 6 Sep 2024 01:18:32 -0400
Subject: [PATCH 01/54] Avoid using ZipError

---
 .../src/main/java/sbt/internal/inc/zip/ZipCentralDir.java     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/internal/zinc-classfile/src/main/java/sbt/internal/inc/zip/ZipCentralDir.java b/internal/zinc-classfile/src/main/java/sbt/internal/inc/zip/ZipCentralDir.java
index 20fe9e1c9..c0ca6d8aa 100644
--- a/internal/zinc-classfile/src/main/java/sbt/internal/inc/zip/ZipCentralDir.java
+++ b/internal/zinc-classfile/src/main/java/sbt/internal/inc/zip/ZipCentralDir.java
@@ -302,8 +302,8 @@ public int hashCode() {
         IndexNode child;  // 1st child
     }
 
-    private static void zerror(String msg) {
-        throw new ZipError(msg);
+    private static void zerror(String msg) throws ZipException {
+        throw new ZipException(msg);
     }
 
     private void buildNodeTree() {

From ac211dcae45c6e52973c5c524c6e0fd180c8dbdc Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Fri, 6 Sep 2024 23:04:33 -0400
Subject: [PATCH 02/54] Fix build

---
 .github/workflows/ci.yml | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d3af480be..48653ce17 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -64,20 +64,19 @@ jobs:
       shell: bash
       run: |
         sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Shapeless.*" "runBenchmarks"
-    - name: Checkout Develop Branch (4, 5)
+    - name: Checkout 1.10.x Branch (4, 5)
       if: ${{ github.event_name == 'pull_request' && (matrix.jobtype == 4 || matrix.jobtype == 5) }}
       uses: actions/checkout@v4
       with:
         clean: false
-        ref: develop
-    - name: Benchmark (Scalac) against Develop Branch (4)
+        ref: 1.10.x
+    - name: Benchmark (Scalac) against 1.10.x Branch (4)
       if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 4 }}
       shell: bash
       run: |
-        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Scalac.*" "zincBenchmarks/jmh:clean" "runBenchmarks"
-    - name: Benchmark (Shapeless) against Develop Branch (5)
+        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Scalac.*" "zincBenchmarks/Jmh/clean" "runBenchmarks"
+    - name: Benchmark (Shapeless) against 1.10.x Branch (5)
       if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 5 }}
       shell: bash
       run: |
-        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Shapeless.*" "zincBenchmarks/jmh:clean" "runBenchmarks"
-        
+        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Shapeless.*" "zincBenchmarks/Jmh/clean" "runBenchmarks"

From ed57d0e51fa21b7b046e2cd84096caa86be1636c Mon Sep 17 00:00:00 2001
From: rochala <rochala@tutanota.com>
Date: Wed, 11 Sep 2024 18:47:04 +0200
Subject: [PATCH 03/54] Copy bytes directly instead of using
 scala.reflect.io.Streamable suboptimal methods

---
 .../src/main/scala/xsbt/AbstractZincFile.scala | 18 ++++++++++++++++--
 1 file changed, 16 insertions(+), 2 deletions(-)

diff --git a/internal/compiler-bridge/src/main/scala/xsbt/AbstractZincFile.scala b/internal/compiler-bridge/src/main/scala/xsbt/AbstractZincFile.scala
index 2398339a2..b3352a8fd 100644
--- a/internal/compiler-bridge/src/main/scala/xsbt/AbstractZincFile.scala
+++ b/internal/compiler-bridge/src/main/scala/xsbt/AbstractZincFile.scala
@@ -12,7 +12,6 @@
 package xsbt
 
 import xsbti.{ PathBasedFile, VirtualFile }
-import scala.reflect.io.Streamable
 
 private trait AbstractZincFile extends scala.reflect.io.AbstractFile {
   def underlying: VirtualFile
@@ -25,7 +24,22 @@ private final class ZincPlainFile private[xsbt] (val underlying: PathBasedFile)
 private final class ZincVirtualFile private[xsbt] (val underlying: VirtualFile)
     extends scala.reflect.io.VirtualFile(underlying.name, underlying.id)
     with AbstractZincFile {
-  Streamable.closing(output)(_.write(Streamable.bytes(underlying.input))) // fill in the content
+  val buffer = new Array[Byte](4096)
+
+  val in = underlying.input()
+  val output0 = output
+
+  try {
+    var readBytes = in.read(buffer)
+
+    while (readBytes != -1) {
+      output0.write(buffer, 0, readBytes)
+      readBytes = in.read(buffer)
+    }
+  } finally {
+    in.close()
+    output0.close()
+  }
 }
 
 private object AbstractZincFile {

From 0929cf689403b0702f8921540b335aaf424ed630 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Tue, 17 Sep 2024 00:16:27 -0700
Subject: [PATCH 04/54] early return in transitive invalidation if possible

---
 .../sbt/internal/inc/IncrementalCommon.scala  | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
index 492b0e63f..1548fb3cf 100644
--- a/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
+++ b/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
@@ -464,16 +464,10 @@ private[inc] abstract class IncrementalCommon(
     val dependsOnClass = findClassDependencies(_, relations)
     val firstClassInvalidation: Set[String] = {
       val invalidated =
-        if (invalidateTransitively) {
-          // Invalidate by brute force (normally happens when we've done more than 3 incremental runs)
-          IncrementalCommon.transitiveDeps(initial, log)(dependsOnClass)
-        } else {
-          changes.apiChanges.flatMap(invalidateClassesInternally(relations, _, isScalaClass)).toSet
-        }
-      val included = includeTransitiveInitialInvalidations(initial, invalidated, dependsOnClass)
-      log.debug("Final step, transitive dependencies:\n\t" + included)
-      included
+        changes.apiChanges.flatMap(invalidateClassesInternally(relations, _, isScalaClass)).toSet
+      includeTransitiveInitialInvalidations(initial, invalidated, dependsOnClass)
     }
+    log.debug("Final step, transitive dependencies:\n\t" + firstClassInvalidation)
 
     // Invalidate classes linked with a class file that is produced by more than one source file
     val secondClassInvalidation = IncrementalCommon.invalidateNamesProducingSameClassFile(relations)
@@ -506,7 +500,13 @@ private[inc] abstract class IncrementalCommon(
       Set.empty
     } else {
       if (invalidateTransitively) {
-        newInvalidations ++ recompiledClasses
+        val firstClassTransitiveInvalidation = includeTransitiveInitialInvalidations(
+          initial,
+          IncrementalCommon.transitiveDeps(initial, log)(dependsOnClass),
+          dependsOnClass
+        )
+        log.debug("Invalidate by brute force:\n\t" + firstClassTransitiveInvalidation)
+        firstClassTransitiveInvalidation ++ secondClassInvalidation ++ thirdClassInvalidation
       } else {
         firstClassInvalidation ++ secondClassInvalidation ++ thirdClassInvalidation
       }

From 39aa5135d83b9457bdaafd7daac989a03880648b Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Wed, 18 Sep 2024 21:32:49 -0700
Subject: [PATCH 05/54] Add back Carston's transitive invalidation logic

Probably not needed anymore but better safe than sorry
---
 .../src/main/scala/sbt/internal/inc/IncrementalCommon.scala     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
index 1548fb3cf..4bdef942d 100644
--- a/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
+++ b/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
@@ -506,7 +506,7 @@ private[inc] abstract class IncrementalCommon(
           dependsOnClass
         )
         log.debug("Invalidate by brute force:\n\t" + firstClassTransitiveInvalidation)
-        firstClassTransitiveInvalidation ++ secondClassInvalidation ++ thirdClassInvalidation
+        firstClassTransitiveInvalidation ++ secondClassInvalidation ++ thirdClassInvalidation ++ recompiledClasses
       } else {
         firstClassInvalidation ++ secondClassInvalidation ++ thirdClassInvalidation
       }

From 77e7a2c9ca8a764249135a6109468c1135147f1b Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Fri, 20 Sep 2024 19:54:48 +0000
Subject: [PATCH 06/54] Update sbt, util-control, util-interface, ... to 1.10.2

---
 project/build.properties | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/build.properties b/project/build.properties
index ee4c672cd..0b699c305 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1 +1 @@
-sbt.version=1.10.1
+sbt.version=1.10.2

From cdc924c3ac274a72f3e029190cb3da2249718bcc Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Fri, 20 Sep 2024 19:55:01 +0000
Subject: [PATCH 07/54] Update scalacheck to 1.18.1

---
 project/Dependencies.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index 80aa604ec..065d7351d 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -75,7 +75,7 @@ object Dependencies {
   val parserCombinator = "org.scala-lang.modules" %% "scala-parser-combinators" % "1.1.2"
   val sbinary = "org.scala-sbt" %% "sbinary" % "0.5.1"
   val scalaXml = "org.scala-lang.modules" %% "scala-xml" % "2.3.0"
-  val scalaCheck = "org.scalacheck" %% "scalacheck" % "1.18.0"
+  val scalaCheck = "org.scalacheck" %% "scalacheck" % "1.18.1"
   val scalatest = "org.scalatest" %% "scalatest" % "3.2.19"
   val verify = "com.eed3si9n.verify" %% "verify" % "2.0.1"
   val sjsonnew = Def.setting {

From 34aa51af3c10e4b0b0dbc7325e4dda503ce5048b Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sun, 22 Sep 2024 20:54:45 -0700
Subject: [PATCH 08/54] Add unit test to demonstrate the 1 cycle saving

---
 .../source-dependencies/transitive-early-stopping/A.scala    | 3 +++
 .../source-dependencies/transitive-early-stopping/B.scala    | 3 +++
 .../source-dependencies/transitive-early-stopping/C.scala    | 4 ++++
 .../source-dependencies/transitive-early-stopping/D.scala    | 3 +++
 .../transitive-early-stopping/changes/A.scala                | 3 +++
 .../source-dependencies/transitive-early-stopping/test       | 5 +++++
 6 files changed, 21 insertions(+)
 create mode 100644 zinc/src/sbt-test/source-dependencies/transitive-early-stopping/A.scala
 create mode 100644 zinc/src/sbt-test/source-dependencies/transitive-early-stopping/B.scala
 create mode 100644 zinc/src/sbt-test/source-dependencies/transitive-early-stopping/C.scala
 create mode 100644 zinc/src/sbt-test/source-dependencies/transitive-early-stopping/D.scala
 create mode 100644 zinc/src/sbt-test/source-dependencies/transitive-early-stopping/changes/A.scala
 create mode 100644 zinc/src/sbt-test/source-dependencies/transitive-early-stopping/test

diff --git a/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/A.scala b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/A.scala
new file mode 100644
index 000000000..d26475934
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/A.scala
@@ -0,0 +1,3 @@
+object A {
+  val a: Int = 0
+}
\ No newline at end of file
diff --git a/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/B.scala b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/B.scala
new file mode 100644
index 000000000..e2eb7968d
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/B.scala
@@ -0,0 +1,3 @@
+object B {
+  val b = A.a
+}
\ No newline at end of file
diff --git a/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/C.scala b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/C.scala
new file mode 100644
index 000000000..75b2d7c07
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/C.scala
@@ -0,0 +1,4 @@
+object C {
+  val c1 = B.b
+  val c2: Int = 0;
+}
\ No newline at end of file
diff --git a/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/D.scala b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/D.scala
new file mode 100644
index 000000000..497b75205
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/D.scala
@@ -0,0 +1,3 @@
+object D {
+  val d: Int = C.c2
+}
\ No newline at end of file
diff --git a/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/changes/A.scala b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/changes/A.scala
new file mode 100644
index 000000000..822a53e8f
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/changes/A.scala
@@ -0,0 +1,3 @@
+object A {
+  val a: String = ""
+}
\ No newline at end of file
diff --git a/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/test b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/test
new file mode 100644
index 000000000..10867af1a
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/transitive-early-stopping/test
@@ -0,0 +1,5 @@
+> compile
+
+$ copy-file changes/A.scala A.scala
+> compile
+> checkIterations 4
\ No newline at end of file

From f2a5923abb94c2d76220043a7c369d6f7cc8fd92 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sun, 22 Sep 2024 21:04:05 -0700
Subject: [PATCH 09/54] Replace XOR with hashCode

---
 .../zinc-core/src/main/scala/sbt/internal/inc/Incremental.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 37e93decb..b16e6b6d5 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
@@ -886,7 +886,7 @@ private final class AnalysisCallback(
                 val externalParentsAPI = externalParents.map(analysis.apis.externalAPI)
                 val internalParentsAPI = internalParents.map(analysis.apis.internalAPI)
                 val parentsHashes = (externalParentsAPI ++ internalParentsAPI).map(_.extraHash())
-                parentsHashes.fold(currentExtraHash)(_ ^ _)
+                parentsHashes.hashCode
               case None => currentExtraHash
             }
           }

From 6cbcb28b7b2d9e48e8d5f0c7b62ff59ec5c84c75 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sun, 22 Sep 2024 21:28:52 -0700
Subject: [PATCH 10/54] Add currentExtraHash to be part of hashCode()

---
 .../zinc-core/src/main/scala/sbt/internal/inc/Incremental.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 b16e6b6d5..5db24c6db 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
@@ -886,7 +886,7 @@ private final class AnalysisCallback(
                 val externalParentsAPI = externalParents.map(analysis.apis.externalAPI)
                 val internalParentsAPI = internalParents.map(analysis.apis.internalAPI)
                 val parentsHashes = (externalParentsAPI ++ internalParentsAPI).map(_.extraHash())
-                parentsHashes.hashCode
+                (parentsHashes + currentExtraHash).hashCode()
               case None => currentExtraHash
             }
           }

From 698f3994e4ab41fc5a0ebf67937bbd3dfad97e55 Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Sun, 22 Sep 2024 17:10:13 +0000
Subject: [PATCH 11/54] Update util-control, util-interface, ... to 1.10.2

---
 project/Dependencies.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index 065d7351d..7387f699d 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -16,7 +16,7 @@ object Dependencies {
   val scala212_213 = Seq(defaultScalaVersion, scala213)
 
   private val ioVersion = nightlyVersion.getOrElse("1.10.0")
-  private val utilVersion = nightlyVersion.getOrElse("1.10.1")
+  private val utilVersion = nightlyVersion.getOrElse("1.10.2")
 
   private val sbtIO = "org.scala-sbt" %% "io" % ioVersion
 

From 95edec7b77cc85fd073a9d4eb140f6ecf5faa357 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Tue, 24 Sep 2024 00:10:37 -0700
Subject: [PATCH 12/54] Run AnalysisFormatBenchmark during CI

---
 .github/workflows/ci.yml | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 48653ce17..86b9faeec 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -30,6 +30,9 @@ jobs:
           - os: ubuntu-latest
             java: 21
             jobtype: 5
+          - os: ubuntu-latest
+            java: 21
+            jobtype: 6
     runs-on: ${{ matrix.os }}
     steps:
     - name: Checkout
@@ -64,19 +67,29 @@ jobs:
       shell: bash
       run: |
         sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Shapeless.*" "runBenchmarks"
-    - name: Checkout 1.10.x Branch (4, 5)
+    - name: Benchmark (AnalysisFormatBenchmark) (6)
+      if: ${{ matrix.jobtype == 6 }}
+      shell: bash
+      run: |
+        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*AnalysisFormatBenchmark.*" "zincBenchmarks/Jmh/clean" "runBenchmarks"
+    - name: Checkout Target Branch (4, 5)
       if: ${{ github.event_name == 'pull_request' && (matrix.jobtype == 4 || matrix.jobtype == 5) }}
       uses: actions/checkout@v4
       with:
         clean: false
-        ref: 1.10.x
-    - name: Benchmark (Scalac) against 1.10.x Branch (4)
+        ref: ${{ github.event.pull_request.base.ref }}
+    - name: Benchmark (Scalac) against Target Branch (4)
       if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 4 }}
       shell: bash
       run: |
         sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Scalac.*" "zincBenchmarks/Jmh/clean" "runBenchmarks"
-    - name: Benchmark (Shapeless) against 1.10.x Branch (5)
+    - name: Benchmark (Shapeless) against Target Branch (5)
       if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 5 }}
       shell: bash
       run: |
         sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Shapeless.*" "zincBenchmarks/Jmh/clean" "runBenchmarks"
+    - name: Benchmark (AnalysisFormatBenchmark) against Target Branch (6)
+      if: ${{ matrix.jobtype == 6 }}
+      shell: bash
+      run: |
+        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*AnalysisFormatBenchmark.*" "zincBenchmarks/Jmh/clean" "runBenchmarks"

From 4ecd7edee320d9314dd567f9ce681a9c1b587134 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Thu, 26 Sep 2024 00:23:33 -0700
Subject: [PATCH 13/54] Remove text & protobuf format from benchmarking

---
 .github/workflows/ci.yml                           | 13 ++++++-------
 .../test/scala/xsbt/AnalysisFormatBenchmark.scala  | 14 --------------
 2 files changed, 6 insertions(+), 21 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 86b9faeec..43f5dc7c7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -71,25 +71,24 @@ jobs:
       if: ${{ matrix.jobtype == 6 }}
       shell: bash
       run: |
-        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*AnalysisFormatBenchmark.*" "zincBenchmarks/Jmh/clean" "runBenchmarks"
-    - name: Checkout Target Branch (4, 5)
-      if: ${{ github.event_name == 'pull_request' && (matrix.jobtype == 4 || matrix.jobtype == 5) }}
+        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*AnalysisFormatBenchmark.*" "runBenchmarks"
+    - name: Checkout Target Branch (4-6)
+      if: ${{ github.event_name == 'pull_request' && (matrix.jobtype >= 4 || matrix.jobtype <= 6) }}
       uses: actions/checkout@v4
       with:
-        clean: false
         ref: ${{ github.event.pull_request.base.ref }}
     - name: Benchmark (Scalac) against Target Branch (4)
       if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 4 }}
       shell: bash
       run: |
-        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Scalac.*" "zincBenchmarks/Jmh/clean" "runBenchmarks"
+        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Scalac.*" "runBenchmarks"
     - name: Benchmark (Shapeless) against Target Branch (5)
       if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 5 }}
       shell: bash
       run: |
-        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Shapeless.*" "zincBenchmarks/Jmh/clean" "runBenchmarks"
+        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Shapeless.*" "runBenchmarks"
     - name: Benchmark (AnalysisFormatBenchmark) against Target Branch (6)
       if: ${{ matrix.jobtype == 6 }}
       shell: bash
       run: |
-        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*AnalysisFormatBenchmark.*" "zincBenchmarks/Jmh/clean" "runBenchmarks"
+        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*AnalysisFormatBenchmark.*" "runBenchmarks"
diff --git a/internal/zinc-benchmarks/src/test/scala/xsbt/AnalysisFormatBenchmark.scala b/internal/zinc-benchmarks/src/test/scala/xsbt/AnalysisFormatBenchmark.scala
index 353a52eb3..2c219c79c 100644
--- a/internal/zinc-benchmarks/src/test/scala/xsbt/AnalysisFormatBenchmark.scala
+++ b/internal/zinc-benchmarks/src/test/scala/xsbt/AnalysisFormatBenchmark.scala
@@ -62,26 +62,12 @@ class AnalysisFormatBenchmark {
     if (temp != null) IO.delete(temp)
   }
 
-  @Benchmark
-  def readBinary(bh: Blackhole): Unit = bh.consume(readAll("", FileAnalysisStore.binary(_)))
-
-  @Benchmark
-  def readText(bh: Blackhole): Unit = bh.consume(readAll("-ref-text", FileAnalysisStore.text(_)))
-
   @Benchmark
   def readConsistentBinary(bh: Blackhole): Unit =
     bh.consume(
       readAll("-ref-cbin", ConsistentFileAnalysisStore.binary(_, ReadWriteMappers.getEmptyMappers))
     )
 
-  @Benchmark
-  def writeBinary(bh: Blackhole): Unit =
-    bh.consume(writeAll("-test-bin", FileAnalysisStore.binary(_), cached))
-
-  @Benchmark
-  def writeText(bh: Blackhole): Unit =
-    bh.consume(writeAll("-test-text", FileAnalysisStore.text(_), cached))
-
   @Benchmark
   def writeConsistentBinary(bh: Blackhole): Unit =
     bh.consume(

From 1e41c1a6bf36bbaf8c40de0a271905062bdc0c15 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Thu, 26 Sep 2024 23:39:38 -0700
Subject: [PATCH 14/54] Add missing condition

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 43f5dc7c7..b936e63be 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -88,7 +88,7 @@ jobs:
       run: |
         sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Shapeless.*" "runBenchmarks"
     - name: Benchmark (AnalysisFormatBenchmark) against Target Branch (6)
-      if: ${{ matrix.jobtype == 6 }}
+      if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 6 }}
       shell: bash
       run: |
         sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*AnalysisFormatBenchmark.*" "runBenchmarks"

From 2855609eed404da0956ce514901f9a53a5eaad27 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Fri, 8 Dec 2023 17:26:42 -0800
Subject: [PATCH 15/54] Emits SourceInfos when incremental compilation fails

Zinc does not provide a way to surface list of all problems present in a
codebase.

This PR builds SourceInfos in Analysis Callback and in `handleErrors`,
the compiler bridge then throws an exception containing the SourceInfos
so build tools like sbt can access the informations.

Closes #932
---
 .../src/main/scala/xsbt/CompilerBridge.scala  | 29 +++++++++++++++----
 .../main/java/xsbti/AnalysisCallback3.java    | 21 ++++++++++++++
 .../src/main/java/xsbti/CompileFailed2.java   | 22 ++++++++++++++
 .../scala/sbt/internal/inc/RawCompiler.scala  |  4 ++-
 .../scala/sbt/internal/inc/Incremental.scala  | 21 +++++++++++++-
 .../src/main/scala/xsbti/TestCallback.scala   |  8 +++--
 .../src/main/scala/xsbti/TestSourceInfo.scala | 23 +++++++++++++++
 .../main/scala/xsbti/TestSourceInfos.scala    | 24 +++++++++++++++
 .../inc/IncrementalCompilerImpl.scala         |  8 +++++
 .../sbt/inc/IncrementalCompilerSpec.scala     | 21 ++++++++++++++
 10 files changed, 171 insertions(+), 10 deletions(-)
 create mode 100644 internal/compiler-interface/src/main/java/xsbti/AnalysisCallback3.java
 create mode 100644 internal/compiler-interface/src/main/java/xsbti/CompileFailed2.java
 create mode 100644 internal/zinc-testing/src/main/scala/xsbti/TestSourceInfo.scala
 create mode 100644 internal/zinc-testing/src/main/scala/xsbti/TestSourceInfos.scala

diff --git a/internal/compiler-bridge/src/main/scala/xsbt/CompilerBridge.scala b/internal/compiler-bridge/src/main/scala/xsbt/CompilerBridge.scala
index b491b0e71..77260e7ac 100644
--- a/internal/compiler-bridge/src/main/scala/xsbt/CompilerBridge.scala
+++ b/internal/compiler-bridge/src/main/scala/xsbt/CompilerBridge.scala
@@ -18,6 +18,8 @@ import scala.collection.mutable
 import scala.reflect.io.AbstractFile
 import scala.tools.nsc.CompilerCommand
 import Log.debug
+import xsbti.compile.analysis.ReadSourceInfos
+
 import java.io.File
 
 /**
@@ -49,6 +51,16 @@ class InterfaceCompileFailed(
     override val toString: String
 ) extends xsbti.CompileFailed
 
+class InterfaceCompileFailed2(
+    val arguments: Array[String],
+    val sourceInfos: ReadSourceInfos,
+    override val toString: String
+) extends xsbti.CompileFailed2 {
+  import scala.collection.JavaConverters._
+  val problems: Array[Problem] =
+    sourceInfos.getAllSourceInfos.values().asScala.flatMap(_.getReportedProblems).toArray
+}
+
 class InterfaceCompileCancelled(val arguments: Array[String], override val toString: String)
     extends xsbti.CompileCancelled
 
@@ -149,8 +161,8 @@ private final class CachedCompiler0(
       underlyingReporter: DelegatingReporter,
       compileProgress: CompileProgress
   ): Unit = {
-    // cast down to AnalysisCallback2
-    val callback2 = callback.asInstanceOf[xsbti.AnalysisCallback2]
+    // cast down to AnalysisCallback3
+    val callback3 = callback.asInstanceOf[xsbti.AnalysisCallback3]
 
     compiler.set(callback, underlyingReporter)
     if (command.shouldStopWithInfo) {
@@ -165,7 +177,7 @@ private final class CachedCompiler0(
       run.compileFiles(sources)
       processUnreportedWarnings(run)
       underlyingReporter.problems.foreach(p =>
-        callback2.problem2(
+        callback3.problem2(
           p.category,
           p.position,
           p.message,
@@ -180,8 +192,10 @@ private final class CachedCompiler0(
     }
 
     underlyingReporter.printSummary()
-    if (!noErrors(underlyingReporter))
-      handleErrors(underlyingReporter, log)
+    if (!noErrors(underlyingReporter)) {
+      val infos = callback3.getSourceInfos
+      handleErrors(infos, log)
+    }
 
     // the case where we cancelled compilation _after_ some compilation errors got reported
     // will be handled by line above so errors still will be reported properly just potentially not
@@ -195,6 +209,11 @@ private final class CachedCompiler0(
     throw new InterfaceCompileFailed(args, dreporter.problems, "Compilation failed")
   }
 
+  def handleErrors(sourceInfos: ReadSourceInfos, log: Logger): Nothing = {
+    debug(log, "Compilation failed (CompilerInterface)")
+    throw new InterfaceCompileFailed2(args, sourceInfos, "Compilation failed")
+  }
+
   def handleCompilationCancellation(dreporter: DelegatingReporter, log: Logger): Nothing = {
     assert(dreporter.cancelled, "We should get here only if when compilation got cancelled")
     debug(log, "Compilation cancelled (CompilerInterface)")
diff --git a/internal/compiler-interface/src/main/java/xsbti/AnalysisCallback3.java b/internal/compiler-interface/src/main/java/xsbti/AnalysisCallback3.java
new file mode 100644
index 000000000..649ad752e
--- /dev/null
+++ b/internal/compiler-interface/src/main/java/xsbti/AnalysisCallback3.java
@@ -0,0 +1,21 @@
+/*
+ * 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 xsbti;
+import xsbti.compile.analysis.ReadSourceInfos;
+
+/**
+ * Extension to {@link AnalysisCallback2}.
+ * Similar to {@link AnalysisCallback2}, it serves as compatibility layer for Scala compilers.
+ */
+public interface AnalysisCallback3 extends AnalysisCallback2 {
+    ReadSourceInfos getSourceInfos();
+}
diff --git a/internal/compiler-interface/src/main/java/xsbti/CompileFailed2.java b/internal/compiler-interface/src/main/java/xsbti/CompileFailed2.java
new file mode 100644
index 000000000..e5d4260a3
--- /dev/null
+++ b/internal/compiler-interface/src/main/java/xsbti/CompileFailed2.java
@@ -0,0 +1,22 @@
+/*
+ * 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 xsbti;
+
+import xsbti.compile.analysis.ReadSourceInfos;
+
+public abstract class CompileFailed2 extends CompileFailed {
+    /**
+     * Returns SourceInfos containing problems for each file.
+     * This includes problems found by most recent compilation run.
+     */
+    public abstract ReadSourceInfos sourceInfos();
+}
diff --git a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/RawCompiler.scala b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/RawCompiler.scala
index c90f8eda0..b22165f43 100644
--- a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/RawCompiler.scala
+++ b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/RawCompiler.scala
@@ -15,6 +15,7 @@ package inc
 
 import java.nio.file.Path
 import sbt.internal.util.FeedbackProvidedException
+import xsbti.compile.analysis.ReadSourceInfos
 import xsbti.compile.{ ClasspathOptions, ScalaInstance => XScalaInstance }
 
 /**
@@ -98,11 +99,12 @@ class CompileFailed(
     val arguments: Array[String],
     override val toString: String,
     val problems: Array[xsbti.Problem],
+    val sourceInfosOption: Option[ReadSourceInfos],
     cause: Throwable
 ) extends xsbti.CompileFailed(cause)
     with FeedbackProvidedException {
 
   def this(arguments: Array[String], toString: String, problems: Array[xsbti.Problem]) = {
-    this(arguments, toString, problems, null)
+    this(arguments, toString, problems, None, null)
   }
 }
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 37e93decb..508af7f52 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
@@ -590,7 +590,7 @@ private final class AnalysisCallback(
     progress: Option[CompileProgress],
     incHandlerOpt: Option[Incremental.IncrementalCallback],
     log: Logger
-) extends xsbti.AnalysisCallback2 {
+) extends xsbti.AnalysisCallback3 {
   import Incremental.CompileCycleResult
 
   // This must have a unique value per AnalysisCallback
@@ -1067,6 +1067,25 @@ private final class AnalysisCallback(
     }
   }
 
+  def getSourceInfos: SourceInfos = {
+    // Collect Source Info from current run
+    val sources = reporteds.keySet ++ unreporteds.keySet ++ mainClasses.keySet
+    val sourceToInfo = sources.map { source =>
+      val info = SourceInfos.makeInfo(
+        getOrNil(reporteds.iterator.map { case (k, v) => k -> v.asScala.toSeq }.toMap, source),
+        getOrNil(unreporteds.iterator.map { case (k, v) => k -> v.asScala.toSeq }.toMap, source),
+        getOrNil(mainClasses.iterator.map { case (k, v) => k -> v.asScala.toSeq }.toMap, source)
+      )
+      (source, info)
+    }.toMap
+    val sourceInfoFromCurrentRun = SourceInfos.of(sourceToInfo)
+    // Collect reported problems from previous run
+    incHandlerOpt.map(_.previousAnalysisPruned) match {
+      case Some(prevAnalysis) => prevAnalysis.infos ++ sourceInfoFromCurrentRun
+      case None               => sourceInfoFromCurrentRun
+    }
+  }
+
   override def apiPhaseCompleted(): Unit = {
     // If we know we're done with cycles (presumably because all sources were invalidated) we can store early analysis
     // and picke data now.  Otherwise, we need to wait for dependency information to decide if there are more cycles.
diff --git a/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala b/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala
index 94161317f..9426b8c6b 100644
--- a/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala
+++ b/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala
@@ -15,12 +15,12 @@ import java.io.File
 import java.nio.file.Path
 import java.{ util => ju }
 import ju.Optional
-
-import xsbti.api.{ DependencyContext, ClassLike }
+import xsbti.api.{ ClassLike, DependencyContext }
+import xsbti.compile.analysis.ReadSourceInfos
 
 import scala.collection.mutable.ArrayBuffer
 
-class TestCallback extends AnalysisCallback2 {
+class TestCallback extends AnalysisCallback3 {
   case class TestUsedName(name: String, scopes: ju.EnumSet[UseScope])
 
   val classDependencies = new ArrayBuffer[(String, String, DependencyContext)]
@@ -153,6 +153,8 @@ class TestCallback extends AnalysisCallback2 {
   override def isPickleJava: Boolean = false
 
   override def getPickleJarPair = Optional.empty()
+
+  override def getSourceInfos: ReadSourceInfos = new TestSourceInfos
 }
 
 object TestCallback {
diff --git a/internal/zinc-testing/src/main/scala/xsbti/TestSourceInfo.scala b/internal/zinc-testing/src/main/scala/xsbti/TestSourceInfo.scala
new file mode 100644
index 000000000..6ded26142
--- /dev/null
+++ b/internal/zinc-testing/src/main/scala/xsbti/TestSourceInfo.scala
@@ -0,0 +1,23 @@
+/*
+ * 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 xsbti
+
+import xsbti.compile.analysis.SourceInfo
+
+class TestSourceInfo extends SourceInfo {
+
+  override def getReportedProblems: Array[Problem] = Array.empty[Problem]
+
+  override def getUnreportedProblems: Array[Problem] = Array.empty[Problem]
+
+  override def getMainClasses: Array[String] = Array.empty[String]
+}
diff --git a/internal/zinc-testing/src/main/scala/xsbti/TestSourceInfos.scala b/internal/zinc-testing/src/main/scala/xsbti/TestSourceInfos.scala
new file mode 100644
index 000000000..060eec1c7
--- /dev/null
+++ b/internal/zinc-testing/src/main/scala/xsbti/TestSourceInfos.scala
@@ -0,0 +1,24 @@
+/*
+ * 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 xsbti
+
+import xsbti.compile.analysis.{ ReadSourceInfos, SourceInfo }
+
+import java.util
+
+class TestSourceInfos extends ReadSourceInfos {
+
+  override def get(sourceFile: VirtualFileRef): SourceInfo = new TestSourceInfo
+
+  override def getAllSourceInfos: util.Map[VirtualFileRef, SourceInfo] =
+    new util.HashMap[VirtualFileRef, SourceInfo]()
+}
diff --git a/zinc/src/main/scala/sbt/internal/inc/IncrementalCompilerImpl.scala b/zinc/src/main/scala/sbt/internal/inc/IncrementalCompilerImpl.scala
index 889400427..b954db27c 100644
--- a/zinc/src/main/scala/sbt/internal/inc/IncrementalCompilerImpl.scala
+++ b/zinc/src/main/scala/sbt/internal/inc/IncrementalCompilerImpl.scala
@@ -331,11 +331,19 @@ class IncrementalCompilerImpl extends IncrementalCompiler {
     try {
       compilerRun
     } catch {
+      case e: xsbti.CompileFailed2 => throw new sbt.internal.inc.CompileFailed(
+          e.arguments,
+          e.toString,
+          e.problems,
+          Some(e.sourceInfos()),
+          e,
+        ) // just ignore
       case e: xsbti.CompileFailed =>
         throw new sbt.internal.inc.CompileFailed(
           e.arguments,
           e.toString,
           e.problems,
+          None,
           e
         ) // just ignore
       case e: CompileFailed        => throw e // just ignore
diff --git a/zinc/src/test/scala/sbt/inc/IncrementalCompilerSpec.scala b/zinc/src/test/scala/sbt/inc/IncrementalCompilerSpec.scala
index c812e6898..ff1a4c7b3 100644
--- a/zinc/src/test/scala/sbt/inc/IncrementalCompilerSpec.scala
+++ b/zinc/src/test/scala/sbt/inc/IncrementalCompilerSpec.scala
@@ -240,4 +240,25 @@ class IncrementalCompilerSpec extends BaseCompilerSpec {
         }
       } finally comp.close()
   }
+
+  it should "emit SourceInfos when incremental compilation fails" in withTmpDir {
+    tmp =>
+      val project = VirtualSubproject(tmp.toPath / "p1")
+      val comp = project.setup.createCompiler()
+      val s1 = "object A { final val i = 1"
+      val f1 = StringVirtualFile("A.scala", s1)
+      try {
+        val exception = intercept[CompileFailed] {
+          comp.compile(f1)
+        }
+        exception.sourceInfosOption match {
+          case Some(sourceInfos) =>
+            assert(
+              !sourceInfos.getAllSourceInfos.isEmpty,
+              "Expected non-empty source infos"
+            )
+          case None => fail("Expected sourceInfos")
+        }
+      } finally comp.close()
+  }
 }

From a996c7392b13830a6cb5d01db00ccdd1dc61f8be Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sun, 29 Sep 2024 20:10:08 -0700
Subject: [PATCH 16/54] Add log for third class invalidation

---
 .../src/main/scala/sbt/internal/inc/IncrementalCommon.scala      | 1 +
 1 file changed, 1 insertion(+)

diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
index 4bdef942d..dfe6a869f 100644
--- a/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
+++ b/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
@@ -492,6 +492,7 @@ private[inc] abstract class IncrementalCommon(
       val transitive = IncrementalCommon.transitiveDeps(recompiledClasses, log)(dependsOnClass)
       (transitive -- recompiledClasses).filter(analysis.apis.internalAPI(_).hasMacro)
     }
+    log.debug(s"Invalidated macros due to upstream dependencies change: ${thirdClassInvalidation}")
 
     val newInvalidations =
       (firstClassInvalidation -- recompiledClasses) ++ secondClassInvalidation ++ thirdClassInvalidation

From ae2bf27c95f857c4104816acccb90e368053603d Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Tue, 1 Oct 2024 00:04:50 -0700
Subject: [PATCH 17/54] tell Scala Steward to ignore jgit update

---
 .scala-steward.conf | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/.scala-steward.conf b/.scala-steward.conf
index fd3928446..00e3eba3a 100644
--- a/.scala-steward.conf
+++ b/.scala-steward.conf
@@ -5,5 +5,6 @@ pullRequests.frequency = "14 days"
 updates.ignore = [
   # as per discussion on sbt/zinc#1236, this is
   # "if it ain't broke don't fix it" territory
-  { groupId = "com.google.protobuf" }
+  { groupId = "com.google.protobuf" },
+  { groupId = "org.eclipse.jgit" }
 ]

From 5a014fc8a959f17ef4eee82c9b44461032676688 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Wed, 2 Oct 2024 00:14:23 -0700
Subject: [PATCH 18/54] Make zinc-scripted show up in IntelliJ

---
 build.sbt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/build.sbt b/build.sbt
index 4afb5cd89..dc91d3e53 100644
--- a/build.sbt
+++ b/build.sbt
@@ -686,7 +686,6 @@ lazy val zincScripted = (projectMatrix in internalPath / "zinc-scripted")
   .enablePlugins(BuildInfoPlugin)
   .settings(
     baseSettings,
-    ideSkipProject := true, // otherwise IntelliJ complains
     publish / skip := true,
     name := "zinc Scripted",
     Compile / buildInfo := Nil, // Only generate build info for tests

From 7696f6ca622f9416e4a1c650d8035aa5ac166f1f Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Fri, 27 Sep 2024 11:55:44 -0700
Subject: [PATCH 19/54] Generate AbstractZincFile during -sourcepath workflow

In certain codepath, unit.source.file is a PlainFile, which causes a MatchError.

This PR converts PlainFile to AbstractZincFile, avoiding the MatchError.
---
 .../src/main/scala/xsbt/CallbackGlobal.scala         | 12 +++++++++++-
 .../src/main/java/xsbti/AnalysisCallback3.java       |  5 +++++
 .../main/scala/sbt/internal/inc/Incremental.scala    |  2 ++
 .../src/test/scala/sbt/internal/inc/IncHandler.scala |  5 ++++-
 .../src/main/scala/xsbti/TestCallback.scala          |  4 ++++
 .../sourcepath-virtualfile/changes/B.scala           |  3 +++
 .../sourcepath-virtualfile/incOptions.properties     |  1 +
 .../sourcepath-virtualfile/src/main/scala/A.scala    |  1 +
 .../sourcepath-virtualfile/src/main/scala/B.scala    |  3 +++
 .../source-dependencies/sourcepath-virtualfile/test  |  6 ++++++
 10 files changed, 40 insertions(+), 2 deletions(-)
 create mode 100644 zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/changes/B.scala
 create mode 100644 zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/incOptions.properties
 create mode 100644 zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/src/main/scala/A.scala
 create mode 100644 zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/src/main/scala/B.scala
 create mode 100644 zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/test

diff --git a/internal/compiler-bridge/src/main/scala/xsbt/CallbackGlobal.scala b/internal/compiler-bridge/src/main/scala/xsbt/CallbackGlobal.scala
index 0b3663ece..4c6f53d9d 100644
--- a/internal/compiler-bridge/src/main/scala/xsbt/CallbackGlobal.scala
+++ b/internal/compiler-bridge/src/main/scala/xsbt/CallbackGlobal.scala
@@ -11,7 +11,7 @@
 
 package xsbt
 
-import xsbti.{ AnalysisCallback, Severity }
+import xsbti.{ AnalysisCallback, AnalysisCallback3, Severity }
 import xsbti.compile._
 
 import scala.tools.nsc._
@@ -20,6 +20,7 @@ import java.nio.file.{ Files, Path }
 
 import scala.reflect.io.PlainFile
 import scala.reflect.ReflectAccess._
+import scala.reflect.internal.util.BatchSourceFile
 
 /** Defines the interface of the incremental compiler hiding implementation details. */
 sealed abstract class CallbackGlobal(
@@ -78,6 +79,15 @@ sealed class ZincCompiler(settings: Settings, dreporter: DelegatingReporter, out
     extends CallbackGlobal(settings, dreporter, output)
     with ZincGlobalCompat {
 
+  override def getSourceFile(f: AbstractFile): BatchSourceFile = {
+    val file = (f, callback) match {
+      case (plainFile: PlainFile, callback3: AnalysisCallback3) =>
+        AbstractZincFile(callback3.toVirtualFile(plainFile.file.toPath))
+      case _ => f
+    }
+    super.getSourceFile(file)
+  }
+
   final class ZincRun(compileProgress: CompileProgress) extends Run {
     override def informUnitStarting(phase: Phase, unit: CompilationUnit): Unit = {
       compileProgress.startUnit(phase.name, unit.source.path)
diff --git a/internal/compiler-interface/src/main/java/xsbti/AnalysisCallback3.java b/internal/compiler-interface/src/main/java/xsbti/AnalysisCallback3.java
index 649ad752e..b91afd028 100644
--- a/internal/compiler-interface/src/main/java/xsbti/AnalysisCallback3.java
+++ b/internal/compiler-interface/src/main/java/xsbti/AnalysisCallback3.java
@@ -10,12 +10,17 @@
  */
 
 package xsbti;
+
 import xsbti.compile.analysis.ReadSourceInfos;
 
+import java.nio.file.Path;
+
 /**
  * Extension to {@link AnalysisCallback2}.
  * Similar to {@link AnalysisCallback2}, it serves as compatibility layer for Scala compilers.
  */
 public interface AnalysisCallback3 extends AnalysisCallback2 {
+    VirtualFile toVirtualFile(Path path);
+
     ReadSourceInfos getSourceInfos();
 }
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 5035187c5..72ec426a9 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
@@ -674,6 +674,8 @@ private final class AnalysisCallback(
     ()
   }
 
+  override def toVirtualFile(path: Path): VirtualFile = converter.toVirtualFile(path)
+
   override def problem2(
       category: String,
       pos: Position,
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 7a76d0cf8..4d9cba150 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
@@ -795,7 +795,10 @@ case class ProjectStructure(
     }
     val scalacOptions: List[String] =
       Option(map.get("scalac.options")).toList
-        .flatMap(_.toString.split(" +").toList) ++
+        .flatMap(_.toString.split(" +").toList.map(_.replace(
+          "[basedir]",
+          baseDirectory.toAbsolutePath.toString
+        ))) ++
         // for now assume export pipelining for all pipelining subprojects
         (if (incOptions.pipelining) List("-Ypickle-java", "-Ypickle-write", earlyOutput.toString)
          else Nil)
diff --git a/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala b/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala
index 9426b8c6b..484407c2f 100644
--- a/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala
+++ b/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala
@@ -154,6 +154,10 @@ class TestCallback extends AnalysisCallback3 {
 
   override def getPickleJarPair = Optional.empty()
 
+  override def toVirtualFile(path: Path): VirtualFile = {
+    throw new UnsupportedOperationException("This method should not be called in tests")
+  }
+
   override def getSourceInfos: ReadSourceInfos = new TestSourceInfos
 }
 
diff --git a/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/changes/B.scala b/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/changes/B.scala
new file mode 100644
index 000000000..3826c673f
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/changes/B.scala
@@ -0,0 +1,3 @@
+class B {
+  def f: A = new A()
+}
diff --git a/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/incOptions.properties b/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/incOptions.properties
new file mode 100644
index 000000000..6b07ac31d
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/incOptions.properties
@@ -0,0 +1 @@
+scalac.options = -sourcepath [basedir]/src/main/scala
diff --git a/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/src/main/scala/A.scala b/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/src/main/scala/A.scala
new file mode 100644
index 000000000..83d15dc73
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/src/main/scala/A.scala
@@ -0,0 +1 @@
+class A
diff --git a/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/src/main/scala/B.scala b/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/src/main/scala/B.scala
new file mode 100644
index 000000000..a97bc1e39
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/src/main/scala/B.scala
@@ -0,0 +1,3 @@
+class B {
+  def f = new A()
+}
diff --git a/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/test b/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/test
new file mode 100644
index 000000000..45605ea4a
--- /dev/null
+++ b/zinc/src/sbt-test/source-dependencies/sourcepath-virtualfile/test
@@ -0,0 +1,6 @@
+> compile
+
+$ copy-file changes/B.scala src/main/scala/B.scala
+$ touch src/main/scala/A.scala
+
+> compile

From 5481d6ca771d7b5d94e2f0357ae51b0f92708dba Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sat, 5 Oct 2024 23:38:14 -0700
Subject: [PATCH 20/54] Fix typo in ci.yml

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b936e63be..92a3d2df8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -73,7 +73,7 @@ jobs:
       run: |
         sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*AnalysisFormatBenchmark.*" "runBenchmarks"
     - name: Checkout Target Branch (4-6)
-      if: ${{ github.event_name == 'pull_request' && (matrix.jobtype >= 4 || matrix.jobtype <= 6) }}
+      if: ${{ github.event_name == 'pull_request' && (matrix.jobtype >= 4 && matrix.jobtype <= 6) }}
       uses: actions/checkout@v4
       with:
         ref: ${{ github.event.pull_request.base.ref }}

From bca00e5726f691faa0400cc521781b6481df07db Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sat, 5 Oct 2024 23:07:52 -0700
Subject: [PATCH 21/54] Add 25 minute timeout for CI

---
 .github/workflows/ci.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b936e63be..a36e73a74 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -5,6 +5,7 @@ on:
 
 jobs:
   test:
+    timeout-minutes: 25
     strategy:
       fail-fast: false
       matrix:

From 7d4e43a7be8506f39611d9d6845f1fdfd29e8bc9 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Tue, 8 Oct 2024 13:23:12 -0700
Subject: [PATCH 22/54] Fix CVE

---
 build.sbt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/build.sbt b/build.sbt
index dc91d3e53..79775dc50 100644
--- a/build.sbt
+++ b/build.sbt
@@ -327,7 +327,7 @@ lazy val zincPersistCore = (project in internalPath / "zinc-persist-core")
     crossPaths := false,
     autoScalaLibrary := false,
     exportJars := true,
-    ProtobufConfig / version := "3.24.4",
+    ProtobufConfig / version := "3.25.5",
     publish / skip := true,
     assembly / assemblyShadeRules := Seq(
       ShadeRule

From 13ab8e6c05e419d6e3b67352b555e8eb623862f1 Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Tue, 8 Oct 2024 20:55:08 +0000
Subject: [PATCH 23/54] Update sbt-pgp to 2.3.0

---
 project/plugins.sbt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/plugins.sbt b/project/plugins.sbt
index bf4128449..e181053d0 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -1,7 +1,7 @@
 scalacOptions += "-feature"
 
 addSbtPlugin("com.github.sbt" % "sbt-dynver" % "5.0.1")
-addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.2.1")
+addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.3.0")
 addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.5.2")
 addSbtPlugin("org.scala-sbt" % "sbt-contraband" % "0.5.3")
 addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.4.7")

From 11f8c6d250838e0089f761e3fc4ad3c3fe890d9f Mon Sep 17 00:00:00 2001
From: Scala Steward <scala_steward@virtuslab.com>
Date: Tue, 8 Oct 2024 20:55:32 +0000
Subject: [PATCH 24/54] Update sbt-contraband to 0.6.0

---
 project/plugins.sbt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/plugins.sbt b/project/plugins.sbt
index bf4128449..1e0435f87 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -3,7 +3,7 @@ scalacOptions += "-feature"
 addSbtPlugin("com.github.sbt" % "sbt-dynver" % "5.0.1")
 addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.2.1")
 addSbtPlugin("org.scalameta" % "sbt-scalafmt" % "2.5.2")
-addSbtPlugin("org.scala-sbt" % "sbt-contraband" % "0.5.3")
+addSbtPlugin("org.scala-sbt" % "sbt-contraband" % "0.6.0")
 addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.4.7")
 addSbtPlugin("de.heikoseeberger" % "sbt-header" % "5.10.0")
 addSbtPlugin("com.github.sbt" % "sbt-protobuf" % "0.8.0")

From 1326c4fee28c5581a82da4cee1cad2e9aa5f8141 Mon Sep 17 00:00:00 2001
From: adpi2 <adrien.piquerez@gmail.com>
Date: Wed, 9 Oct 2024 10:00:46 +0200
Subject: [PATCH 25/54] Submit dependency graph for security alert

---
 .github/workflows/dependency-graph.yml | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 .github/workflows/dependency-graph.yml

diff --git a/.github/workflows/dependency-graph.yml b/.github/workflows/dependency-graph.yml
new file mode 100644
index 000000000..be2039b71
--- /dev/null
+++ b/.github/workflows/dependency-graph.yml
@@ -0,0 +1,16 @@
+# .github/workflows/dependency-graph.yml
+name: Submit Dependency Graph
+on:
+  push:
+    branches: [1.10.x] # default branch of the project
+permissions: {}
+jobs:
+  submit-graph:
+    permissions:
+      contents: write # to submit the dependency graph
+
+    name: Submit Dependency Graph
+    runs-on: ubuntu-latest # or windows-latest, or macOS-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: scalacenter/sbt-dependency-submission@v3

From 51301199aca4cfe21cce7d46bf6dc37c8431ceb3 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Wed, 9 Oct 2024 10:59:36 -0700
Subject: [PATCH 26/54] Try unblock CI

---
 .github/workflows/ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a4512ecba..dff02a4de 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -44,6 +44,8 @@ jobs:
         distribution: temurin
         java-version: ${{ matrix.java }}
         cache: sbt
+    - name: Setup SBT
+      uses: sbt/setup-sbt@v1
     - name: Build and test (1)
       if: ${{ matrix.jobtype == 1 }}
       shell: bash

From 1c39dc2b48900ad7d1b8f177fe438144d83e3432 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Wed, 9 Oct 2024 11:05:02 -0700
Subject: [PATCH 27/54] Add sbt setup to all workflows

---
 .github/workflows/dependency-graph.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/dependency-graph.yml b/.github/workflows/dependency-graph.yml
index be2039b71..3c73297f1 100644
--- a/.github/workflows/dependency-graph.yml
+++ b/.github/workflows/dependency-graph.yml
@@ -13,4 +13,5 @@ jobs:
     runs-on: ubuntu-latest # or windows-latest, or macOS-latest
     steps:
       - uses: actions/checkout@v4
+      - uses: sbt/setup-sbt@v1
       - uses: scalacenter/sbt-dependency-submission@v3

From 33e2aa29e732334166fa530409bb1e56e5ca9ea7 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Wed, 9 Oct 2024 11:09:33 -0700
Subject: [PATCH 28/54] Add develop branch

---
 .github/workflows/dependency-graph.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/dependency-graph.yml b/.github/workflows/dependency-graph.yml
index 3c73297f1..230f09c17 100644
--- a/.github/workflows/dependency-graph.yml
+++ b/.github/workflows/dependency-graph.yml
@@ -2,7 +2,7 @@
 name: Submit Dependency Graph
 on:
   push:
-    branches: [1.10.x] # default branch of the project
+    branches: [1.10.x, develop] # default branch of the project
 permissions: {}
 jobs:
   submit-graph:

From 452bc11e05ba9b308e268eb6bbbfe1ae33b73cce Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Wed, 9 Oct 2024 11:39:34 -0700
Subject: [PATCH 29/54] Fix sbt command not found after checkout target branch

---
 .github/workflows/ci.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index dff02a4de..59ea4776a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -80,6 +80,9 @@ jobs:
       uses: actions/checkout@v4
       with:
         ref: ${{ github.event.pull_request.base.ref }}
+    - name: Setup SBT
+      uses: sbt/setup-sbt@v1
+      if: ${{ github.event_name == 'pull_request' && (matrix.jobtype >= 4 && matrix.jobtype <= 6) }}
     - name: Benchmark (Scalac) against Target Branch (4)
       if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 4 }}
       shell: bash

From 7aa92cb48872f28dd44c1bb7520a84a0e02f230e Mon Sep 17 00:00:00 2001
From: Scala Steward <43047562+scala-steward@users.noreply.github.com>
Date: Thu, 10 Oct 2024 23:42:11 +0200
Subject: [PATCH 30/54] Update scala-compiler, scala-library to 2.12.20 (#1392)

Co-authored-by: Seth Tisue <seth@tisue.net>
---
 project/Dependencies.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index 7387f699d..c345bbca3 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -7,7 +7,7 @@ object Dependencies {
 
   val scala210 = "2.10.7"
   val scala211 = "2.11.12"
-  val scala212 = "2.12.19"
+  val scala212 = "2.12.20"
   val scala213 = "2.13.14"
   val scala3ForBridge = "3.3.1"
   val scala213ForBridge = "2.13.14"

From 7e34dc8052b895a06cfddba589cc30a39bf7b0ce Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Fri, 11 Oct 2024 17:11:24 -0700
Subject: [PATCH 31/54] Handle specific javac emitted output

---
 .../scala/sbt/internal/inc/javac/JavaErrorParser.scala   | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/JavaErrorParser.scala b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/JavaErrorParser.scala
index cb8c86058..cbb1ad3a0 100644
--- a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/JavaErrorParser.scala
+++ b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/JavaErrorParser.scala
@@ -270,10 +270,17 @@ class JavaErrorParser(relativeDir: File = new File(new File(".").getAbsolutePath
         ()
     }
 
+  val nonProblem: Parser[Unit] = {
+    val skipLine =
+      ("Loading source file" | "Constructing Javadoc information") ~ """[^\r\n]*(\r\n|\n)?""".r
+    rep(skipLine) ^^ (_ => ())
+  }
+
   val potentialProblem: Parser[Problem] =
     warningMessage | errorMessage | noteMessage | javacError | javacWarning
 
-  val javacOutput: Parser[Seq[Problem]] = rep(potentialProblem) <~ opt(outputSumamry)
+  val javacOutput: Parser[Seq[Problem]] =
+    nonProblem ~> rep(potentialProblem) <~ opt(outputSumamry)
 
   /**
    * Example:

From 8c4a5397146af0d6a02b339d7a424b7b6cd6d8b1 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Fri, 11 Oct 2024 17:59:46 -0700
Subject: [PATCH 32/54] Add extra opt()

---
 .../src/main/scala/sbt/internal/inc/javac/JavaErrorParser.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/JavaErrorParser.scala b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/JavaErrorParser.scala
index cbb1ad3a0..6692f3ef5 100644
--- a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/JavaErrorParser.scala
+++ b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/javac/JavaErrorParser.scala
@@ -280,7 +280,7 @@ class JavaErrorParser(relativeDir: File = new File(new File(".").getAbsolutePath
     warningMessage | errorMessage | noteMessage | javacError | javacWarning
 
   val javacOutput: Parser[Seq[Problem]] =
-    nonProblem ~> rep(potentialProblem) <~ opt(outputSumamry)
+    opt(nonProblem) ~> rep(potentialProblem) <~ opt(outputSumamry)
 
   /**
    * Example:

From 980b91d8d176f9f918d63234a53a8867ea962439 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Fri, 11 Oct 2024 18:11:26 -0700
Subject: [PATCH 33/54] Add test case to JavaErrorParserSpec

---
 ...erSpec.scala => JavaErrorParserSpec.scala} | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 rename internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/{javaErrorParserSpec.scala => JavaErrorParserSpec.scala} (89%)

diff --git a/internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/javaErrorParserSpec.scala b/internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/JavaErrorParserSpec.scala
similarity index 89%
rename from internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/javaErrorParserSpec.scala
rename to internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/JavaErrorParserSpec.scala
index 5e4d8244f..b092adfff 100644
--- a/internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/javaErrorParserSpec.scala
+++ b/internal/zinc-compile-core/src/test/scala/sbt/internal/inc/javac/JavaErrorParserSpec.scala
@@ -23,6 +23,7 @@ class JavaErrorParserSpec extends UnitSpec with Diagrams {
   "The JavaErrorParser" should "be able to parse Linux errors" in parseSampleLinux()
   it should "be able to parse windows file names" in parseWindowsFile()
   it should "be able to parse windows errors" in parseSampleWindows()
+  it should "be able to parse javac non-problems" in parseSampleNonProblem()
   it should "be able to parse javac warnings" in parseJavacWarning()
   it should "be able to parse javac errors" in parseSampleJavac()
   it should "register the position of errors" in parseErrorPosition()
@@ -47,6 +48,14 @@ class JavaErrorParserSpec extends UnitSpec with Diagrams {
     problems(0).position.sourcePath.get shouldBe (windowsFile)
   }
 
+  def parseSampleNonProblem() = {
+    val parser = new JavaErrorParser()
+    val logger = ConsoleLogger()
+    val problems = parser.parseProblems(sampleNonProblemMessage, logger)
+
+    assert(problems.size == 2)
+  }
+
   def parseWindowsFile() = {
     val parser = new JavaErrorParser()
     parser.parse(parser.fileAndLineNo, sampleWindowsMessage) match {
@@ -198,6 +207,21 @@ class JavaErrorParserSpec extends UnitSpec with Diagrams {
       |return baz();
     """.stripMargin
 
+  def sampleNonProblemMessage =
+    raw"""
+       |Loading source file D:\Repos\zinc\internal\zinc-compile-core\target\jvm-2.13\test-classes\sbt\internal\inc\javac\test1.java...
+       |Constructing Javadoc information...
+       |D:\Repos\zinc\internal\zinc-compile-core\target\jvm-2.13\test-classes\sbt\internal\inc\javac\test1.java:14: error: class Test is public, should be declared in a file named Test.java
+       |public class Test {
+       |       ^
+       |D:\Repos\zinc\internal\zinc-compile-core\target\jvm-2.13\test-classes\sbt\internal\inc\javac\test1.java:15: error: cannot find symbol
+       |    public NotFound foo() { return 5; }
+       |           ^
+       |  symbol:   class NotFound
+       |  location: class Test
+       |2 errors
+    """.stripMargin.trim
+
   def sampleJavacWarning =
     "warning: [options] system modules path not set in conjunction with -source 17"
 

From 056a71218b7d1f44858afc72e3a1d1c8eaf255f8 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Wed, 9 Oct 2024 18:06:17 -0700
Subject: [PATCH 34/54] regenerate artifacts

---
 .../src/main/contraband-java/xsbti/api/Access.java              | 2 +-
 .../src/main/contraband-java/xsbti/api/AnalyzedClass.java       | 2 +-
 .../src/main/contraband-java/xsbti/api/Annotated.java           | 2 +-
 .../src/main/contraband-java/xsbti/api/Annotation.java          | 2 +-
 .../src/main/contraband-java/xsbti/api/AnnotationArgument.java  | 2 +-
 .../src/main/contraband-java/xsbti/api/ClassDefinition.java     | 2 +-
 .../src/main/contraband-java/xsbti/api/ClassLike.java           | 2 +-
 .../src/main/contraband-java/xsbti/api/ClassLikeDef.java        | 2 +-
 .../src/main/contraband-java/xsbti/api/Companions.java          | 2 +-
 .../src/main/contraband-java/xsbti/api/Constant.java            | 2 +-
 .../src/main/contraband-java/xsbti/api/Def.java                 | 2 +-
 .../src/main/contraband-java/xsbti/api/Definition.java          | 2 +-
 .../src/main/contraband-java/xsbti/api/DefinitionType.java      | 2 +-
 .../src/main/contraband-java/xsbti/api/DependencyContext.java   | 2 +-
 .../src/main/contraband-java/xsbti/api/EmptyType.java           | 2 +-
 .../src/main/contraband-java/xsbti/api/Existential.java         | 2 +-
 .../src/main/contraband-java/xsbti/api/ExternalDependency.java  | 2 +-
 .../src/main/contraband-java/xsbti/api/FieldLike.java           | 2 +-
 .../src/main/contraband-java/xsbti/api/Id.java                  | 2 +-
 .../src/main/contraband-java/xsbti/api/IdQualifier.java         | 2 +-
 .../src/main/contraband-java/xsbti/api/InternalDependency.java  | 2 +-
 .../src/main/contraband-java/xsbti/api/MethodParameter.java     | 2 +-
 .../src/main/contraband-java/xsbti/api/NameHash.java            | 2 +-
 .../src/main/contraband-java/xsbti/api/Package.java             | 2 +-
 .../src/main/contraband-java/xsbti/api/ParameterList.java       | 2 +-
 .../src/main/contraband-java/xsbti/api/ParameterModifier.java   | 2 +-
 .../src/main/contraband-java/xsbti/api/ParameterRef.java        | 2 +-
 .../src/main/contraband-java/xsbti/api/Parameterized.java       | 2 +-
 .../main/contraband-java/xsbti/api/ParameterizedDefinition.java | 2 +-
 .../src/main/contraband-java/xsbti/api/Path.java                | 2 +-
 .../src/main/contraband-java/xsbti/api/PathComponent.java       | 2 +-
 .../src/main/contraband-java/xsbti/api/Polymorphic.java         | 2 +-
 .../src/main/contraband-java/xsbti/api/Private.java             | 2 +-
 .../src/main/contraband-java/xsbti/api/Projection.java          | 2 +-
 .../src/main/contraband-java/xsbti/api/Protected.java           | 2 +-
 .../src/main/contraband-java/xsbti/api/Public.java              | 2 +-
 .../src/main/contraband-java/xsbti/api/Qualified.java           | 2 +-
 .../src/main/contraband-java/xsbti/api/Qualifier.java           | 2 +-
 .../src/main/contraband-java/xsbti/api/Singleton.java           | 2 +-
 .../src/main/contraband-java/xsbti/api/Structure.java           | 2 +-
 .../src/main/contraband-java/xsbti/api/Super.java               | 2 +-
 .../src/main/contraband-java/xsbti/api/This.java                | 2 +-
 .../src/main/contraband-java/xsbti/api/ThisQualifier.java       | 2 +-
 .../src/main/contraband-java/xsbti/api/Type.java                | 2 +-
 .../src/main/contraband-java/xsbti/api/TypeAlias.java           | 2 +-
 .../src/main/contraband-java/xsbti/api/TypeDeclaration.java     | 2 +-
 .../src/main/contraband-java/xsbti/api/TypeMember.java          | 2 +-
 .../src/main/contraband-java/xsbti/api/TypeParameter.java       | 2 +-
 .../src/main/contraband-java/xsbti/api/Unqualified.java         | 2 +-
 .../src/main/contraband-java/xsbti/api/Val.java                 | 2 +-
 .../src/main/contraband-java/xsbti/api/Var.java                 | 2 +-
 .../src/main/contraband-java/xsbti/api/Variance.java            | 2 +-
 .../contraband-java/xsbti/compile/ClassFileManagerType.java     | 2 +-
 .../main/contraband-java/xsbti/compile/ClasspathOptions.java    | 2 +-
 .../src/main/contraband-java/xsbti/compile/CompileOptions.java  | 2 +-
 .../src/main/contraband-java/xsbti/compile/CompileResult.java   | 2 +-
 .../src/main/contraband-java/xsbti/compile/Compilers.java       | 2 +-
 .../xsbti/compile/DeleteImmediatelyManagerType.java             | 2 +-
 .../src/main/contraband-java/xsbti/compile/FileHash.java        | 2 +-
 .../src/main/contraband-java/xsbti/compile/IncOptions.java      | 2 +-
 .../src/main/contraband-java/xsbti/compile/IncToolOptions.java  | 2 +-
 .../src/main/contraband-java/xsbti/compile/Inputs.java          | 2 +-
 .../src/main/contraband-java/xsbti/compile/MiniOptions.java     | 2 +-
 .../src/main/contraband-java/xsbti/compile/MiniSetup.java       | 2 +-
 .../src/main/contraband-java/xsbti/compile/PreviousResult.java  | 2 +-
 .../src/main/contraband-java/xsbti/compile/Setup.java           | 2 +-
 .../contraband-java/xsbti/compile/TransactionalManagerType.java | 2 +-
 .../src/main/contraband-java/xsbti/ReporterConfig.java          | 2 +-
 68 files changed, 68 insertions(+), 68 deletions(-)

diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Access.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Access.java
index 7b3be0e32..74a0235dd 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Access.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Access.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/AnalyzedClass.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/AnalyzedClass.java
index a0f614bd3..f931ba0d7 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/AnalyzedClass.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/AnalyzedClass.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Annotated.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Annotated.java
index 6e78e9566..5ab0aa594 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Annotated.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Annotated.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Annotation.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Annotation.java
index 4afa7b7db..93a76a9d2 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Annotation.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Annotation.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/AnnotationArgument.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/AnnotationArgument.java
index 8604c7cf6..5009f8e68 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/AnnotationArgument.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/AnnotationArgument.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassDefinition.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassDefinition.java
index a1a95f09d..ea58ea287 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassDefinition.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassDefinition.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassLike.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassLike.java
index 1bf398b59..b09cf3ec5 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassLike.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassLike.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassLikeDef.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassLikeDef.java
index 28fc4712e..1a8755dcb 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassLikeDef.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ClassLikeDef.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Companions.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Companions.java
index d7bf4e99e..25ddd7103 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Companions.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Companions.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Constant.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Constant.java
index 1bd1b5070..343148923 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Constant.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Constant.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Def.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Def.java
index 3d893a184..795393b30 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Def.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Def.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Definition.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Definition.java
index 4c204a9b8..ee0978c32 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Definition.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Definition.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/DefinitionType.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/DefinitionType.java
index d2f7d505f..dd5782da1 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/DefinitionType.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/DefinitionType.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/DependencyContext.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/DependencyContext.java
index 9bc6d4db1..2270e886b 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/DependencyContext.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/DependencyContext.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/EmptyType.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/EmptyType.java
index 011968329..aa34a585b 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/EmptyType.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/EmptyType.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Existential.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Existential.java
index 47f840e3b..a84934e3f 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Existential.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Existential.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ExternalDependency.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ExternalDependency.java
index 447539bb6..e4978044a 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ExternalDependency.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ExternalDependency.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/FieldLike.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/FieldLike.java
index ceff4862e..4e33a1566 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/FieldLike.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/FieldLike.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Id.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Id.java
index d292a7d45..0ca918d15 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Id.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Id.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/IdQualifier.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/IdQualifier.java
index 9956bb66c..5c6830129 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/IdQualifier.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/IdQualifier.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/InternalDependency.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/InternalDependency.java
index 7f4d9020d..849cbd060 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/InternalDependency.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/InternalDependency.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/MethodParameter.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/MethodParameter.java
index 85befeee7..30e2ebec5 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/MethodParameter.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/MethodParameter.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/NameHash.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/NameHash.java
index 153f18243..8470e197c 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/NameHash.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/NameHash.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Package.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Package.java
index 831b1d46c..6b2f66ba5 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Package.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Package.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterList.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterList.java
index d902ad85f..4d72c41ea 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterList.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterList.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterModifier.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterModifier.java
index cea8bbc97..5d5292ca7 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterModifier.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterModifier.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterRef.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterRef.java
index 058f1c8af..7c9982bca 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterRef.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterRef.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Parameterized.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Parameterized.java
index 5efedda68..ac1f10833 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Parameterized.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Parameterized.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterizedDefinition.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterizedDefinition.java
index 604374ea1..43d147869 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterizedDefinition.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ParameterizedDefinition.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Path.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Path.java
index 8ff2bebef..a4fd51918 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Path.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Path.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/PathComponent.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/PathComponent.java
index d0568001e..cc51b7924 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/PathComponent.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/PathComponent.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Polymorphic.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Polymorphic.java
index 8a70bb1cf..934a717c9 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Polymorphic.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Polymorphic.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Private.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Private.java
index 0c35cd88e..d02b993a7 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Private.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Private.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Projection.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Projection.java
index 509a63f5d..b22568df3 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Projection.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Projection.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Protected.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Protected.java
index 0090f16e4..1dd167ad3 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Protected.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Protected.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Public.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Public.java
index 1d777f7a5..d2c412182 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Public.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Public.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Qualified.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Qualified.java
index ebeac7390..5f927cd82 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Qualified.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Qualified.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Qualifier.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Qualifier.java
index 7c9064852..b43b7d80b 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Qualifier.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Qualifier.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Singleton.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Singleton.java
index 0a66cb824..1af73e7a2 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Singleton.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Singleton.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Structure.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Structure.java
index 6bbb86af9..e7b4e88a5 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Structure.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Structure.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Super.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Super.java
index 3219722f4..ab570c3fb 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Super.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Super.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/This.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/This.java
index b1ae7a006..cb9627e9e 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/This.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/This.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ThisQualifier.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ThisQualifier.java
index 4a9781cce..9cc5263c8 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/ThisQualifier.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/ThisQualifier.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Type.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Type.java
index a427839a4..1a7d51f8a 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Type.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Type.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeAlias.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeAlias.java
index 658ca3512..c193e87ab 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeAlias.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeAlias.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeDeclaration.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeDeclaration.java
index 525ba41eb..5d6db0148 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeDeclaration.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeDeclaration.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeMember.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeMember.java
index 040924c68..699b0f25b 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeMember.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeMember.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeParameter.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeParameter.java
index a02a4f3f3..5481e8f46 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeParameter.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/TypeParameter.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Unqualified.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Unqualified.java
index b481a4c97..505cce650 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Unqualified.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Unqualified.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Val.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Val.java
index 7a5c5fb42..41ff176cc 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Val.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Val.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Var.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Var.java
index a70498a3b..09db27aaa 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Var.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Var.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Variance.java b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Variance.java
index e8991d108..efeb54baf 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/api/Variance.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/api/Variance.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/ClassFileManagerType.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/ClassFileManagerType.java
index 0a7b00286..a7efe1b1a 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/ClassFileManagerType.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/ClassFileManagerType.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/ClasspathOptions.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/ClasspathOptions.java
index 3fac455fc..23e267d75 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/ClasspathOptions.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/ClasspathOptions.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/CompileOptions.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/CompileOptions.java
index 35ce9fb2e..85c8cf477 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/CompileOptions.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/CompileOptions.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/CompileResult.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/CompileResult.java
index 39759a3fe..77a38fcd2 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/CompileResult.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/CompileResult.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Compilers.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Compilers.java
index 4d1a5d79e..6aa7b739e 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Compilers.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Compilers.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/DeleteImmediatelyManagerType.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/DeleteImmediatelyManagerType.java
index c21151486..9c87eefea 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/DeleteImmediatelyManagerType.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/DeleteImmediatelyManagerType.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/FileHash.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/FileHash.java
index 230b5526e..78b701adc 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/FileHash.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/FileHash.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/IncOptions.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/IncOptions.java
index 9ae4f4106..a73116eca 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/IncOptions.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/IncOptions.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/IncToolOptions.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/IncToolOptions.java
index 7b7268fd1..417526fb5 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/IncToolOptions.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/IncToolOptions.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Inputs.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Inputs.java
index 00d5cacea..012bb2ad5 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Inputs.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Inputs.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/MiniOptions.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/MiniOptions.java
index b1e4716f2..fb6a21ed9 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/MiniOptions.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/MiniOptions.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/MiniSetup.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/MiniSetup.java
index 23da8e1cc..6509b3654 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/MiniSetup.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/MiniSetup.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/PreviousResult.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/PreviousResult.java
index 450a4e7e3..09099447b 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/PreviousResult.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/PreviousResult.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Setup.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Setup.java
index e50a3c00a..ced769f04 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Setup.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/Setup.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/TransactionalManagerType.java b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/TransactionalManagerType.java
index 66b14db5e..d813314dd 100644
--- a/internal/compiler-interface/src/main/contraband-java/xsbti/compile/TransactionalManagerType.java
+++ b/internal/compiler-interface/src/main/contraband-java/xsbti/compile/TransactionalManagerType.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY
diff --git a/internal/zinc-compile-core/src/main/contraband-java/xsbti/ReporterConfig.java b/internal/zinc-compile-core/src/main/contraband-java/xsbti/ReporterConfig.java
index 1c34deadd..8be6ec876 100644
--- a/internal/zinc-compile-core/src/main/contraband-java/xsbti/ReporterConfig.java
+++ b/internal/zinc-compile-core/src/main/contraband-java/xsbti/ReporterConfig.java
@@ -1,5 +1,5 @@
 /**
- * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]].
+ * This code is generated using [[https://www.scala-sbt.org/contraband]].
  */
 
 // DO NOT EDIT MANUALLY

From 8b01f72b28dc4ef8f6ec7dea5f722c95ca1438a5 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sat, 5 Oct 2024 14:47:25 -0700
Subject: [PATCH 35/54] Handle DependencyByMacroExpansion during serialization

---
 .../inc/consistent/ConsistentAnalysisFormat.scala  | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

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 b6bb03a01..bf8431158 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
@@ -344,6 +344,8 @@ class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
     wrS("inheritance.external", rs.inheritance.external)
     wrS("localInheritance.internal", rs.localInheritance.internal)
     wrS("localInheritance.external", rs.localInheritance.external)
+    wrS("macroExpansion.internal", rs.macroExpansion.internal)
+    wrS("macroExpansion.external", rs.macroExpansion.external)
     wrS("productClassNames", rs.productClassName)
   }
 
@@ -367,23 +369,25 @@ class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
     val bin = rd(mapSource, mapBinary)
     val lcn = rd(mapBinary, identity[String])
     val cn = rd(mapSource, identity[String])
-    val mri, mre, ii, ie, lii, lie, bcn = rdS()
+    val mri, mre, ii, ie, lii, lie, mei, mee, bcn = rdS()
     def deps(
         m: Relation[String, String],
         i: Relation[String, String],
-        l: Relation[String, String]
+        l: Relation[String, String],
+        me: Relation[String, String],
     ) =
       Map(
         DependencyContext.DependencyByMemberRef -> m,
         DependencyContext.DependencyByInheritance -> i,
-        DependencyContext.LocalDependencyByInheritance -> l
+        DependencyContext.LocalDependencyByInheritance -> l,
+        DependencyContext.DependencyByMacroExpansion -> me,
       )
     Relations.make(
       p,
       bin,
       lcn,
-      InternalDependencies(deps(mri, ii, lii)),
-      ExternalDependencies(deps(mre, ie, lie)),
+      InternalDependencies(deps(mri, ii, lii, mei)),
+      ExternalDependencies(deps(mre, ie, lie, mee)),
       cn,
       un,
       bcn

From 6dd9e692bdec22833245dfa9158f379b3bc95bb5 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sat, 5 Oct 2024 23:02:07 -0700
Subject: [PATCH 36/54] Serialize & deserialize extraHash

---
 .../internal/inc/consistent/ConsistentAnalysisFormat.scala    | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

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 bf8431158..73d5fd203 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
@@ -142,6 +142,7 @@ class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
       out.int(ac.apiHash())
       out.bool(ac.hasMacro)
       out.string(ac.provenance())
+      out.int(ac.extraHash())
       val nh0 = ac.nameHashes()
       val nh = if (nh0.length > 1 && sort) {
         val nh = nh0.clone()
@@ -166,6 +167,7 @@ class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
       val ah = in.int()
       val hm = in.bool()
       val p = in.string()
+      val eh = in.int()
       val nhNames = in.readStringArray()
       val nhScopes = in.readArray[UseScope]() { UseScope.values()(in.byte().toInt) }
       val nhHashes = in.readArray[Int]() { in.int() }
@@ -178,7 +180,7 @@ class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
       val comp =
         if (storeApis) Companions.of(readClassLike(in), readClassLike(in))
         else APIs.emptyCompanions
-      AnalyzedClass.of(ts, name, SafeLazyProxy.strict(comp), ah, nameHashes, hm, ah, p)
+      AnalyzedClass.of(ts, name, SafeLazyProxy.strict(comp), ah, nameHashes, hm, eh, p)
     }
   }
 

From 53d55a71d7ea3a560a53781fb7159fcfb2ec6931 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sat, 5 Oct 2024 14:47:57 -0700
Subject: [PATCH 37/54] Add test

---
 .../src/test/scala/sbt/inc/AnalysisGenerators.scala        | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

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 d338ee712..f73696eb6 100644
--- a/internal/zinc-persist/src/test/scala/sbt/inc/AnalysisGenerators.scala
+++ b/internal/zinc-persist/src/test/scala/sbt/inc/AnalysisGenerators.scala
@@ -206,18 +206,21 @@ object AnalysisGenerators {
       memberRef <- genRClassDependencies(classNames)
       inheritance <- genSubRClassDependencies(memberRef)
       localInheritance <- genSubRClassDependencies(memberRef)
+      macroExpansion <- genSubRClassDependencies(memberRef)
       internal <- InternalDependencies(
         Map(
           DependencyByMemberRef -> memberRef.internal,
           DependencyByInheritance -> inheritance.internal,
-          LocalDependencyByInheritance -> localInheritance.internal
+          LocalDependencyByInheritance -> localInheritance.internal,
+          DependencyByMacroExpansion -> macroExpansion.internal,
         )
       )
       external <- ExternalDependencies(
         Map(
           DependencyByMemberRef -> memberRef.external,
           DependencyByInheritance -> inheritance.external,
-          LocalDependencyByInheritance -> localInheritance.external
+          LocalDependencyByInheritance -> localInheritance.external,
+          DependencyByMacroExpansion -> macroExpansion.external,
         )
       )
       classes = rel(srcs, classNames)

From 63252d4b36868ac66b18c8dd52e3e26a4b236b34 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sun, 13 Oct 2024 18:03:58 -0700
Subject: [PATCH 38/54] Remove unnecessary checkout

---
 .github/workflows/ci.yml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 59ea4776a..dff02a4de 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -80,9 +80,6 @@ jobs:
       uses: actions/checkout@v4
       with:
         ref: ${{ github.event.pull_request.base.ref }}
-    - name: Setup SBT
-      uses: sbt/setup-sbt@v1
-      if: ${{ github.event_name == 'pull_request' && (matrix.jobtype >= 4 && matrix.jobtype <= 6) }}
     - name: Benchmark (Scalac) against Target Branch (4)
       if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 4 }}
       shell: bash

From 528970b73ef9096d4c7823ac2d6bb722ba03a08b Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Tue, 15 Oct 2024 00:56:09 -0700
Subject: [PATCH 39/54] Remove unused import

---
 .../src/main/java/sbt/internal/inc/zip/ZipCentralDir.java        | 1 -
 1 file changed, 1 deletion(-)

diff --git a/internal/zinc-classfile/src/main/java/sbt/internal/inc/zip/ZipCentralDir.java b/internal/zinc-classfile/src/main/java/sbt/internal/inc/zip/ZipCentralDir.java
index c0ca6d8aa..4a9790f4a 100644
--- a/internal/zinc-classfile/src/main/java/sbt/internal/inc/zip/ZipCentralDir.java
+++ b/internal/zinc-classfile/src/main/java/sbt/internal/inc/zip/ZipCentralDir.java
@@ -47,7 +47,6 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.*;
-import java.util.zip.ZipError;
 import java.util.zip.ZipException;
 
 import static java.nio.file.StandardOpenOption.READ;

From be2aa983e27a5e9a5111e6d5af427f9fd847a0a4 Mon Sep 17 00:00:00 2001
From: Scala Steward <43047562+scala-steward@users.noreply.github.com>
Date: Tue, 15 Oct 2024 23:37:03 +0200
Subject: [PATCH 40/54] Update scala-compiler, scala-library to 2.13.15 (#1446)

Co-authored-by: Seth Tisue <seth@tisue.net>
---
 .../test/scala/sbt/internal/inc/CompilingSpecification.scala  | 2 +-
 .../zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala   | 2 +-
 project/Dependencies.scala                                    | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala b/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala
index 1539b55ac..519499e28 100644
--- a/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala
+++ b/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala
@@ -35,7 +35,7 @@ trait CompilingSpecification extends AbstractBridgeProviderTestkit {
       .get("zinc.build.compilerbridge.scalaVersion")
       .getOrElse(sys.error("zinc.build.compilerbridge.scalaVersion property not found"))
   def maxErrors = 100
-  def scala213 = "2.13.14"
+  def scala213 = "2.13.15"
 
   def scalaCompiler(instance: xsbti.compile.ScalaInstance, bridgeJar: Path): AnalyzingCompiler = {
     val bridgeProvider = ZincUtil.constantBridgeProvider(instance, bridgeJar)
diff --git a/internal/zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala b/internal/zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala
index f7ac1540e..2c411579f 100644
--- a/internal/zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala
+++ b/internal/zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala
@@ -107,7 +107,7 @@ private[xsbt] class ZincBenchmark(toCompile: BenchmarkProject, zincEnabled: Bool
 private[xsbt] object ZincBenchmark {
   // This is the Scala version used to compile the benchmark project
   // do not use `scala.util.Properties.versionNumberString`.
-  val scalaVersion = "2.13.14"
+  val scalaVersion = "2.13.15"
 
   /* ************************************************************* */
   /* Utils to programmatically instantiate Compiler from sbt setup  */
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index c345bbca3..fb8323598 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -8,9 +8,9 @@ object Dependencies {
   val scala210 = "2.10.7"
   val scala211 = "2.11.12"
   val scala212 = "2.12.20"
-  val scala213 = "2.13.14"
+  val scala213 = "2.13.15"
   val scala3ForBridge = "3.3.1"
-  val scala213ForBridge = "2.13.14"
+  val scala213ForBridge = "2.13.15"
   val defaultScalaVersion = scala212
   val compilerBridgeVersions = Seq(scala212, scala210, scala211, scala213)
   val scala212_213 = Seq(defaultScalaVersion, scala213)

From c89009809eacf3a00a07d9e08a099215d7bdc6c5 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Wed, 16 Oct 2024 10:53:32 -0700
Subject: [PATCH 41/54] Backport dummy jar handling for Consistent Analysis
 Format

---
 .../main/scala/sbt/internal/inc/Analysis.scala  |  1 +
 .../consistent/ConsistentAnalysisFormat.scala   | 17 ++++++++++++++---
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/Analysis.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/Analysis.scala
index d1fa60c66..5f2813071 100644
--- a/internal/zinc-core/src/main/scala/sbt/internal/inc/Analysis.scala
+++ b/internal/zinc-core/src/main/scala/sbt/internal/inc/Analysis.scala
@@ -133,6 +133,7 @@ object Analysis {
     }
 
   lazy val dummyOutputPath: Path = Paths.get("/tmp/dummy")
+  lazy val dummyOutputJarPath: Path = Paths.get("/tmp/dummy/output.jar")
 }
 
 private class MAnalysis(
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 73d5fd203..683b5ae9c 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
@@ -28,7 +28,7 @@ import Compat._
 class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
   import ConsistentAnalysisFormat._
 
-  private[this] final val VERSION = 1100028
+  private[this] final val VERSION = 1100029
   private[this] final val readMapper = mappers.getReadMapper
   private[this] final val writeMapper = mappers.getWriteMapper
 
@@ -40,6 +40,7 @@ class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
     writeStamps(out, analysis0.stamps)
     writeAPIs(out, analysis0.apis, setup.storeApis())
     writeSourceInfos(out, analysis0.infos)
+    // we do not read or write the Compilations
     out.int(VERSION)
     out.end()
   }
@@ -51,9 +52,11 @@ class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
     val stamps = readStamps(in)
     val apis = readAPIs(in, setup.storeApis())
     val infos = readSourceInfos(in)
+    // we do not read or write the Compilations
+    val compilations = Compilations.of(Nil)
     readVersion(in)
     in.end()
-    (Analysis.Empty.copy(stamps, apis, relations, infos, Compilations.of(Nil)), setup)
+    (Analysis.Empty.copy(stamps, apis, relations, infos, compilations), setup)
   }
 
   @inline
@@ -294,6 +297,13 @@ class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
       out.byte(setup.order.ordinal().toByte)
       out.bool(setup.storeApis())
       out.writeArray("extra", setup.extra, 2) { t => out.string(t.get1); out.string(t.get2) }
+      val singleOutput = setup.output().getSingleOutputAsPath()
+      val outputPath = singleOutput match {
+        case o if o.isPresent() && o.get().getFileName().toString().endsWith(".jar") =>
+          Analysis.dummyOutputJarPath
+        case _ => Analysis.dummyOutputPath
+      }
+      out.string(outputPath.toString())
     }
   }
 
@@ -308,8 +318,9 @@ class ConsistentAnalysisFormat(val mappers: ReadWriteMappers, sort: Boolean) {
       val compileOrder = CompileOrder.values()(in.byte().toInt)
       val skipApiStoring = in.bool()
       val extra = in.readArray(2) { InterfaceUtil.t2(in.string() -> in.string()) }
+      val outputPath = in.string()
       readMapper.mapMiniSetup(MiniSetup.of(
-        CompileOutput(Analysis.dummyOutputPath),
+        CompileOutput(Paths.get(outputPath)),
         MiniOptions.of(classpathHash, scalacOptions, javacOptions),
         compilerVersion,
         compileOrder,

From a29004168c964e2d8551ac7b49332a7d63c5cb78 Mon Sep 17 00:00:00 2001
From: Li Haoyi <haoyi.sg@gmail.com>
Date: Thu, 17 Oct 2024 23:14:39 +0800
Subject: [PATCH 42/54] Revert #1284 Include mutual dependency in initial
 invalidation (#1462)

Ref https://github.com/sbt/zinc/pull/1284
Fixes https://github.com/sbt/zinc/issues/1461
Fixes https://github.com/sbt/zinc/issues/1420
Also fixes https://github.com/com-lihaoyi/mill/issues/3748 downstream

Not sure if there's a better way to fix this? Just opening this to spark discussion

The original bugs are fine, but the solution seems incorrect, and is both overly conservative (invalidating everything based on whitespace?) and not conservative enough (doesn't handle cycles with length > 2?).
---
 .../main/scala/sbt/internal/inc/IncrementalCommon.scala  | 9 +--------
 .../abstract-class-to-trait/{test => pending}            | 0
 .../source-dependencies/false-error/{test => pending}    | 0
 .../nested-type-params/{test => pending}                 | 0
 .../no-type-annotation/{test => pending}                 | 0
 5 files changed, 1 insertion(+), 8 deletions(-)
 rename zinc/src/sbt-test/source-dependencies/abstract-class-to-trait/{test => pending} (100%)
 rename zinc/src/sbt-test/source-dependencies/false-error/{test => pending} (100%)
 rename zinc/src/sbt-test/source-dependencies/nested-type-params/{test => pending} (100%)
 rename zinc/src/sbt-test/source-dependencies/no-type-annotation/{test => pending} (100%)

diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
index dfe6a869f..19cfff70e 100644
--- a/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
+++ b/internal/zinc-core/src/main/scala/sbt/internal/inc/IncrementalCommon.scala
@@ -534,14 +534,7 @@ private[inc] abstract class IncrementalCommon(
     val removedClasses = classNames(removedSrcs)
     val dependentOnRemovedClasses = removedClasses.flatMap(previous.memberRef.internal.reverse)
     val modifiedClasses = classNames(modifiedSrcs)
-    val mutualDependentOnModifiedClasses = {
-      val dependentOnModifiedClasses = modifiedClasses.flatMap(previous.memberRef.internal.reverse)
-      dependentOnModifiedClasses.filter(dependent =>
-        previous.memberRef.internal.reverse(dependent).exists(modifiedClasses)
-      )
-    }
-    val invalidatedClasses =
-      removedClasses ++ dependentOnRemovedClasses ++ modifiedClasses ++ mutualDependentOnModifiedClasses
+    val invalidatedClasses = removedClasses ++ dependentOnRemovedClasses ++ modifiedClasses
 
     val byProduct = changes.removedProducts.flatMap(previous.produced)
     val byLibraryDep = changes.libraryDeps.flatMap(previous.usesLibrary)
diff --git a/zinc/src/sbt-test/source-dependencies/abstract-class-to-trait/test b/zinc/src/sbt-test/source-dependencies/abstract-class-to-trait/pending
similarity index 100%
rename from zinc/src/sbt-test/source-dependencies/abstract-class-to-trait/test
rename to zinc/src/sbt-test/source-dependencies/abstract-class-to-trait/pending
diff --git a/zinc/src/sbt-test/source-dependencies/false-error/test b/zinc/src/sbt-test/source-dependencies/false-error/pending
similarity index 100%
rename from zinc/src/sbt-test/source-dependencies/false-error/test
rename to zinc/src/sbt-test/source-dependencies/false-error/pending
diff --git a/zinc/src/sbt-test/source-dependencies/nested-type-params/test b/zinc/src/sbt-test/source-dependencies/nested-type-params/pending
similarity index 100%
rename from zinc/src/sbt-test/source-dependencies/nested-type-params/test
rename to zinc/src/sbt-test/source-dependencies/nested-type-params/pending
diff --git a/zinc/src/sbt-test/source-dependencies/no-type-annotation/test b/zinc/src/sbt-test/source-dependencies/no-type-annotation/pending
similarity index 100%
rename from zinc/src/sbt-test/source-dependencies/no-type-annotation/test
rename to zinc/src/sbt-test/source-dependencies/no-type-annotation/pending

From 9c235435e4193a5af9eee1ae9aabd557e6c970c3 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Thu, 17 Oct 2024 22:57:57 -0700
Subject: [PATCH 43/54] Backport #1456

---
 .../ConsistentFileAnalysisStore.scala         |  34 ++-
 .../consistent/ParallelGzipOutputStream.scala | 230 +++++++++++++-----
 ...istentAnalysisFormatIntegrationSuite.scala |  20 +-
 .../ConsistentAnalysisFormatSuite.scala       |  35 +--
 ...arallelGzipOutputStreamSpecification.scala | 185 ++++++++++++++
 .../internal/inc/MixedAnalyzingCompiler.scala |   5 -
 6 files changed, 389 insertions(+), 120 deletions(-)
 create mode 100644 internal/zinc-persist/src/test/scala/sbt/inc/consistent/ParallelGzipOutputStreamSpecification.scala

diff --git a/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ConsistentFileAnalysisStore.scala b/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ConsistentFileAnalysisStore.scala
index 01d5af474..418eae932 100644
--- a/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ConsistentFileAnalysisStore.scala
+++ b/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ConsistentFileAnalysisStore.scala
@@ -12,44 +12,55 @@ package sbt.internal.inc.consistent
  * additional information regarding copyright ownership.
  */
 
-import java.io.{ File, FileInputStream, FileOutputStream }
-import java.util.Optional
 import sbt.io.{ IO, Using }
+import xsbti.compile.analysis.ReadWriteMappers
 import xsbti.compile.{ AnalysisContents, AnalysisStore => XAnalysisStore }
 
+import java.io.{ File, FileInputStream, FileOutputStream }
+import java.util.Optional
 import scala.util.control.Exception.allCatch
-import xsbti.compile.analysis.ReadWriteMappers
-
-import scala.concurrent.ExecutionContext
 
 object ConsistentFileAnalysisStore {
   def text(
       file: File,
       mappers: ReadWriteMappers,
       sort: Boolean = true,
-      ec: ExecutionContext = ExecutionContext.global,
       parallelism: Int = Runtime.getRuntime.availableProcessors()
   ): XAnalysisStore =
     new AStore(
       file,
       new ConsistentAnalysisFormat(mappers, sort),
       SerializerFactory.text,
-      ec,
       parallelism
     )
 
+  def binary(file: File): XAnalysisStore =
+    binary(
+      file,
+      mappers = ReadWriteMappers.getEmptyMappers(),
+      sort = true,
+    )
+
+  def binary(
+      file: File,
+      mappers: ReadWriteMappers
+  ): XAnalysisStore =
+    binary(
+      file,
+      mappers,
+      sort = true,
+    )
+
   def binary(
       file: File,
       mappers: ReadWriteMappers,
-      sort: Boolean = true,
-      ec: ExecutionContext = ExecutionContext.global,
+      sort: Boolean,
       parallelism: Int = Runtime.getRuntime.availableProcessors()
   ): XAnalysisStore =
     new AStore(
       file,
       new ConsistentAnalysisFormat(mappers, sort),
       SerializerFactory.binary,
-      ec,
       parallelism
     )
 
@@ -57,7 +68,6 @@ object ConsistentFileAnalysisStore {
       file: File,
       format: ConsistentAnalysisFormat,
       sf: SerializerFactory[S, D],
-      ec: ExecutionContext = ExecutionContext.global,
       parallelism: Int = Runtime.getRuntime.availableProcessors()
   ) extends XAnalysisStore {
 
@@ -68,7 +78,7 @@ object ConsistentFileAnalysisStore {
       if (!file.getParentFile.exists()) file.getParentFile.mkdirs()
       val fout = new FileOutputStream(tmpAnalysisFile)
       try {
-        val gout = new ParallelGzipOutputStream(fout, ec, parallelism)
+        val gout = new ParallelGzipOutputStream(fout, parallelism)
         val ser = sf.serializerFor(gout)
         format.write(ser, analysis, setup)
         gout.close()
diff --git a/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ParallelGzipOutputStream.scala b/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ParallelGzipOutputStream.scala
index bdce23d10..0419abf82 100644
--- a/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ParallelGzipOutputStream.scala
+++ b/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ParallelGzipOutputStream.scala
@@ -1,123 +1,219 @@
+// Original code by Stefan Zeiger (see https://github.com/szeiger/zinc/blob/1d296b2fbeaae1cf14e4c00db0bbc2203f9783a4/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/NewParallelGzipOutputStream.scala)
+// Modified by Rex Kerr to use Java threads directly rather than Future
 package sbt.internal.inc.consistent
-
 import java.io.{ ByteArrayOutputStream, FilterOutputStream, OutputStream }
 import java.util.zip.{ CRC32, Deflater, DeflaterOutputStream }
 
+import java.util.concurrent.{ SynchronousQueue, ArrayBlockingQueue, LinkedTransferQueue }
+
 import scala.annotation.tailrec
-import scala.concurrent.duration.Duration
-import scala.concurrent.{ Await, ExecutionContext, Future }
-import scala.collection.mutable
 
 /**
  * Parallel gzip compression. Algorithm based on https://github.com/shevek/parallelgzip
  * with additional optimization and simplification. This is essentially a block-buffered
  * stream but instead of writing a full block to the underlying output, it is passed to a
- * thread pool for compression and the Futures of compressed blocks are collected when
- * flushing.
+ * thread pool for compression and the compressed blocks are collected when flushing.
  */
 object ParallelGzipOutputStream {
   private val blockSize = 64 * 1024
   private val compression = Deflater.DEFAULT_COMPRESSION
 
-  private class BufOut(size: Int) extends ByteArrayOutputStream(size) {
-    def writeTo(buf: Array[Byte]): Unit = System.arraycopy(this.buf, 0, buf, 0, count)
+  // Holds an input buffer to load data and an output buffer to write
+  // the compressed data into.  Compressing clears the input buffer.
+  // Compressed data can be retrieved with `output.writeTo(OutputStream)`.
+  private final class Block(var index: Int) {
+    val input = new Array[Byte](blockSize)
+    var inputN = 0
+    val output = new ByteArrayOutputStream(blockSize + (blockSize >> 3))
+    val deflater = new Deflater(compression, true)
+    val dos = new DeflaterOutputStream(output, deflater, true)
+
+    def compress(): Unit = {
+      deflater.reset()
+      output.reset()
+      dos.write(input, 0, inputN)
+      dos.flush()
+      inputN = 0
+    }
   }
 
-  private class Worker {
-    private[this] val defl = new Deflater(compression, true)
-    private[this] val buf = new BufOut(blockSize + (blockSize >> 3))
-    private[this] val out = new DeflaterOutputStream(buf, defl, true)
-    def compress(b: Block): Unit = {
-      defl.reset()
-      buf.reset()
-      out.write(b.data, 0, b.length)
-      out.flush()
-      b.length = buf.size
-      if (b.length > b.data.length) b.data = new Array[Byte](b.length)
-      buf.writeTo(b.data)
+  // Waits for data to appear in a SynchronousQueue.
+  // When it does, compress it and pass it along.  Also put self in a pool of workers awaiting more work.
+  // If data does not appear but a `None` appears instead, cease running (and do not add self to work queue).
+  private final class Worker(
+      val workers: ArrayBlockingQueue[Worker],
+      val compressed: LinkedTransferQueue[Either[Int, Block]]
+  ) extends Thread {
+    val work = new SynchronousQueue[Option[Block]]
+
+    @tailrec
+    def loop(): Unit = {
+      work.take() match {
+        case Some(block) =>
+          block.compress()
+          compressed.put(Right(block))
+          workers.put(this)
+          loop()
+        case _ =>
+      }
     }
-  }
 
-  private val localWorker = new ThreadLocal[Worker] {
-    override def initialValue = new Worker
+    override def run(): Unit = {
+      loop()
+    }
   }
 
-  private class Block {
-    var data = new Array[Byte](blockSize + (blockSize >> 3))
-    var length = 0
+  // Waits for data to appear in a LinkedTransferQueue.
+  // When it does, place it into a sorted tree and, if the data is in order, write it out.
+  // Once the data has been written, place it into a cache for completed buffers.
+  // If data does not appear but an integer appears instead, set a mark to quit once
+  // that many blocks have been written.
+  private final class Scribe(out: OutputStream, val completed: LinkedTransferQueue[Block])
+      extends Thread {
+    val work = new LinkedTransferQueue[Either[Int, Block]]
+    private val tree = new collection.mutable.TreeMap[Int, Block]
+    private var next = 0
+    private var stopAt = Int.MaxValue
+
+    @tailrec
+    def loop(): Unit = {
+      work.take() match {
+        case Right(block) =>
+          tree(block.index) = block
+        case Left(limit) =>
+          stopAt = limit
+      }
+      while (tree.nonEmpty && tree.head._2.index == next) {
+        val block = tree.remove(next).get
+        block.output.writeTo(out)
+        completed.put(block)
+        next += 1
+      }
+      if (next < stopAt) loop()
+    }
+
+    override def run(): Unit = {
+      loop()
+    }
   }
 
   private val header = Array[Byte](0x1f.toByte, 0x8b.toByte, Deflater.DEFLATED, 0, 0, 0, 0, 0, 0, 0)
 }
 
-final class ParallelGzipOutputStream(out: OutputStream, ec: ExecutionContext, parallelism: Int)
+/**
+ * Implements a parallel chunked compression algorithm (using minimum of two extra threads).
+ * Note that the methods in this class are not themselves threadsafe; this class
+ * has "interior concurrency" (c.f. interior mutability).  In particular, writing
+ * concurrent with or after a close operation is not defined.
+ */
+final class ParallelGzipOutputStream(out: OutputStream, parallelism: Int)
     extends FilterOutputStream(out) {
   import ParallelGzipOutputStream._
 
-  private final val crc = new CRC32
-  private final val queueLimit = parallelism * 3
-  // preferred on 2.13: new mutable.ArrayDeque[Future[Block]](queueLimit)
-  private final val pending = mutable.Queue.empty[Future[Block]]
-  private var current: Block = new Block
-  private var free: Block = _
-  private var total = 0L
+  private val crc = new CRC32
+  private var totalBlocks = 0
+  private var totalCount = 0L
+
+  private val bufferLimit = parallelism * 3
+  private var bufferCount = 1
+  private var current = new Block(0)
+
+  private val workerCount = math.max(1, parallelism - 1)
+  private val workers = new ArrayBlockingQueue[Worker](workerCount)
+  private val buffers = new LinkedTransferQueue[Block]()
 
   out.write(header)
+  private val scribe = new Scribe(out, buffers)
+  scribe.start()
+
+  while (workers.remainingCapacity() > 0) {
+    val w = new Worker(workers, scribe.work)
+    workers.put(w)
+    w.start()
+  }
 
   override def write(b: Int): Unit = write(Array[Byte]((b & 0xff).toByte))
   override def write(b: Array[Byte]): Unit = write(b, 0, b.length)
 
-  @tailrec override def write(b: Array[Byte], off: Int, len: Int): Unit = {
-    val copy = math.min(len, blockSize - current.length)
+  @tailrec
+  override def write(b: Array[Byte], off: Int, len: Int): Unit = {
+    val copy = math.min(len, blockSize - current.inputN)
     crc.update(b, off, copy)
-    total += copy
-    System.arraycopy(b, off, current.data, current.length, copy)
-    current.length += copy
+    totalCount += copy
+    System.arraycopy(b, off, current.input, current.inputN, copy)
+    current.inputN += copy
     if (copy < len) {
       submit()
       write(b, off + copy, len - copy)
     }
   }
 
-  private[this] def submit(): Unit = {
-    flushUntil(queueLimit - 1)
-    val finalBlock = current
-    pending += Future { localWorker.get.compress(finalBlock); finalBlock }(ec)
-    if (free != null) {
-      current = free
-      free = null
-    } else current = new Block()
+  private def submit(): Unit = {
+    val w = workers.take()
+    w.work.put(Some(current))
+    totalBlocks += 1
+    current = buffers.poll()
+    if (current eq null) {
+      if (bufferCount < bufferLimit) {
+        current = new Block(totalBlocks)
+        bufferCount += 1
+      } else {
+        current = buffers.take()
+      }
+    }
+    current.index = totalBlocks
   }
 
-  private def flushUntil(remaining: Int): Unit =
-    while (pending.length > remaining || pending.headOption.exists(_.isCompleted)) {
-      val b = Await.result(pending.dequeue(), Duration.Inf)
-      out.write(b.data, 0, b.length)
-      b.length = 0
-      free = b
+  private def flushImpl(shutdown: Boolean): Unit = {
+    val fetched = new Array[Block](bufferCount - 1)
+    var n = 0
+    // If we have all the buffers, all pending work is done.
+    while (n < fetched.length) {
+      fetched(n) = buffers.take()
+      n += 1
     }
+    if (shutdown) {
+      // Send stop signal to workers and scribe
+      n = workerCount
+      while (n > 0) {
+        workers.take().work.put(None)
+        n -= 1
+      }
+      scribe.work.put(Left(totalBlocks))
+    } else {
+      // Put all the buffers back so we can keep accepting data.
+      n = 0
+      while (n < fetched.length) {
+        buffers.put(fetched(n))
+        n += 1
+      }
+    }
+  }
 
+  /**
+   * Blocks until all pending data is written.  Note that this is a poor use of a parallel data writing class.
+   * It is preferable to write all data and then close the stream.  Note also that a flushed stream will not
+   * have the trailing CRC checksum and therefore will not be a valid compressed file, so there is little point
+   * flushing early.
+   */
   override def flush(): Unit = {
-    if (current.length > 0) submit()
-    flushUntil(0)
+    if (current.inputN > 0) submit()
+    flushImpl(false)
     super.flush()
   }
 
   override def close(): Unit = {
-    flush()
+    if (current.inputN > 0) submit()
+    flushImpl(true)
+
     val buf = new Array[Byte](10)
-    def int(i: Int, off: Int): Unit = {
-      buf(off) = ((i & 0xff).toByte)
-      buf(off + 1) = (((i >>> 8) & 0xff).toByte)
-      buf(off + 2) = (((i >>> 16) & 0xff).toByte)
-      buf(off + 3) = (((i >>> 24) & 0xff).toByte)
-    }
-    buf(0) = 3
-    int(crc.getValue.toInt, 2)
-    int((total & 0xffffffffL).toInt, 6)
+    val bb = java.nio.ByteBuffer.wrap(buf)
+    bb.order(java.nio.ByteOrder.LITTLE_ENDIAN)
+    bb.putShort(3)
+    bb.putInt(crc.getValue.toInt)
+    bb.putInt((totalCount & 0xffffffffL).toInt)
     out.write(buf)
+
     out.close()
-    total = Integer.MIN_VALUE
-    free = null
   }
 }
diff --git a/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ConsistentAnalysisFormatIntegrationSuite.scala b/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ConsistentAnalysisFormatIntegrationSuite.scala
index 1e26809df..4317db355 100644
--- a/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ConsistentAnalysisFormatIntegrationSuite.scala
+++ b/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ConsistentAnalysisFormatIntegrationSuite.scala
@@ -1,11 +1,11 @@
 package sbt.inc.consistent
 
-import java.io.File
+import java.io.{ File, FileInputStream }
 import java.util.Arrays
 import org.scalatest.funsuite.AnyFunSuite
 import sbt.internal.inc.consistent.ConsistentFileAnalysisStore
 import sbt.internal.inc.{ Analysis, FileAnalysisStore }
-import sbt.io.IO
+import sbt.io.{ IO, Using }
 import xsbti.compile.{ AnalysisContents, AnalysisStore }
 import xsbti.compile.analysis.ReadWriteMappers
 
@@ -47,6 +47,22 @@ class ConsistentAnalysisFormatIntegrationSuite extends AnyFunSuite {
     }
   }
 
+  test("compression ratio") {
+    for (d <- data) {
+      assert(d.exists())
+      val api = read(FileAnalysisStore.binary(d))
+      val file = write("cbin1.zip", api)
+      val uncompressedSize = Using.gzipInputStream(new FileInputStream(file)) { in =>
+        val content = IO.readBytes(in)
+        content.length
+      }
+      val compressedSize = d.length()
+      val compressionRatio = compressedSize.toDouble / uncompressedSize.toDouble
+      assert(compressionRatio < 0.85)
+      // compression rate for each data: 0.8185090254676337, 0.7247774786370688, 0.8346021341469837
+    }
+  }
+
   def read(store: AnalysisStore): AnalysisContents = {
     val api = store.unsafeGet()
     // Force loading of companion file and check that the companion data is present:
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..00a604cb0 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
@@ -1,22 +1,9 @@
 package sbt.inc.consistent
 
-import java.io.{
-  BufferedInputStream,
-  BufferedReader,
-  ByteArrayInputStream,
-  ByteArrayOutputStream,
-  StringReader,
-  StringWriter
-}
-import java.util.zip.GZIPInputStream
-import java.util.Arrays
-import scala.util.Random
 import org.scalatest.funsuite.AnyFunSuite
 import sbt.internal.inc.consistent._
-import sbt.io.IO
 import Compat._
-
-import scala.concurrent.ExecutionContext
+import java.io._
 
 class ConsistentAnalysisFormatSuite extends AnyFunSuite {
 
@@ -89,24 +76,4 @@ class ConsistentAnalysisFormatSuite extends AnyFunSuite {
     writeTo(SerializerFactory.binary.serializerFor(out))
     readFrom(SerializerFactory.binary.deserializerFor(new ByteArrayInputStream(out.toByteArray)))
   }
-
-  test("ParallelGzip") {
-    val bs = 64 * 1024
-    val rnd = new Random(0L)
-    for {
-      threads <- Seq(1, 8)
-      size <- Seq(0, bs - 1, bs, bs + 1, bs * 8 - 1, bs * 8, bs * 8 + 1)
-    } {
-      val a = new Array[Byte](size)
-      rnd.nextBytes(a)
-      val bout = new ByteArrayOutputStream()
-      val gout = new ParallelGzipOutputStream(bout, ExecutionContext.global, parallelism = threads)
-      gout.write(a)
-      gout.close()
-      val gin =
-        new BufferedInputStream(new GZIPInputStream(new ByteArrayInputStream(bout.toByteArray)))
-      val a2 = IO.readBytes(gin)
-      assert(Arrays.equals(a, a2), s"threads = $threads, size = $size")
-    }
-  }
 }
diff --git a/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ParallelGzipOutputStreamSpecification.scala b/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ParallelGzipOutputStreamSpecification.scala
new file mode 100644
index 000000000..b2bbe8913
--- /dev/null
+++ b/internal/zinc-persist/src/test/scala/sbt/inc/consistent/ParallelGzipOutputStreamSpecification.scala
@@ -0,0 +1,185 @@
+package sbt.inc.consistent
+
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+
+import java.io.{ ByteArrayInputStream, ByteArrayOutputStream }
+import java.nio.file.{ Files, Paths, StandardOpenOption }
+import sbt.internal.inc.consistent.ParallelGzipOutputStream
+import sbt.io.IO
+import sbt.io.Using
+
+import java.util.Arrays
+import scala.util.Random
+import scala.concurrent.{ Await, Future }
+import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.duration._
+
+class ParallelGzipOutputStreamSpecification extends AnyFlatSpec with Matchers {
+  val defaultSize: Int = 64 * 1024
+  val sizes: Seq[Int] = Seq(
+    0,
+    1,
+    3,
+    32,
+    127,
+    1025,
+    defaultSize - 1,
+    defaultSize,
+    defaultSize + 1,
+    defaultSize * 8 - 1,
+    defaultSize * 8,
+    defaultSize * 8 + 1
+  )
+  val numberOfGzipStreams: Seq[Int] = Seq(1, 2, 4, 8, 15)
+  val parallelisms: Seq[Int] = 1 to 17
+
+  def decompress(data: Array[Byte]): Array[Byte] = {
+    Using.gzipInputStream(new ByteArrayInputStream(data))(IO.readBytes)
+  }
+
+  def compress(data: Array[Byte], parallelism: Int, testSetup: String): Array[Byte] = {
+    val bout = new ByteArrayOutputStream()
+    val gout = new ParallelGzipOutputStream(bout, parallelism)
+    try {
+      gout.write(data)
+    } catch {
+      case e: Exception =>
+        handleFailure(Array[Byte](), data, testSetup, "Compression Failed", Some(e))
+    } finally {
+      gout.close()
+    }
+    bout.toByteArray
+  }
+
+  def writeToFile(data: Array[Byte], fileName: String): Unit = {
+    val outputDir = Paths.get("../../../test-gzip-output")
+    if (!Files.exists(outputDir)) {
+      Files.createDirectories(outputDir)
+    }
+    val path = outputDir.resolve(fileName)
+    Files.write(path, data, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)
+    ()
+  }
+
+  // Need this in windows to produce valid windows filename
+  def sanitizedFilename(fileName: String): String = {
+    fileName.replaceAll("[^a-zA-Z0-9-_.]", "_")
+  }
+
+  def handleFailure(
+      compressed: Array[Byte],
+      data: Array[Byte],
+      testSetup: String,
+      errorCause: String,
+      errorOpt: Option[Exception] = None,
+  ): Unit = {
+    val compressedFileName = sanitizedFilename(s"compressed_$testSetup.gz")
+    val dataFileName = sanitizedFilename(s"data_$testSetup.bin")
+    writeToFile(compressed, compressedFileName)
+    writeToFile(data, dataFileName)
+
+    errorOpt match {
+      case Some(error) =>
+        fail(s"$errorCause. See $compressedFileName and $dataFileName", error)
+      case _ => fail(s"$errorCause. See $compressedFileName and $dataFileName")
+    }
+
+  }
+
+  def verifyRoundTrip(data: Array[Byte], parallelism: Int, testSetup: String): Unit = {
+    val compressed = compress(data, parallelism, testSetup)
+    try {
+      val decompressed = decompress(compressed)
+      if (!Arrays.equals(data, decompressed)) {
+        handleFailure(compressed, data, testSetup, "Compression and decompression mismatch.")
+      }
+    } catch {
+      case e: Exception =>
+        handleFailure(
+          compressed,
+          data,
+          testSetup,
+          "Decompression failed",
+          Some(e),
+        )
+    }
+  }
+
+  def randomArray(size: Int): Array[Byte] = {
+    val rnd = new Random(0L)
+    val data = new Array[Byte](size)
+    rnd.nextBytes(data)
+    data
+  }
+
+  it should "compress and decompress data correctly" in {
+    for {
+      parallelism <- parallelisms
+      size <- sizes
+    } {
+      val data = randomArray(size)
+      verifyRoundTrip(data, parallelism, s"parallelism = $parallelism, size = $size")
+    }
+  }
+
+  it should "handle highly redundant data correctly" in {
+    for {
+      parallelism <- parallelisms
+      size <- sizes
+    } {
+      val data = Array.fill(size)(0.toByte)
+      verifyRoundTrip(data, parallelism, s"parallelism = $parallelism, size = $size, redundant")
+    }
+  }
+
+  it should "handle large data sizes" in {
+    val largeData = randomArray(64 * 1024 * 1024) // 64 MB
+    for (parallelism <- parallelisms) {
+      verifyRoundTrip(largeData, parallelism, s"parallelism = $parallelism, large data size")
+    }
+  }
+
+  it should "handle very large parallelism" in {
+    val data = randomArray(defaultSize * 16)
+    val maxNumberOfThreads = 200
+    verifyRoundTrip(data, maxNumberOfThreads, s"parallelism = $maxNumberOfThreads, large data")
+  }
+
+  it should "handle multiple ParallelGzipOutputStream concurrently" in {
+    for {
+      numberOfGzipStream <- numberOfGzipStreams
+      parallelism <- parallelisms
+      size <- sizes
+    } {
+      val verifications = Future.traverse(1 to numberOfGzipStream)(numberOfGzipStream =>
+        Future {
+          val data = randomArray(size)
+          verifyRoundTrip(
+            data,
+            parallelism,
+            s"numberOfStreams: $numberOfGzipStream, parallelism = $parallelism, size = $size, multiple"
+          )
+        }
+      )
+      Await.result(verifications, 60.seconds)
+    }
+  }
+
+  it should "handle multiple ParallelGzipOutputStream with varying config concurrently" in {
+    val verifications = Future.traverse(for {
+      parallelism <- parallelisms.take(10)
+      size <- sizes
+    } yield (parallelism, size)) { case (parallelism, size) =>
+      Future {
+        val data = randomArray(size)
+        verifyRoundTrip(
+          data,
+          parallelism,
+          s"parallelism = $parallelism, size = $size, varying"
+        )
+      }
+    }
+    Await.result(verifications, 60.seconds)
+  }
+}
diff --git a/zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala b/zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala
index a9ab5ec62..457cbb389 100644
--- a/zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala
+++ b/zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala
@@ -37,7 +37,6 @@ import sbt.internal.inc.VirtualFileUtil.toAbsolute
 import sbt.internal.inc.caching.ClasspathCache
 import sbt.internal.inc.javac.AnalyzingJavaCompiler
 import sbt.internal.util.ConsoleAppender
-import scala.concurrent.ExecutionContext
 
 /** An instance of an analyzing compiler that can run both javac + scalac. */
 final class MixedAnalyzingCompiler(
@@ -507,7 +506,6 @@ object MixedAnalyzingCompiler {
       useConsistent = false,
       mappers = ReadWriteMappers.getEmptyMappers(),
       sort = true,
-      ec = ExecutionContext.global,
       parallelism = Runtime.getRuntime.availableProcessors(),
     )
 
@@ -517,7 +515,6 @@ object MixedAnalyzingCompiler {
       useConsistent: Boolean,
       mappers: ReadWriteMappers,
       sort: Boolean,
-      ec: ExecutionContext,
       parallelism: Int,
   ): AnalysisStore = {
     val fileStore = (useTextAnalysis, useConsistent) match {
@@ -528,7 +525,6 @@ object MixedAnalyzingCompiler {
           file = analysisFile.toFile,
           mappers = mappers,
           sort = sort,
-          ec = ec,
           parallelism = parallelism,
         )
       case (true, false) =>
@@ -538,7 +534,6 @@ object MixedAnalyzingCompiler {
           file = analysisFile.toFile,
           mappers = mappers,
           sort = sort,
-          ec = ec,
           parallelism = parallelism,
         )
     }

From 5a41ce63f6935533e9330a10ae506a259783feb3 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 44/54] Clean compile warnings

---
 .../src/test/scala/xsbt/ZincBenchmark.scala   |  2 +-
 .../sbt/internal/inc/AnalyzingCompiler.scala  |  6 +++---
 .../sbt/internal/inc/FilteredReporter.scala   |  7 +++++--
 .../sbt/internal/inc/javac/ForkedJava.scala   | 20 +++++++++++++++++--
 .../sbt/internal/inc/javac/LocalJava.scala    |  2 --
 .../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  |  4 ++--
 .../scala/sbt/internal/inc/SourceInfo.scala   | 15 ++++++++------
 .../main/scala/sbt/internal/inc/Stamp.scala   | 18 +++++++----------
 .../scala/sbt/internal/inc/UsedName.scala     |  2 +-
 .../consistent/ConsistentAnalysisFormat.scala |  4 ++--
 .../inc/text/TextAnalysisFormat.scala         | 18 ++++++++++++++---
 .../scala/sbt/inc/AnalysisGenerators.scala    |  2 +-
 .../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 +++---
 20 files changed, 88 insertions(+), 59 deletions(-)

diff --git a/internal/zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala b/internal/zinc-benchmarks/src/test/scala/xsbt/ZincBenchmark.scala
index 2c411579f..72e6dfeb3 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-compile-core/src/main/scala/sbt/internal/inc/AnalyzingCompiler.scala b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/AnalyzingCompiler.scala
index 1f2d57fd6..b9f0cc9b0 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..6a6fb039d 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
@@ -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 a4fee662a..b305a053d 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.collection.JavaConverters._
         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-core/src/main/scala/sbt/internal/inc/Changes.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/Changes.scala
index e6df712f1..3a895f887 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 72ec426a9..7a3fa13c1 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 be849cdf5..b3b09c3bf 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
@@ -49,7 +49,7 @@ object Locate {
       }
   }
   def find[S](name: String, gets: Stream[String => Either[Boolean, S]]): Either[Boolean, S] =
-    find[S](name, gets.toIterator)
+    find[S](name, gets.iterator)
 
   /**
    * Returns a function that searches the provided class path for
@@ -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 bf084b09b..b274f4b08 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
@@ -38,14 +38,17 @@ object SourceInfos {
   ): SourceInfo =
     new UnderlyingSourceInfo(reported, unreported, mainClasses)
 
-  def merge(infos: Traversable[SourceInfos]): SourceInfos =
+  def merge(infos: Iterable[SourceInfos]): SourceInfos =
     infos.foldLeft(SourceInfos.empty)(_ ++ _)
 
   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.collection.JavaConverters._
+    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 58d14906b..4b3b2205d 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.collection.JavaConverters._
 import scala.util.matching.Regex
 
 /**
@@ -240,8 +241,7 @@ object Stamper {
       cache: collection.concurrent.Map[VirtualFileRef, (Long, XStamp)],
       converter: FileConverter,
       getStamp: VirtualFileRef => XStamp
-  ): VirtualFileRef => XStamp = { key: VirtualFileRef =>
-    import scala.collection.JavaConverters._
+  ): VirtualFileRef => XStamp = { (key: VirtualFileRef) =>
     val p = converter.toPath(key)
     val ts =
       try IO.getModifiedTimeOrZero(p.toFile)
@@ -311,7 +311,7 @@ object Stamps {
   ): Stamps =
     new MStamps(products, sources, libraries)
 
-  def merge(stamps: Traversable[Stamps]): Stamps = stamps.foldLeft(Stamps.empty)(_ ++ _)
+  def merge(stamps: Iterable[Stamps]): Stamps = stamps.foldLeft(Stamps.empty)(_ ++ _)
 }
 
 private class MStamps(
@@ -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 684e1b714..01e9cf0b8 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/sbt/internal/inc/consistent/ConsistentAnalysisFormat.scala b/internal/zinc-persist/src/main/scala/sbt/internal/inc/consistent/ConsistentAnalysisFormat.scala
index 683b5ae9c..2a2cc46fc 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
@@ -273,8 +273,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 = in.readArray()(readProblem()).toIndexedSeq
+      val unreportedProblems = in.readArray()(readProblem()).toIndexedSeq
       val info = SourceInfos.makeInfo(reportedProblems, unreportedProblems, mainClasses)
       (file, info)
     })
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 4f055b5f2..22a1a9e1d 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
@@ -484,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,
+        mappedClasspathHash.toIndexedSeq,
+        fileHashToString
+      )
+      writeSeq(out)(
+        Headers.compileOptions,
+        setup.options.scalacOptions.toIndexedSeq,
+        soptionsMapper.write
+      )
+      writeSeq(out)(
+        Headers.javacOptions,
+        setup.options.javacOptions.toIndexedSeq,
+        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 f73696eb6..9ce08dfed 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-scripted/src/test/scala/sbt/internal/inc/IncHandler.scala b/internal/zinc-scripted/src/test/scala/sbt/internal/inc/IncHandler.scala
index 4d9cba150..d282f4338 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
@@ -515,7 +515,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 b954db27c..bef4b8983 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 457cbb389..b08b699d1 100644
--- a/zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala
+++ b/zinc/src/main/scala/sbt/internal/inc/MixedAnalyzingCompiler.scala
@@ -78,7 +78,7 @@ final class MixedAnalyzingCompiler(
               javaSrcs,
               Seq(toVirtualFile(outputJar)),
               config.converter,
-              joptions,
+              joptions.toIndexedSeq,
               CompileOutput(outputDir),
               outputJarOpt,
               callback,
@@ -94,7 +94,7 @@ final class MixedAnalyzingCompiler(
                 javaSrcs,
                 extraClasspath map toVirtualFile,
                 config.converter,
-                joptions,
+                joptions.toIndexedSeq,
                 output,
                 outputJarOpt,
                 callback,
@@ -143,7 +143,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 =
@@ -240,7 +241,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)
     }
   }
 
@@ -415,7 +417,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 6d0f3630f..2ae4c34cd 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 d6704c547..58107ab9e 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,

From ded724840ec3e1a2bb00d8b78333236ac26581e8 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Fri, 18 Oct 2024 12:28:03 -0700
Subject: [PATCH 45/54] Add more missing .toIndexedSeq calls

---
 .../scala/sbt/internal/inc/ClassToAPI.scala   |  6 ++---
 .../src/main/scala/xsbt/api/Discovery.scala   | 14 ++++++-----
 .../src/main/scala/xsbt/api/ShowAPI.scala     | 24 +++++++++++--------
 .../sbt/internal/inc/CompilerArguments.scala  |  3 ++-
 4 files changed, 27 insertions(+), 20 deletions(-)

diff --git a/internal/zinc-apiinfo/src/main/scala/sbt/internal/inc/ClassToAPI.scala b/internal/zinc-apiinfo/src/main/scala/sbt/internal/inc/ClassToAPI.scala
index 2a91f0cf8..693a0523f 100644
--- a/internal/zinc-apiinfo/src/main/scala/sbt/internal/inc/ClassToAPI.scala
+++ b/internal/zinc-apiinfo/src/main/scala/sbt/internal/inc/ClassToAPI.scala
@@ -507,11 +507,11 @@ object ClassToAPI {
    * We need this logic to trigger recompilation due to changes to pattern exhaustivity checking results.
    */
   private def childrenOfSealedClass(c: Class[?]): Seq[api.Type] =
-    if (!c.isEnum) emptyTypeArray
+    if (!c.isEnum) emptyTypeArray.toIndexedSeq
     else {
       // Calling getCanonicalName() on classes from enum constants yields same string as enumClazz.getCanonicalName
       // Moreover old behaviour create new instance of enum - what may fail (e.g. in static block )
-      Array(reference(c))
+      Seq(reference(c))
     }
 
   // full information not available from reflection
@@ -556,7 +556,7 @@ object ClassToAPI {
     }
 
   def pathFromString(s: String): api.Path =
-    pathFromStrings(s.split("\\."))
+    pathFromStrings(s.split("\\.").toIndexedSeq)
   def pathFromStrings(ss: Seq[String]): api.Path =
     api.Path.of((ss.map(api.Id.of(_)) :+ ThisRef).toArray)
   def packageName(c: Class[?]) = packageAndName(c)._1
diff --git a/internal/zinc-apiinfo/src/main/scala/xsbt/api/Discovery.scala b/internal/zinc-apiinfo/src/main/scala/xsbt/api/Discovery.scala
index 608a1c8da..9801e89e3 100644
--- a/internal/zinc-apiinfo/src/main/scala/xsbt/api/Discovery.scala
+++ b/internal/zinc-apiinfo/src/main/scala/xsbt/api/Discovery.scala
@@ -34,13 +34,13 @@ class Discovery(baseClasses: Set[String], annotations: Set[String]) {
       case _ => Discovered.empty
     }
   def discover(c: ClassLike): Discovered = {
-    val onClass = Discovery.findAnnotations(c.annotations, annotations)
+    val onClass = Discovery.findAnnotations(c.annotations.toIndexedSeq, annotations)
     val onDefs = Discovery.defAnnotations(c.structure, annotations) ++ c.savedAnnotations.filter(
       annotations
     )
     val module = isModule(c)
     new Discovered(
-      bases(c.name, c.structure.parents),
+      bases(c.name, c.structure.parents.toIndexedSeq),
       onClass ++ onDefs,
       module && hasMainMethod(c),
       module
@@ -66,7 +66,7 @@ object Discovery {
       simpleName(a.base).filter(pred)
     }.toSet
   def defAnnotations(s: Structure, pred: String => Boolean): Set[String] =
-    defAnnotations(s.declared, pred) ++ defAnnotations(s.inherited, pred)
+    defAnnotations(s.declared.toIndexedSeq, pred) ++ defAnnotations(s.inherited, pred)
   def defAnnotations(defs: Seq[Definition], pred: String => Boolean): Set[String] =
     findAnnotations(
       defs.flatMap {
@@ -82,19 +82,21 @@ object Discovery {
   def isModule(c: ClassLike) = c.definitionType == DefinitionType.Module
 
   def hasMainMethod(c: ClassLike): Boolean =
-    hasMainMethod(c.structure.declared) || hasMainMethod(c.structure.inherited)
+    hasMainMethod(c.structure.declared.toIndexedSeq) || hasMainMethod(
+      c.structure.inherited.toIndexedSeq
+    )
   def hasMainMethod(defs: Seq[Definition]): Boolean =
     defs.exists(isMainMethod)
   def isMainMethod(d: Definition): Boolean =
     d match {
       case d: Def =>
         d.name == "main" && isPublic(d) && isConcrete(d) && isUnit(d.returnType) && isStringArray(
-          d.valueParameters
+          d.valueParameters.toIndexedSeq
         )
       case _ => false
     }
   def isStringArray(vp: IndexedSeq[ParameterList]): Boolean =
-    vp.length == 1 && isStringArray(vp(0).parameters)
+    vp.length == 1 && isStringArray(vp(0).parameters.toIndexedSeq)
   def isStringArray(params: Seq[MethodParameter]): Boolean =
     params.length == 1 && isStringArray(params(0))
   def isStringArray(p: MethodParameter): Boolean =
diff --git a/internal/zinc-apiinfo/src/main/scala/xsbt/api/ShowAPI.scala b/internal/zinc-apiinfo/src/main/scala/xsbt/api/ShowAPI.scala
index 3c706b8b6..14ae4f456 100644
--- a/internal/zinc-apiinfo/src/main/scala/xsbt/api/ShowAPI.scala
+++ b/internal/zinc-apiinfo/src/main/scala/xsbt/api/ShowAPI.scala
@@ -41,12 +41,14 @@ object ShowAPI {
     case v: Val => showMonoDef(v, "val") + ": " + showType(v.tpe)
     case v: Var => showMonoDef(v, "var") + ": " + showType(v.tpe)
     case d: Def =>
-      showPolyDef(d, "def") + showValueParams(d.valueParameters) + ": " + showType(d.returnType)
+      showPolyDef(d, "def") + showValueParams(d.valueParameters.toIndexedSeq) + ": " + showType(
+        d.returnType
+      )
     case ta: TypeAlias       => showPolyDef(ta, "type") + " = " + showType(ta.tpe)
     case td: TypeDeclaration => showPolyDef(td, "type") + showBounds(td.lowerBound, td.upperBound)
     case cl: ClassLike =>
       showMonoDef(d, showDefinitionType(cl.definitionType)) +
-        showTypeParameters(cl.typeParameters) + " extends " + showTemplate(cl)
+        showTypeParameters(cl.typeParameters.toIndexedSeq) + " extends " + showTemplate(cl)
     case cl: ClassLikeDef => showPolyDef(cl, showDefinitionType(cl.definitionType))
   }
 
@@ -59,9 +61,11 @@ object ShowAPI {
 
       cl.structure.parents.map(showNestedType).mkString("", " with ", " {") + showSelf +
         lines(
-          truncateDecls(cl.structure.inherited).map(d => "^inherited^ " + showNestedDefinition(d))
+          truncateDecls(cl.structure.inherited).toIndexedSeq.map(d =>
+            "^inherited^ " + showNestedDefinition(d)
+          )
         ) +
-        lines(truncateDecls(cl.structure.declared).map(showNestedDefinition)) +
+        lines(truncateDecls(cl.structure.declared).toIndexedSeq.map(showNestedDefinition)) +
         "}"
     }
 
@@ -73,7 +77,7 @@ object ShowAPI {
     case p: Parameterized =>
       showType(p.baseType) + p.typeArguments.map(showType).mkString("[", ", ", "]")
     case c: Constant  => showType(c.baseType) + "(" + c.value + ")"
-    case a: Annotated => showAnnotations(a.annotations) + " " + showType(a.baseType)
+    case a: Annotated => showAnnotations(a.annotations.toIndexedSeq) + " " + showType(a.baseType)
     case s: Structure =>
       s.parents.map(showType).mkString(" with ") + (
         if (nesting <= 0) "{ <nesting level reached> }"
@@ -90,7 +94,7 @@ object ShowAPI {
     case p: Polymorphic =>
       showType(p.baseType) + (
         if (nesting <= 0) " [ <nesting level reached> ]"
-        else showNestedTypeParameters(p.parameters)
+        else showNestedTypeParameters(p.parameters.toIndexedSeq)
       )
   }
 
@@ -103,22 +107,22 @@ object ShowAPI {
 
   private def space(s: String) = if (s.isEmpty) s else s + " "
   private def showMonoDef(d: Definition, label: String)(implicit nesting: Int): String =
-    space(showAnnotations(d.annotations)) + space(showAccess(d.access)) + space(
+    space(showAnnotations(d.annotations.toIndexedSeq)) + space(showAccess(d.access)) + space(
       showModifiers(d.modifiers)
     ) + space(label) + d.name
 
   private def showPolyDef(d: ParameterizedDefinition, label: String)(
       implicit nesting: Int
   ): String =
-    showMonoDef(d, label) + showTypeParameters(d.typeParameters)
+    showMonoDef(d, label) + showTypeParameters(d.typeParameters.toIndexedSeq)
 
   private def showTypeParameters(tps: Seq[TypeParameter])(implicit nesting: Int): String =
     if (tps.isEmpty) ""
     else tps.map(showTypeParameter).mkString("[", ", ", "]")
 
   private def showTypeParameter(tp: TypeParameter)(implicit nesting: Int): String =
-    showAnnotations(tp.annotations) + " " + showVariance(tp.variance) + tp.id + showTypeParameters(
-      tp.typeParameters
+    showAnnotations(tp.annotations.toIndexedSeq) + " " + showVariance(tp.variance) + tp.id + showTypeParameters(
+      tp.typeParameters.toIndexedSeq
     ) + " " + showBounds(tp.lowerBound, tp.upperBound)
 
   private def showAnnotations(as: Seq[Annotation])(implicit nesting: Int) =
diff --git a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/CompilerArguments.scala b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/CompilerArguments.scala
index f490e9150..c6834ada4 100644
--- a/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/CompilerArguments.scala
+++ b/internal/zinc-compile-core/src/main/scala/sbt/internal/inc/CompilerArguments.scala
@@ -88,7 +88,8 @@ final class CompilerArguments(
    */
   def finishClasspath(classpath: Seq[Path]): Seq[Path] = {
     val filteredClasspath = filterLibrary(classpath)
-    val extraCompiler = include(cpOptions.compiler, scalaInstance.compilerJars.map(_.toPath): _*)
+    val extraCompiler =
+      include(cpOptions.compiler, scalaInstance.compilerJars.toIndexedSeq.map(_.toPath): _*)
     val otherJars = scalaInstance.otherJars.toList.map(_.toPath)
     val extraClasspath = include(cpOptions.extra, otherJars: _*)
     filteredClasspath ++ extraCompiler ++ extraClasspath

From 3dc678326a2603c9f03188ffd36e347ffe18ba01 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Fri, 18 Oct 2024 14:02:27 -0700
Subject: [PATCH 46/54] Add even more missing .toIndexedSeq calls

---
 .../internal/inc/CompilingSpecification.scala |  8 ++--
 .../scala/sbt/internal/inc/ClassToAPI.scala   | 29 ++++++++++----
 .../src/main/scala/xsbt/api/Discovery.scala   |  2 +-
 .../src/main/scala/xsbt/api/HashAPI.scala     |  4 +-
 .../src/main/scala/xsbt/api/SameAPI.scala     | 38 +++++++++++--------
 .../sbt/internal/inc/classfile/Parser.scala   |  2 +-
 .../sbt/internal/inc/ScalaInstance.scala      |  2 +-
 .../inc/classpath/ClasspathUtilities.scala    |  2 +-
 8 files changed, 54 insertions(+), 33 deletions(-)

diff --git a/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala b/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala
index 519499e28..2b48f1781 100644
--- a/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala
+++ b/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala
@@ -281,8 +281,8 @@ trait CompilingSpecification extends AbstractBridgeProviderTestkit {
     val cp = (si.allJars).map(_.toPath) ++ Array(targetDir)
     val classpath = cp.map(converter.toVirtualFile)
     sc.doc(
-      sources = sources.toArray[VirtualFile],
-      classpath = classpath,
+      sources = sources.toIndexedSeq,
+      classpath = classpath.toIndexedSeq,
       converter = converter,
       outputDirectory = targetDir,
       options = Nil,
@@ -305,7 +305,7 @@ trait CompilingSpecification extends AbstractBridgeProviderTestkit {
     val cp = (si.allJars).map(_.toPath) ++ Array(targetDir)
     val classpath = cp.map(converter.toVirtualFile)
     sc.console(
-      classpath = classpath,
+      classpath = classpath.toIndexedSeq,
       converter = converter,
       options = Nil,
       initialCommands = initial,
@@ -327,7 +327,7 @@ trait CompilingSpecification extends AbstractBridgeProviderTestkit {
     val cp = (si.allJars).map(_.toPath) ++ Array(targetDir)
     val classpath = cp.map(converter.toVirtualFile)
     sc.interactiveConsole(
-      classpath = classpath,
+      classpath = classpath.toIndexedSeq,
       converter = converter,
       options = args.toSeq,
       initialCommands = "",
diff --git a/internal/zinc-apiinfo/src/main/scala/sbt/internal/inc/ClassToAPI.scala b/internal/zinc-apiinfo/src/main/scala/sbt/internal/inc/ClassToAPI.scala
index 693a0523f..d3506f73d 100644
--- a/internal/zinc-apiinfo/src/main/scala/sbt/internal/inc/ClassToAPI.scala
+++ b/internal/zinc-apiinfo/src/main/scala/sbt/internal/inc/ClassToAPI.scala
@@ -191,14 +191,29 @@ object ClassToAPI {
       cmap: ClassMap
   ): (api.Structure, api.Structure) = {
     lazy val cf = classFileForClass(c)
-    val methods = mergeMap(c, c.getDeclaredMethods, c.getMethods, methodToDef(enclPkg))
-    val fields = mergeMap(c, c.getDeclaredFields, c.getFields, fieldToDef(c, cf, enclPkg))
+    val methods = mergeMap(
+      c,
+      c.getDeclaredMethods.toIndexedSeq,
+      c.getMethods.toIndexedSeq,
+      methodToDef(enclPkg)
+    )
+    val fields = mergeMap(
+      c,
+      c.getDeclaredFields.toIndexedSeq,
+      c.getFields.toIndexedSeq,
+      fieldToDef(c, cf, enclPkg)
+    )
     val constructors =
-      mergeMap(c, c.getDeclaredConstructors, c.getConstructors, constructorToDef(enclPkg))
+      mergeMap(
+        c,
+        c.getDeclaredConstructors.toIndexedSeq,
+        c.getConstructors.toIndexedSeq,
+        constructorToDef(enclPkg)
+      )
     val classes = merge[Class[?]](
       c,
-      c.getDeclaredClasses,
-      c.getClasses,
+      c.getDeclaredClasses.toIndexedSeq,
+      c.getClasses.toIndexedSeq,
       toDefinitions(cmap),
       (_: Seq[Class[?]]).partition(isStatic),
       _.getEnclosingClass != c
@@ -240,7 +255,7 @@ object ClassToAPI {
   private def allSuperTypes(t: Type): Seq[Type] = {
     @tailrec def accumulate(t: Type, accum: Seq[Type] = Seq.empty): Seq[Type] = t match {
       case c: Class[?] =>
-        val (parent, interfaces) = (c.getGenericSuperclass, c.getGenericInterfaces)
+        val (parent, interfaces) = (c.getGenericSuperclass, c.getGenericInterfaces.toIndexedSeq)
         accumulate(parent, (accum :+ parent) ++ flattenAll(interfaces))
       case p: ParameterizedType =>
         accumulate(p.getRawType, accum)
@@ -263,7 +278,7 @@ object ClassToAPI {
   def types(ts: Seq[Type]): Array[api.Type] =
     ts.filter(_ ne null).map(reference).toArray
   def upperBounds(ts: Array[Type]): api.Type =
-    api.Structure.of(lzy(types(ts)), lzyEmptyDefArray, lzyEmptyDefArray)
+    api.Structure.of(lzy(types(ts.toIndexedSeq)), lzyEmptyDefArray, lzyEmptyDefArray)
 
   @deprecated("No longer used", "0.13.0")
   def parents(c: Class[?]): Seq[api.Type] = types(allSuperTypes(c))
diff --git a/internal/zinc-apiinfo/src/main/scala/xsbt/api/Discovery.scala b/internal/zinc-apiinfo/src/main/scala/xsbt/api/Discovery.scala
index 9801e89e3..e5e0313d2 100644
--- a/internal/zinc-apiinfo/src/main/scala/xsbt/api/Discovery.scala
+++ b/internal/zinc-apiinfo/src/main/scala/xsbt/api/Discovery.scala
@@ -66,7 +66,7 @@ object Discovery {
       simpleName(a.base).filter(pred)
     }.toSet
   def defAnnotations(s: Structure, pred: String => Boolean): Set[String] =
-    defAnnotations(s.declared.toIndexedSeq, pred) ++ defAnnotations(s.inherited, pred)
+    defAnnotations(s.declared.toIndexedSeq, pred) ++ defAnnotations(s.inherited.toIndexedSeq, pred)
   def defAnnotations(defs: Seq[Definition], pred: String => Boolean): Set[String] =
     findAnnotations(
       defs.flatMap {
diff --git a/internal/zinc-apiinfo/src/main/scala/xsbt/api/HashAPI.scala b/internal/zinc-apiinfo/src/main/scala/xsbt/api/HashAPI.scala
index 875254059..90349cac3 100644
--- a/internal/zinc-apiinfo/src/main/scala/xsbt/api/HashAPI.scala
+++ b/internal/zinc-apiinfo/src/main/scala/xsbt/api/HashAPI.scala
@@ -432,8 +432,8 @@ final class HashAPI private (
     extend(StructureHash)
     hashTypes(structure.parents, includeDefinitions)
     if (includeDefinitions) {
-      hashDefinitions(structure.declared, false, isTrait)
-      hashDefinitions(structure.inherited, false, isTrait)
+      hashDefinitions(structure.declared.toIndexedSeq, false, isTrait)
+      hashDefinitions(structure.inherited.toIndexedSeq, false, isTrait)
     }
   }
   def hashParameters(parameters: Array[TypeParameter], base: Type): Unit = {
diff --git a/internal/zinc-apiinfo/src/main/scala/xsbt/api/SameAPI.scala b/internal/zinc-apiinfo/src/main/scala/xsbt/api/SameAPI.scala
index bc926caa5..8049d611f 100644
--- a/internal/zinc-apiinfo/src/main/scala/xsbt/api/SameAPI.scala
+++ b/internal/zinc-apiinfo/src/main/scala/xsbt/api/SameAPI.scala
@@ -139,7 +139,10 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
     // a.name == b.name &&
     debug(sameAccess(a.access, b.access), "Access differed") &&
     debug(sameModifiers(a.modifiers, b.modifiers), "Modifiers differed") &&
-    debug(sameAnnotations(a.annotations, b.annotations), "Annotations differed") &&
+    debug(
+      sameAnnotations(a.annotations.toIndexedSeq, b.annotations.toIndexedSeq),
+      "Annotations differed"
+    ) &&
     debug(sameDefinitionSpecificAPI(a, b), "Definition-specific differed")
   }
 
@@ -184,7 +187,7 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
   def sameAnnotation(a: Annotation, b: Annotation): Boolean =
     debug(sameType(a.base, b.base), "Annotation base type differed") &&
       debug(
-        sameAnnotationArguments(a.arguments, b.arguments),
+        sameAnnotationArguments(a.arguments.toIndexedSeq, b.arguments.toIndexedSeq),
         "Annotation arguments differed (" + a + ") and (" + b + ")"
       )
   def sameAnnotationArguments(a: Seq[AnnotationArgument], b: Seq[AnnotationArgument]): Boolean =
@@ -203,7 +206,7 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
 
   def sameParameterizedDefinition(a: ParameterizedDefinition, b: ParameterizedDefinition): Boolean =
     debug(
-      sameTypeParameters(a.typeParameters, b.typeParameters),
+      sameTypeParameters(a.typeParameters.toIndexedSeq, b.typeParameters.toIndexedSeq),
       "Different type parameters for " + a.name
     ) &&
       sameParameterizedSpecificAPI(a, b)
@@ -222,7 +225,7 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
 
   def sameDefSpecificAPI(a: Def, b: Def): Boolean =
     debug(
-      sameValueParameters(a.valueParameters, b.valueParameters),
+      sameValueParameters(a.valueParameters.toIndexedSeq, b.valueParameters.toIndexedSeq),
       "Different def value parameters for " + a.name
     ) &&
       debug(sameType(a.returnType, b.returnType), "Different def return type for " + a.name)
@@ -253,7 +256,7 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
     debug(sameTopLevel(a, b), "Top level flag differs") &&
     sameDefinitionType(a.definitionType, b.definitionType) &&
     sameType(a.selfType, b.selfType) &&
-    sameSeq(a.childrenOfSealedClass, b.childrenOfSealedClass)(sameType) &&
+    sameSeq(a.childrenOfSealedClass.toIndexedSeq, b.childrenOfSealedClass.toIndexedSeq)(sameType) &&
     sameStructure(a.structure, b.structure)
   }
 
@@ -265,7 +268,7 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
 
   def sameParameterList(a: ParameterList, b: ParameterList): Boolean =
     (a.isImplicit == b.isImplicit) &&
-      sameParameters(a.parameters, b.parameters)
+      sameParameters(a.parameters.toIndexedSeq, b.parameters.toIndexedSeq)
   def sameParameters(a: Seq[MethodParameter], b: Seq[MethodParameter]): Boolean =
     sameSeq(a, b)(sameMethodParameter)
   def sameMethodParameter(a: MethodParameter, b: MethodParameter): Boolean =
@@ -283,8 +286,11 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
   def sameTypeParameters(a: Seq[TypeParameter], b: Seq[TypeParameter]): Boolean =
     debug(sameSeq(a, b)(sameTypeParameter), "Different type parameters")
   def sameTypeParameter(a: TypeParameter, b: TypeParameter): Boolean = {
-    sameTypeParameters(a.typeParameters, b.typeParameters) &&
-    debug(sameAnnotations(a.annotations, b.annotations), "Different type parameter annotations") &&
+    sameTypeParameters(a.typeParameters.toIndexedSeq, b.typeParameters.toIndexedSeq) &&
+    debug(
+      sameAnnotations(a.annotations.toIndexedSeq, b.annotations.toIndexedSeq),
+      "Different type parameter annotations"
+    ) &&
     debug(sameVariance(a.variance, b.variance), "Different variance") &&
     debug(sameType(a.lowerBound, b.lowerBound), "Different lower bound") &&
     debug(sameType(a.upperBound, b.upperBound), "Different upper bound") &&
@@ -326,14 +332,14 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
     sameType(ca.baseType, cb.baseType) &&
       ca.value == cb.value
   def sameExistentialType(a: Existential, b: Existential): Boolean =
-    sameTypeParameters(a.clause, b.clause) &&
+    sameTypeParameters(a.clause.toIndexedSeq, b.clause.toIndexedSeq) &&
       sameType(a.baseType, b.baseType)
   def samePolymorphicType(a: Polymorphic, b: Polymorphic): Boolean =
-    sameTypeParameters(a.parameters, b.parameters) &&
+    sameTypeParameters(a.parameters.toIndexedSeq, b.parameters.toIndexedSeq) &&
       sameType(a.baseType, b.baseType)
   def sameAnnotatedType(a: Annotated, b: Annotated): Boolean =
     sameType(a.baseType, b.baseType) &&
-      sameAnnotations(a.annotations, b.annotations)
+      sameAnnotations(a.annotations.toIndexedSeq, b.annotations.toIndexedSeq)
   def sameStructure(a: Structure, b: Structure): Boolean =
     samePending(a, b)(sameStructureDirect)
 
@@ -341,9 +347,9 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
     if (pending add ((a, b))) f(a, b) else true
 
   def sameStructureDirect(a: Structure, b: Structure): Boolean = {
-    sameSeq(a.parents, b.parents)(sameType) &&
-    sameMembers(a.declared, b.declared) &&
-    sameMembers(a.inherited, b.inherited)
+    sameSeq(a.parents.toIndexedSeq, b.parents.toIndexedSeq)(sameType) &&
+    sameMembers(a.declared.toIndexedSeq, b.declared.toIndexedSeq) &&
+    sameMembers(a.inherited.toIndexedSeq, b.inherited.toIndexedSeq)
   }
 
   def sameMembers(a: Seq[Definition], b: Seq[Definition]): Boolean =
@@ -358,7 +364,7 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
 
   def sameParameterized(a: Parameterized, b: Parameterized): Boolean =
     sameType(a.baseType, b.baseType) &&
-      sameSeq(a.typeArguments, b.typeArguments)(sameType)
+      sameSeq(a.typeArguments.toIndexedSeq, b.typeArguments.toIndexedSeq)(sameType)
   def sameParameterRef(a: ParameterRef, b: ParameterRef): Boolean = sameTags(a.id, b.id)
   def sameSingleton(a: Singleton, b: Singleton): Boolean =
     samePath(a.path, b.path)
@@ -367,7 +373,7 @@ class SameAPI(includePrivate: Boolean, includeParamNames: Boolean) {
       (a.id == b.id)
 
   def samePath(a: Path, b: Path): Boolean =
-    samePathComponents(a.components, b.components)
+    samePathComponents(a.components.toIndexedSeq, b.components.toIndexedSeq)
   def samePathComponents(a: Seq[PathComponent], b: Seq[PathComponent]): Boolean =
     sameSeq(a, b)(samePathComponent)
   def samePathComponent(a: PathComponent, b: PathComponent): Boolean =
diff --git a/internal/zinc-classfile/src/main/scala/sbt/internal/inc/classfile/Parser.scala b/internal/zinc-classfile/src/main/scala/sbt/internal/inc/classfile/Parser.scala
index 01744c109..edbc7c3da 100644
--- a/internal/zinc-classfile/src/main/scala/sbt/internal/inc/classfile/Parser.scala
+++ b/internal/zinc-classfile/src/main/scala/sbt/internal/inc/classfile/Parser.scala
@@ -106,7 +106,7 @@ private[sbt] object Parser {
           in.readUnsignedShort(),
           toString(in.readUnsignedShort()),
           toString(in.readUnsignedShort()),
-          array(in.readUnsignedShort())(parseAttribute())
+          array(in.readUnsignedShort())(parseAttribute()).toIndexedSeq
         )
       private def parseAttribute() = {
         val nameIndex = in.readUnsignedShort()
diff --git a/internal/zinc-classpath/src/main/scala/sbt/internal/inc/ScalaInstance.scala b/internal/zinc-classpath/src/main/scala/sbt/internal/inc/ScalaInstance.scala
index 41ee277c2..b28230152 100644
--- a/internal/zinc-classpath/src/main/scala/sbt/internal/inc/ScalaInstance.scala
+++ b/internal/zinc-classpath/src/main/scala/sbt/internal/inc/ScalaInstance.scala
@@ -266,7 +266,7 @@ object ScalaInstance {
 
   /** Return all the required Scala jars from a path `scalaHome`. */
   def allJars(scalaHome: File): Seq[File] =
-    IO.listFiles(scalaLib(scalaHome)).filter(f => !blacklist(f.getName))
+    IO.listFiles(scalaLib(scalaHome)).toIndexedSeq.filter(f => !blacklist(f.getName))
 
   private[this] def scalaLib(scalaHome: File): File =
     new File(scalaHome, "lib")
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..aea685817 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
@@ -81,7 +81,7 @@ object ClasspathUtil {
       classpath: Seq[Path],
       instance: ScalaInstance
   ): Map[String, String] = {
-    createClasspathResources(classpath, instance.libraryJars.map(_.toPath))
+    createClasspathResources(classpath, instance.libraryJars.toIndexedSeq.map(_.toPath))
   }
 
   def createClasspathResources(appPaths: Seq[Path], bootPaths: Seq[Path]): Map[String, String] = {

From 1f63557191a9bdc81a39cf3ac8c90117cff574fc Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Fri, 18 Oct 2024 15:44:23 -0700
Subject: [PATCH 47/54] Remove an unused import

---
 .../src/test/scala/sbt/internal/inc/CompilingSpecification.scala | 1 -
 1 file changed, 1 deletion(-)

diff --git a/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala b/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala
index 2b48f1781..e926b5265 100644
--- a/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala
+++ b/internal/compiler-bridge-test/src/test/scala/sbt/internal/inc/CompilingSpecification.scala
@@ -9,7 +9,6 @@ import java.util.Optional
 
 import sbt.internal.inc.classpath.ClassLoaderCache
 import sbt.io.IO
-import sbt.io.syntax._
 import xsbti.compile._
 import sbt.util.Logger
 import xsbti.TestCallback.ExtractedClassDependencies

From e74d3e45a5af469d6b9868f86bb41fcaff532405 Mon Sep 17 00:00:00 2001
From: Friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Fri, 18 Oct 2024 18:51:53 -0700
Subject: [PATCH 48/54] Fix some more deprecation warnings

---
 .../src/main/scala/sbt/internal/inc/classfile/Parser.scala  | 6 +++---
 .../scala/sbt/internal/inc/classpath/ClassLoaders.scala     | 4 ++--
 .../src/main/scala/sbt/internal/inc/Compilations.scala      | 2 +-
 .../main/scala/sbt/internal/inc/text/FormatCommons.scala    | 2 +-
 .../scala/sbt/internal/inc/text/RelationsTextFormat.scala   | 2 +-
 5 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/internal/zinc-classfile/src/main/scala/sbt/internal/inc/classfile/Parser.scala b/internal/zinc-classfile/src/main/scala/sbt/internal/inc/classfile/Parser.scala
index edbc7c3da..28f560a00 100644
--- a/internal/zinc-classfile/src/main/scala/sbt/internal/inc/classfile/Parser.scala
+++ b/internal/zinc-classfile/src/main/scala/sbt/internal/inc/classfile/Parser.scala
@@ -39,13 +39,13 @@ import Constants._
 private[sbt] object Parser {
 
   def apply(file: Path, log: Logger): ClassFile =
-    Using.bufferedInputStream(Files.newInputStream(file))(parse(file.toString, log)).right.get
+    Using.bufferedInputStream(Files.newInputStream(file))(parse(file.toString, log)).toOption.get
 
   def apply(file: File, log: Logger): ClassFile =
-    Using.fileInputStream(file)(parse(file.toString, log)).right.get
+    Using.fileInputStream(file)(parse(file.toString, log)).toOption.get
 
   def apply(url: URL, log: Logger): ClassFile =
-    usingUrlInputStreamWithoutCaching(url)(parse(url.toString, log)).right.get
+    usingUrlInputStreamWithoutCaching(url)(parse(url.toString, log)).toOption.get
 
   // JarURLConnection with caching enabled will never close the jar
   private val usingUrlInputStreamWithoutCaching = Using.resource((u: URL) =>
diff --git a/internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath/ClassLoaders.scala b/internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath/ClassLoaders.scala
index 3074c2d23..fde68b471 100644
--- a/internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath/ClassLoaders.scala
+++ b/internal/zinc-classpath/src/main/scala/sbt/internal/inc/classpath/ClassLoaders.scala
@@ -191,8 +191,8 @@ trait NativeCopyLoader extends ClassLoader {
 
   private[this] def findLibrary0(name: String): String = {
     val mappedName = System.mapLibraryName(name)
-    val explicit = explicitLibraries.toIterator.filter(_.getFileName.toString == mappedName)
-    val search = searchPaths.toIterator flatMap relativeLibrary(mappedName)
+    val explicit = explicitLibraries.iterator.filter(_.getFileName.toString == mappedName)
+    val search = searchPaths.iterator flatMap relativeLibrary(mappedName)
     val combined = explicit ++ search
     if (combined.hasNext) copy(combined.next()) else null
   }
diff --git a/internal/zinc-core/src/main/scala/sbt/internal/inc/Compilations.scala b/internal/zinc-core/src/main/scala/sbt/internal/inc/Compilations.scala
index b8021a66b..f992ee7fb 100644
--- a/internal/zinc-core/src/main/scala/sbt/internal/inc/Compilations.scala
+++ b/internal/zinc-core/src/main/scala/sbt/internal/inc/Compilations.scala
@@ -30,7 +30,7 @@ trait Compilations extends ReadCompilations {
 object Compilations {
   val empty: Compilations = new MCompilations(Seq.empty)
   def of(s: Seq[Compilation]): Compilations = new MCompilations(s)
-  def merge(s: Traversable[Compilations]): Compilations =
+  def merge(s: Iterable[Compilations]): Compilations =
     of((s flatMap { _.allCompilations }).toSeq.distinct)
 }
 
diff --git a/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/FormatCommons.scala b/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/FormatCommons.scala
index eef736e0a..20d28cd06 100644
--- a/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/FormatCommons.scala
+++ b/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/FormatCommons.scala
@@ -155,7 +155,7 @@ trait FormatCommons {
 
   protected def readMappedPairs[K, V](
       in: BufferedReader
-  )(expectedHeader: String, s2k: String => K, s2v: (K, String) => V): Traversable[(K, V)] = {
+  )(expectedHeader: String, s2k: String => K, s2v: (K, String) => V): Iterable[(K, V)] = {
     def toPair(s: String): (K, V) = {
       if (s == null) throw new EOFException
       val p = s.indexOf(" -> ")
diff --git a/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/RelationsTextFormat.scala b/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/RelationsTextFormat.scala
index eae0ced88..495b31008 100644
--- a/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/RelationsTextFormat.scala
+++ b/internal/zinc-persist/src/main/scala/sbt/internal/inc/text/RelationsTextFormat.scala
@@ -82,7 +82,7 @@ trait RelationsTextFormat extends FormatCommons {
     def read(in: BufferedReader): Relations = {
       def readRelation[A, B](relDesc: Descriptor[A, B]): Map[A, Set[B]] = {
         import relDesc._
-        val items = readPairs(in)(header, keyMapper.read, valueMapper.read).toIterator
+        val items = readPairs(in)(header, keyMapper.read, valueMapper.read).iterator
         // Reconstruct the multi-map efficiently, using the writing strategy above
         val builder = Map.newBuilder[A, Set[B]]
         var currentKey = null.asInstanceOf[A]

From ce7ad0b441cbc41f2ac018dd21e8b74e717435cc Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Sat, 19 Oct 2024 00:48:23 -0400
Subject: [PATCH 49/54] deps: util 1.10.3

---
 project/Dependencies.scala | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index fb8323598..259959d15 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -15,8 +15,8 @@ object Dependencies {
   val compilerBridgeVersions = Seq(scala212, scala210, scala211, scala213)
   val scala212_213 = Seq(defaultScalaVersion, scala213)
 
-  private val ioVersion = nightlyVersion.getOrElse("1.10.0")
-  private val utilVersion = nightlyVersion.getOrElse("1.10.2")
+  private val ioVersion = nightlyVersion.getOrElse("1.10.1")
+  private val utilVersion = nightlyVersion.getOrElse("1.10.3")
 
   private val sbtIO = "org.scala-sbt" %% "io" % ioVersion
 
@@ -27,7 +27,7 @@ object Dependencies {
   private val utilInterface = "org.scala-sbt" % "util-interface" % utilVersion
   private val utilScripted = "org.scala-sbt" %% "util-scripted" % utilVersion
 
-  val launcherInterface = "org.scala-sbt" % "launcher-interface" % "1.4.3"
+  val launcherInterface = "org.scala-sbt" % "launcher-interface" % "1.4.4"
 
   def getSbtModulePath(key: String, name: String) = {
     val localProps = new java.util.Properties()

From 71ec0275712d34ed6a07485ad983502e64e6f846 Mon Sep 17 00:00:00 2001
From: xuwei-k <6b656e6a69@gmail.com>
Date: Sun, 6 Oct 2024 19:49:17 +0900
Subject: [PATCH 50/54] avoid deprecated collection.mutable.MultiMap

---
 .../src/main/scala/xsbti/TestCallback.scala     | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala b/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala
index 484407c2f..8ccc840a7 100644
--- a/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala
+++ b/internal/zinc-testing/src/main/scala/xsbti/TestCallback.scala
@@ -181,11 +181,18 @@ object TestCallback {
     }
 
     private def pairsToMultiMap[A, B](pairs: Seq[(A, B)]): Map[A, Set[B]] = {
-      import scala.collection.mutable.{ HashMap, MultiMap }
-      val emptyMultiMap = new HashMap[A, scala.collection.mutable.Set[B]] with MultiMap[A, B]
-      val multiMap = pairs.foldLeft(emptyMultiMap) {
-        case (acc, (key, value)) =>
-          acc.addBinding(key, value)
+      import scala.collection.mutable.HashMap
+      val multiMap = HashMap.empty[A, scala.collection.mutable.Set[B]]
+      pairs.foreach {
+        case (key, value) =>
+          multiMap.get(key) match {
+            case None =>
+              val set = collection.mutable.Set.empty[B]
+              set += value
+              multiMap(key) = set
+            case Some(set) =>
+              set += value
+          }
       }
       // convert all collections to immutable variants
       multiMap.toMap.mapValues(_.toSet).toMap.withDefaultValue(Set.empty)

From 9689180509f219cc172165ef4fc351e06f723b29 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sat, 19 Oct 2024 00:29:51 -0700
Subject: [PATCH 51/54] Remove deprecated OpenHashMap

---
 .../src/main/scala/sbt/internal/inc/ReflectUtilities.scala | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/internal/zinc-classpath/src/main/scala/sbt/internal/inc/ReflectUtilities.scala b/internal/zinc-classpath/src/main/scala/sbt/internal/inc/ReflectUtilities.scala
index 61f376182..06b9e2aec 100644
--- a/internal/zinc-classpath/src/main/scala/sbt/internal/inc/ReflectUtilities.scala
+++ b/internal/zinc-classpath/src/main/scala/sbt/internal/inc/ReflectUtilities.scala
@@ -13,6 +13,7 @@ package sbt
 package internal
 package inc
 
+import java.lang.reflect.Field
 import scala.collection._
 
 object ReflectUtilities {
@@ -33,10 +34,10 @@ object ReflectUtilities {
 
   def ancestry(clazz: Class[?]): List[Class[?]] =
     if (clazz == classOf[AnyRef] || !classOf[AnyRef].isAssignableFrom(clazz)) List(clazz)
-    else clazz :: ancestry(clazz.getSuperclass);
+    else clazz :: ancestry(clazz.getSuperclass)
 
-  def fields(clazz: Class[?]) =
-    mutable.OpenHashMap(ancestry(clazz).flatMap(_.getDeclaredFields).map(f => (f.getName, f)): _*)
+  def fields(clazz: Class[?]): mutable.Map[String, Field] =
+    mutable.AnyRefMap(ancestry(clazz).flatMap(_.getDeclaredFields).map(f => (f.getName, f)): _*)
 
   /**
    * Collects all `val`s of type `T` defined on value `self`.

From 92b1cbfd088bedfaaff818153e4bd33b32ee9220 Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sat, 19 Oct 2024 00:43:26 -0700
Subject: [PATCH 52/54] Add MIMA exclusion rule

---
 build.sbt | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/build.sbt b/build.sbt
index 79775dc50..9c8e872f2 100644
--- a/build.sbt
+++ b/build.sbt
@@ -641,6 +641,9 @@ lazy val zincClasspath = (projectMatrix in internalPath / "zinc-classpath")
       exclude[IncompatibleResultTypeProblem](
         "sbt.internal.inc.classpath.NativeCopyConfig.*"
       ),
+      exclude[IncompatibleResultTypeProblem](
+        "sbt.internal.inc.ReflectUtilities.fields"
+      ),
       exclude[IncompatibleSignatureProblem](
         "sbt.internal.inc.classpath.NativeCopyConfig.*"
       ),

From 7aa4a1f95d0bf69fc828b22c40849316ad1b3efb Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sat, 19 Oct 2024 00:53:53 -0700
Subject: [PATCH 53/54] Add all major zinc versions to mimaPreviousArtifacts

---
 build.sbt | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/build.sbt b/build.sbt
index 9c8e872f2..4f2dea499 100644
--- a/build.sbt
+++ b/build.sbt
@@ -29,6 +29,9 @@ def mimaSettings: Seq[Setting[?]] = Seq(
       "1.5.0",
       "1.6.0",
       "1.7.0",
+      "1.8.0",
+      "1.9.0",
+      "1.10.0",
     )
     val versions =
       if (scalaVersion.value.startsWith("2.12.")) pre140 ++ post140

From c170707b692657615be5d1ed246ab2d50db3b7ac Mon Sep 17 00:00:00 2001
From: friendseeker <66892505+Friendseeker@users.noreply.github.com>
Date: Sat, 19 Oct 2024 13:47:30 -0700
Subject: [PATCH 54/54] Comment out failing test

---
 .github/workflows/ci.yml | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c5bb26241..7a5906b26 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -90,8 +90,8 @@ jobs:
       shell: bash
       run: |
         sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*Shapeless.*" "runBenchmarks"
-    - name: Benchmark (AnalysisFormatBenchmark) against Target Branch (6)
-      if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 6 }}
-      shell: bash
-      run: |
-        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*AnalysisFormatBenchmark.*" "runBenchmarks"
+#    - name: Benchmark (AnalysisFormatBenchmark) against Target Branch (6)
+#      if: ${{ github.event_name == 'pull_request' && matrix.jobtype == 6 }}
+#      shell: bash
+#      run: |
+#        sbt -v -Dfile.encoding=UTF-8 "-Dbenchmark.pattern=.*AnalysisFormatBenchmark.*" "runBenchmarks"