From 4dcae2cb734e402845cf31b762131b248ac4c776 Mon Sep 17 00:00:00 2001
From: Eric Peters <eric@peters.org>
Date: Fri, 20 Aug 2021 19:47:19 -0700
Subject: [PATCH 01/11] Add --sbt-cache argument and update localCacheDirectory
 key description

---
 .../src/test/scala/RunnerTest.scala           |  9 +-------
 .../src/test/scala/ScriptTest.scala           | 12 +++++++++-
 launcher-package/src/universal/bin/sbt.bat    | 22 +++++++++++++++++++
 main/src/main/scala/sbt/Keys.scala            |  2 +-
 sbt                                           |  5 +++++
 5 files changed, 40 insertions(+), 10 deletions(-)

diff --git a/launcher-package/integration-test/src/test/scala/RunnerTest.scala b/launcher-package/integration-test/src/test/scala/RunnerTest.scala
index 721fff23e..6d43be04a 100755
--- a/launcher-package/integration-test/src/test/scala/RunnerTest.scala
+++ b/launcher-package/integration-test/src/test/scala/RunnerTest.scala
@@ -6,7 +6,7 @@ import java.io.File
 
 object SbtRunnerTest extends SimpleTestSuite with PowerAssertions {
   // 1.3.0, 1.3.0-M4
-  private val versionRegEx = "\\d(\\.\\d+){2}(-\\w+)?"
+  private[test] val versionRegEx = "\\d(\\.\\d+){2}(-\\w+)?"
 
   lazy val isWindows: Boolean = sys.props("os.name").toLowerCase(java.util.Locale.ENGLISH).contains("windows")
   lazy val sbtScript =
@@ -49,13 +49,6 @@ object SbtRunnerTest extends SimpleTestSuite with PowerAssertions {
     ()
   }
 
-  test("sbt --script-version should print sbtVersion") {
-    val out = sbtProcess("--script-version").!!.trim
-    val expectedVersion = "^"+versionRegEx+"$"
-    assert(out.matches(expectedVersion))
-    ()
-  }
-
   test("sbt --sbt-jar should run") {
     val out = sbtProcess("compile", "-v", "--sbt-jar", "../target/universal/stage/bin/sbt-launch.jar").!!.linesIterator.toList
     assert(out.contains[String]("../target/universal/stage/bin/sbt-launch.jar") ||
diff --git a/launcher-package/integration-test/src/test/scala/ScriptTest.scala b/launcher-package/integration-test/src/test/scala/ScriptTest.scala
index 1db0c50dc..570f0b0dd 100644
--- a/launcher-package/integration-test/src/test/scala/ScriptTest.scala
+++ b/launcher-package/integration-test/src/test/scala/ScriptTest.scala
@@ -109,7 +109,6 @@ object SbtScriptTest extends SimpleTestSuite with PowerAssertions {
     assert(out.contains[String]("-Xss6M"))
   }
 
-
   makeTest(
     name = "sbt with -Dhttp.proxyHost=proxy -Dhttp.proxyPort=8080 in SBT_OPTS",
     sbtOpts = "-Dhttp.proxyHost=proxy -Dhttp.proxyPort=8080",
@@ -169,4 +168,15 @@ object SbtScriptTest extends SimpleTestSuite with PowerAssertions {
     if (isWindows) cancel("Test not supported on windows")
     assert(out.contains[String]("-Dsbt.ivy.home=/ivy/dir"))
   }
+
+  test("sbt --script-version should print sbtVersion") {
+    val out = sbtProcess("--script-version").!!.trim
+    val expectedVersion = "^"+SbtRunnerTest.versionRegEx+"$"
+    assert(out.matches(expectedVersion))
+    ()
+  }
+
+  makeTest("--sbt-cache")("--sbt-cache", "./cachePath") { out: List[String] =>
+    assert(out.contains[String](s"-Dsbt.global.localcache=./cachePath"))
+  }
 }
diff --git a/launcher-package/src/universal/bin/sbt.bat b/launcher-package/src/universal/bin/sbt.bat
index cda987c9e..1a59fd9e1 100755
--- a/launcher-package/src/universal/bin/sbt.bat
+++ b/launcher-package/src/universal/bin/sbt.bat
@@ -42,6 +42,8 @@ set sbt_args_ivy=
 set sbt_args_supershell=
 set sbt_args_timings=
 set sbt_args_traces=
+set sbt_args_sbt_boot=
+set sbt_args_sbt_cache=
 set sbt_args_sbt_create=
 set sbt_args_sbt_dir=
 set sbt_args_sbt_version=
@@ -259,6 +261,21 @@ if defined _sbt_boot_arg (
  )
 )
 
+if "%~0" == "-sbt-cache" set _sbt_cache_arg=true
+if "%~0" == "--sbt-cache" set _sbt_cache_arg=true
+
+if defined _sbt_cache_arg (
+ set _sbt_cache_arg=
+ if not "%~1" == "" (
+   set sbt_args_sbt_cache=%1
+   shift
+   goto args_loop
+ ) else (
+   echo "%~0" is missing a value
+   goto error
+ )
+)
+
 if "%~0" == "-sbt-jar" set _sbt_jar=true
 if "%~0" == "--sbt-jar" set _sbt_jar=true
 
@@ -587,6 +604,10 @@ if defined sbt_args_sbt_boot (
   set _SBT_OPTS=-Dsbt.boot.directory=!sbt_args_sbt_boot! !_SBT_OPTS!
 )
 
+if defined sbt_args_sbt_cache (
+  set _SBT_OPTS=-Dsbt.global.localcache=!sbt_args_sbt_cache! !_SBT_OPTS!
+)
+
 if defined sbt_args_ivy (
   set _SBT_OPTS=-Dsbt.ivy.home=!sbt_args_ivy! !_SBT_OPTS!
 )
@@ -932,6 +953,7 @@ echo   --timings           display task timings report on shutdown
 echo   --sbt-create        start sbt even if current directory contains no sbt project
 echo   --sbt-dir   ^<path^>  path to global settings/plugins directory ^(default: ~/.sbt^)
 echo   --sbt-boot  ^<path^>  path to shared boot directory ^(default: ~/.sbt/boot in 0.11 series^)
+echo   --sbt-cache ^<path^>  path to global cache directory ^(default: operating system specific^)
 echo   --ivy       ^<path^>  path to local Ivy repository ^(default: ~/.ivy2^)
 echo   --mem    ^<integer^>  set memory options ^(default: %sbt_default_mem%^)
 echo   --no-share          use all local caches; no sharing
diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala
index b271fbc1e..21c678fad 100644
--- a/main/src/main/scala/sbt/Keys.scala
+++ b/main/src/main/scala/sbt/Keys.scala
@@ -392,7 +392,7 @@ object Keys {
   val pushRemoteCacheTo = settingKey[Option[Resolver]]("The resolver to publish remote cache to.")
   val remoteCacheResolvers = settingKey[Seq[Resolver]]("Resolvers for remote cache.")
   val remoteCachePom = taskKey[File]("Generates a pom for publishing when publishing Maven-style.")
-  val localCacheDirectory = settingKey[File]("Directory to pull the remote cache to.")
+  val localCacheDirectory = settingKey[File]("Operating system specific cache directory.")
   val usePipelining = settingKey[Boolean]("Use subproject pipelining for compilation.").withRank(BSetting)
   val exportPipelining = settingKey[Boolean]("Product early output so downstream subprojects can do pipelining.").withRank(BSetting)
 
diff --git a/sbt b/sbt
index 7fb865514..ef5e6ebc7 100755
--- a/sbt
+++ b/sbt
@@ -538,6 +538,7 @@ Usage: `basename "$0"` [options]
   --sbt-create        start sbt even if current directory contains no sbt project
   --sbt-dir   <path>  path to global settings/plugins directory (default: ~/.sbt)
   --sbt-boot  <path>  path to shared boot directory (default: ~/.sbt/boot in 0.11 series)
+  --sbt-cache <path>  path to global cache directory (default: operating system specific)
   --ivy       <path>  path to local Ivy repository (default: ~/.ivy2)
   --mem    <integer>  set memory options (default: $sbt_default_mem)
   --no-share          use all local caches; no sharing
@@ -648,6 +649,10 @@ process_args () {
              -batch|--batch) exec </dev/null && shift ;;
 
          -sbt-jar|--sbt-jar) require_arg path "$1" "$2" && sbt_jar="$2" && shift 2 ;;
+     -sbt-cache|--sbt-cache) require_arg path "$1" "$2" &&
+                             sbt_cache="$2" &&
+                             addJava "-Dsbt.global.localcache=$2" &&
+                             shift 2 ;;
  -sbt-version|--sbt-version) require_arg version "$1" "$2" && sbt_version="$2" && shift 2 ;;
      -java-home|--java-home) require_arg path "$1" "$2" &&
                              java_cmd="$2/bin/java" &&

From c31f12d884506417565643f1dd5e072f89393662 Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Fri, 17 Sep 2021 04:17:24 -0400
Subject: [PATCH 02/11] JDK 17

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

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5ab7e9362..f51900803 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,31 +10,31 @@ jobs:
       matrix:
         include:
           - os: ubuntu-latest
-            java: 11
+            java: "17.0-custom=tgz+https://download.java.net/java/GA/jdk17/0d483333a00540d886896bac774ff48b/35/GPL/openjdk-17_linux-x64_bin.tar.gz"
             jobtype: 1
           - os: ubuntu-latest
-            java: 11
+            java: "17.0-custom=tgz+https://download.java.net/java/GA/jdk17/0d483333a00540d886896bac774ff48b/35/GPL/openjdk-17_linux-x64_bin.tar.gz"
             jobtype: 2
           - os: ubuntu-latest
-            java: 11
+            java: "17.0-custom=tgz+https://download.java.net/java/GA/jdk17/0d483333a00540d886896bac774ff48b/35/GPL/openjdk-17_linux-x64_bin.tar.gz"
             jobtype: 3
           - os: ubuntu-latest
-            java: 11
+            java: "17.0-custom=tgz+https://download.java.net/java/GA/jdk17/0d483333a00540d886896bac774ff48b/35/GPL/openjdk-17_linux-x64_bin.tar.gz"
             jobtype: 4
           - os: ubuntu-latest
-            java: 11
+            java: "17-custom=tgz+https://download.java.net/java/GA/jdk17/0d483333a00540d886896bac774ff48b/35/GPL/openjdk-17_linux-x64_bin.tar.gz"
             jobtype: 5
           - os: ubuntu-latest
-            java: 8
+            java: "adopt@1.8"
             jobtype: 6
           - os: ubuntu-latest
-            java: 8
+            java: "adopt@1.8"
             jobtype: 7
           - os: macos-latest
-            java: 8
+            java: "adopt@1.8"
             jobtype: 8
           - os: windows-latest
-            java: 8
+            java: "adopt@1.8"
             jobtype: 9
     runs-on: ${{ matrix.os }}
     env:
@@ -72,7 +72,7 @@ jobs:
     - name: Setup
       uses: olafurpg/setup-scala@v13
       with:
-        java-version: "adopt@1.${{ matrix.java }}"
+        java-version: "${{ matrix.java }}"
     - name: Set up Python 3.7
       uses: actions/setup-python@v2
       with:

From e4f29d37a43070a88d20d31e0641fcfa6582e2c7 Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Fri, 17 Sep 2021 05:14:11 -0400
Subject: [PATCH 03/11] nowarn on TrapExit

---
 run/src/main/scala/sbt/TrapExit.scala | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/run/src/main/scala/sbt/TrapExit.scala b/run/src/main/scala/sbt/TrapExit.scala
index 5c80e1be0..2e53ed2c4 100644
--- a/run/src/main/scala/sbt/TrapExit.scala
+++ b/run/src/main/scala/sbt/TrapExit.scala
@@ -7,6 +7,7 @@
 
 package sbt
 
+import scala.annotation.nowarn
 import scala.reflect.Manifest
 import scala.collection.concurrent.TrieMap
 import java.lang.ref.WeakReference
@@ -32,6 +33,7 @@ import TrapExit._
  * do not terminate, or if concurrent AWT applications are run.
  * This category of code should only be called by forking a new JVM.
  */
+@nowarn
 object TrapExit {
 
   /**
@@ -144,6 +146,7 @@ object TrapExit {
  * It also allows disposing AWT windows if the application created any.
  * Only one AWT application is supported at a time, however.
  */
+@nowarn
 private final class TrapExit(delegateManager: SecurityManager) extends SecurityManager {
 
   /** Tracks the number of running applications in order to short-cut SecurityManager checks when no applications are active.*/

From c013d1180cc81e4e1e1a24e287317c8f2e5a3cb5 Mon Sep 17 00:00:00 2001
From: Amina Adewusi <amina.adewusi@guardian.co.uk>
Date: Fri, 17 Sep 2021 17:46:07 +0100
Subject: [PATCH 04/11] Bump scala version to 2.12.15

---
 build.sbt                                 | 2 +-
 main/src/main/scala/sbt/PluginCross.scala | 2 +-
 project/Dependencies.scala                | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/build.sbt b/build.sbt
index 55a26b6ab..0e6137e5c 100644
--- a/build.sbt
+++ b/build.sbt
@@ -45,7 +45,7 @@ ThisBuild / scmInfo := Some(
 ThisBuild / resolvers += Resolver.mavenLocal
 
 Global / semanticdbEnabled := !(Global / insideCI).value
-Global / semanticdbVersion := "4.4.20"
+Global / semanticdbVersion := "4.4.28"
 val excludeLint = SettingKey[Set[Def.KeyedInitialize[_]]]("excludeLintKeys")
 Global / excludeLint := (Global / excludeLint).?.value.getOrElse(Set.empty)
 Global / excludeLint += componentID
diff --git a/main/src/main/scala/sbt/PluginCross.scala b/main/src/main/scala/sbt/PluginCross.scala
index 39dc0a071..98d5d57e1 100644
--- a/main/src/main/scala/sbt/PluginCross.scala
+++ b/main/src/main/scala/sbt/PluginCross.scala
@@ -99,7 +99,7 @@ private[sbt] object PluginCross {
     VersionNumber(sv) match {
       case VersionNumber(Seq(0, 12, _*), _, _) => "2.9.2"
       case VersionNumber(Seq(0, 13, _*), _, _) => "2.10.7"
-      case VersionNumber(Seq(1, 0, _*), _, _)  => "2.12.14"
+      case VersionNumber(Seq(1, 0, _*), _, _)  => "2.12.15"
       case _                                   => sys.error(s"Unsupported sbt binary version: $sv")
     }
 }
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index 3d398e5bb..d5035cf74 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -4,7 +4,7 @@ import sbt.contraband.ContrabandPlugin.autoImport._
 
 object Dependencies {
   // WARNING: Please Scala update versions in PluginCross.scala too
-  val scala212 = "2.12.14"
+  val scala212 = "2.12.15"
   val scala213 = "2.13.6"
   val checkPluginCross = settingKey[Unit]("Make sure scalaVersion match up")
   val baseScalaVersion = scala212
@@ -116,5 +116,5 @@ object Dependencies {
 
   val hedgehog = "qa.hedgehog" %% "hedgehog-sbt" % "0.6.1"
   val disruptor = "com.lmax" % "disruptor" % "3.4.2"
-  val kindProjector = ("org.typelevel" % "kind-projector" % "0.13.0").cross(CrossVersion.full)
+  val kindProjector = ("org.typelevel" % "kind-projector" % "0.13.2").cross(CrossVersion.full)
 }

From 505492ed332bebfc92508c98378ad968b0ac22ee Mon Sep 17 00:00:00 2001
From: Amina Adewusi <amina.adewusi@guardian.co.uk>
Date: Fri, 17 Sep 2021 18:16:11 +0100
Subject: [PATCH 05/11] Add -Xsource:3 flag

Adding Scala 3 compatible mode for the compilation of build.sbt files.
---
 main/src/main/scala/sbt/Defaults.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala
index 75954a04c..58217442b 100644
--- a/main/src/main/scala/sbt/Defaults.scala
+++ b/main/src/main/scala/sbt/Defaults.scala
@@ -973,7 +973,7 @@ object Defaults extends BuildCommon {
       val old = scalacOptions.value
       if (sbtPlugin.value && VersionNumber(scalaVersion.value)
             .matchesSemVer(SemanticSelector("=2.12 >=2.12.13")))
-        old ++ Seq("-Wconf:cat=unused-nowarn:s")
+        old ++ Seq("-Wconf:cat=unused-nowarn:s", "-Xsource:3")
       else old
     },
     persistJarClasspath :== true,

From 8b9cbb331174cd2759dcc46b37af9c481592f788 Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Sat, 18 Sep 2021 17:37:41 -0400
Subject: [PATCH 06/11] Follow up on Scala 2.12.15 bump

---
 .github/workflows/ci.yml                            |  2 +-
 DEVELOPING.md                                       |  4 ++++
 build.sbt                                           |  1 +
 launcher-package/build.sbt                          |  2 +-
 .../main/scala/sbt/plugins/SemanticdbPlugin.scala   |  2 +-
 .../src/sbt-test/actions/cross-advanced/build.sbt   | 13 +++++++------
 sbt-app/src/sbt-test/actions/cross-advanced/test    |  2 +-
 sbt-app/src/sbt-test/project/sbt-plugin/build.sbt   |  2 +-
 .../project/sbt-plugin/changes/oldSbtPlugin.sbt     |  2 +-
 .../sbt-test/project/semanticdb-version/build.sbt   |  1 +
 sbt-app/src/sbt-test/project/semanticdb/build.sbt   |  2 +-
 .../tests/scala-instance-classloader/build.sbt      |  2 +-
 server-test/src/server-test/response/build.sbt      |  2 +-
 13 files changed, 22 insertions(+), 15 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5ab7e9362..6dfe3956f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -40,7 +40,7 @@ jobs:
     env:
       JAVA_OPTS: -Xms800M -Xmx2G -Xss6M -XX:ReservedCodeCacheSize=128M -server -Dsbt.io.virtual=false -Dfile.encoding=UTF-8
       JVM_OPTS: -Xms800M -Xmx2G -Xss6M -XX:ReservedCodeCacheSize=128M -server -Dsbt.io.virtual=false -Dfile.encoding=UTF-8
-      SCALA_212: 2.12.14
+      SCALA_212: 2.12.15
       SCALA_213: 2.13.6
       UTIL_TESTS: "utilCache/test utilControl/test utilInterface/test utilLogging/test utilPosition/test utilRelation/test utilScripted/test utilTracking/test"
       SBT_LOCAL: false
diff --git a/DEVELOPING.md b/DEVELOPING.md
index 020f81992..8b1db7b09 100644
--- a/DEVELOPING.md
+++ b/DEVELOPING.md
@@ -131,6 +131,10 @@ Listening for transport dt_socket at address: 5005
 Please note that this alternative launcher does _not_ have feature parity with sbt/launcher. (Meta)
 contributions welcome! :-D
 
+### Updating Scala version
+
+See https://github.com/sbt/sbt/pull/6522 for the list of files to change for Scala version upgrade.
+
 ### Diagnosing build failures
 
 Globally included plugins can interfere building `sbt`; if you are getting errors building sbt, try disabling all globally included plugins and try again.
diff --git a/build.sbt b/build.sbt
index 0e6137e5c..399dcd045 100644
--- a/build.sbt
+++ b/build.sbt
@@ -45,6 +45,7 @@ ThisBuild / scmInfo := Some(
 ThisBuild / resolvers += Resolver.mavenLocal
 
 Global / semanticdbEnabled := !(Global / insideCI).value
+// Change main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala too, if you change this.
 Global / semanticdbVersion := "4.4.28"
 val excludeLint = SettingKey[Set[Def.KeyedInitialize[_]]]("excludeLintKeys")
 Global / excludeLint := (Global / excludeLint).?.value.getOrElse(Set.empty)
diff --git a/launcher-package/build.sbt b/launcher-package/build.sbt
index fd12e98cb..dd9e2558c 100755
--- a/launcher-package/build.sbt
+++ b/launcher-package/build.sbt
@@ -26,7 +26,7 @@ lazy val sbtVersionToRelease = sys.props.getOrElse("sbt.build.version", sys.env.
       }))
 
 lazy val scala210 = "2.10.7"
-lazy val scala212 = "2.12.14"
+lazy val scala212 = "2.12.15"
 lazy val scala210Jline = "org.scala-lang" % "jline" % scala210
 lazy val jansi = {
   if (sbtVersionToRelease startsWith "1.") "org.fusesource.jansi" % "jansi" % "1.12"
diff --git a/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala b/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala
index a10f49725..76b9c8f1b 100644
--- a/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala
+++ b/main/src/main/scala/sbt/plugins/SemanticdbPlugin.scala
@@ -26,7 +26,7 @@ object SemanticdbPlugin extends AutoPlugin {
     semanticdbEnabled := SysProp.semanticdb,
     semanticdbIncludeInJar := false,
     semanticdbOptions := List(),
-    semanticdbVersion := "4.4.20"
+    semanticdbVersion := "4.4.28"
   )
 
   override lazy val projectSettings: Seq[Def.Setting[_]] = Seq(
diff --git a/sbt-app/src/sbt-test/actions/cross-advanced/build.sbt b/sbt-app/src/sbt-test/actions/cross-advanced/build.sbt
index c4e16f6ef..a77d7c0dd 100644
--- a/sbt-app/src/sbt-test/actions/cross-advanced/build.sbt
+++ b/sbt-app/src/sbt-test/actions/cross-advanced/build.sbt
@@ -1,5 +1,6 @@
 lazy val check = taskKey[Unit]("")
 lazy val compile2 = taskKey[Unit]("")
+lazy val scala212 = "2.12.15"
 
 lazy val root = (project in file("."))
   .aggregate(foo, bar, client)
@@ -10,19 +11,19 @@ lazy val root = (project in file("."))
 
 lazy val foo = project
   .settings(
-    crossScalaVersions := Seq("2.12.14", "2.13.1"),
+    crossScalaVersions := Seq(scala212, "2.13.1"),
     libraryDependencies += "org.scalatest" %% "scalatest" % "3.1.0",
 
     check := {
       // This tests that +check will respect bar's crossScalaVersions and not switch
       val x = (LocalProject("bar") / scalaVersion).value
-      assert(x == "2.12.14", s"$x == 2.12.12")
+      assert(x == scala212, s"$x == $scala212")
       (Compile / compile).value
     },
     (Test / testOnly) := {
       // This tests that +testOnly will respect bar's crossScalaVersions and not switch
       val x = (LocalProject("bar") / scalaVersion).value
-      assert(x == "2.12.14", s"$x == 2.12.12")
+      assert(x == scala212, s"$x == $scala212")
       val _ = (Test / testOnly).evaluated
     },
     compile2 := {
@@ -35,7 +36,7 @@ lazy val foo = project
 
 lazy val bar = project
   .settings(
-    crossScalaVersions := Seq("2.12.14"),
+    crossScalaVersions := Seq(scala212),
     check := (Compile / compile).value,
     compile2 := (Compile / compile).value,
   )
@@ -46,14 +47,14 @@ lazy val baz = project
     check := {
       // This tests that +baz/check will respect bar's crossScalaVersions and not switch
       val x = (LocalProject("bar") / scalaVersion).value
-      assert(x == "2.12.14", s"$x == 2.12.14")
+      assert(x == scala212, s"$x == $scala212")
       (Compile / compile).value
     },
   )
 
 lazy val client = project
   .settings(
-    crossScalaVersions := Seq("2.12.14", "2.13.1"),
+    crossScalaVersions := Seq(scala212, "2.13.1"),
     check := (Compile / compile).value,
     compile2 := (Compile / compile).value,
   )
diff --git a/sbt-app/src/sbt-test/actions/cross-advanced/test b/sbt-app/src/sbt-test/actions/cross-advanced/test
index 6f606cd4a..5b3ab9f3b 100644
--- a/sbt-app/src/sbt-test/actions/cross-advanced/test
+++ b/sbt-app/src/sbt-test/actions/cross-advanced/test
@@ -17,7 +17,7 @@
 ## test + with command or alias
 > clean
 ## for command cross building you do need crossScalaVerions on root
-> set root/crossScalaVersions := Seq("2.12.14", "2.13.1")
+> set root/crossScalaVersions := Seq("2.12.15", "2.13.1")
 > + build
 $ exists foo/target/scala-2.12
 $ exists foo/target/scala-2.13
diff --git a/sbt-app/src/sbt-test/project/sbt-plugin/build.sbt b/sbt-app/src/sbt-test/project/sbt-plugin/build.sbt
index ae7ce14e9..bb26b40e0 100644
--- a/sbt-app/src/sbt-test/project/sbt-plugin/build.sbt
+++ b/sbt-app/src/sbt-test/project/sbt-plugin/build.sbt
@@ -1,6 +1,6 @@
 lazy val root = project.in(file("."))
   .enablePlugins(SbtPlugin)
   .settings(
-    scalaVersion := "2.12.14",
+    scalaVersion := "2.12.15",
     scalacOptions ++= Seq("-Xfatal-warnings", "-Xlint")
   )
diff --git a/sbt-app/src/sbt-test/project/sbt-plugin/changes/oldSbtPlugin.sbt b/sbt-app/src/sbt-test/project/sbt-plugin/changes/oldSbtPlugin.sbt
index 063ee25e5..ce0acfbe0 100644
--- a/sbt-app/src/sbt-test/project/sbt-plugin/changes/oldSbtPlugin.sbt
+++ b/sbt-app/src/sbt-test/project/sbt-plugin/changes/oldSbtPlugin.sbt
@@ -1,6 +1,6 @@
 lazy val root = project.in(file("."))
   .settings(
-    scalaVersion := "2.12.14",
+    scalaVersion := "2.12.15",
     sbtPlugin := true,
     scalacOptions ++= Seq("-Xfatal-warnings", "-Xlint")
   )
diff --git a/sbt-app/src/sbt-test/project/semanticdb-version/build.sbt b/sbt-app/src/sbt-test/project/semanticdb-version/build.sbt
index 0600aa8dd..fa2845eb9 100644
--- a/sbt-app/src/sbt-test/project/semanticdb-version/build.sbt
+++ b/sbt-app/src/sbt-test/project/semanticdb-version/build.sbt
@@ -1,3 +1,4 @@
+// Don't have to upgrade this while updating 2.12
 ThisBuild / scalaVersion := "2.12.14"
 ThisBuild / semanticdbEnabled := true
 ThisBuild / semanticdbVersion := "4.4.20"
diff --git a/sbt-app/src/sbt-test/project/semanticdb/build.sbt b/sbt-app/src/sbt-test/project/semanticdb/build.sbt
index fc07b3748..3a76b7064 100644
--- a/sbt-app/src/sbt-test/project/semanticdb/build.sbt
+++ b/sbt-app/src/sbt-test/project/semanticdb/build.sbt
@@ -1,4 +1,4 @@
-ThisBuild / scalaVersion := "2.12.12"
+ThisBuild / scalaVersion := "2.12.15"
 ThisBuild / semanticdbEnabled := true
 ThisBuild / semanticdbIncludeInJar := true
 
diff --git a/sbt-app/src/sbt-test/tests/scala-instance-classloader/build.sbt b/sbt-app/src/sbt-test/tests/scala-instance-classloader/build.sbt
index 3ed61dad2..b099f2338 100644
--- a/sbt-app/src/sbt-test/tests/scala-instance-classloader/build.sbt
+++ b/sbt-app/src/sbt-test/tests/scala-instance-classloader/build.sbt
@@ -3,7 +3,7 @@ import sbt.internal.inc.ScalaInstance
 lazy val OtherScala = config("other-scala").hide
 lazy val junitinterface = "com.novocode" % "junit-interface" % "0.11"
 lazy val akkaActor = "com.typesafe.akka" %% "akka-actor" % "2.5.17"
-ThisBuild / scalaVersion := "2.12.14"
+ThisBuild / scalaVersion := "2.12.15"
 
 lazy val root = (project in file("."))
   .configs(OtherScala)
diff --git a/server-test/src/server-test/response/build.sbt b/server-test/src/server-test/response/build.sbt
index 105e64e77..1f18c7ab3 100644
--- a/server-test/src/server-test/response/build.sbt
+++ b/server-test/src/server-test/response/build.sbt
@@ -1,6 +1,6 @@
 import sbt.internal.server.{ ServerHandler, ServerIntent }
 
-ThisBuild / scalaVersion := "2.12.14"
+ThisBuild / scalaVersion := "2.12.15"
 
 Global / serverLog / logLevel := Level.Debug
 // custom handler

From 656409097605f565022bc6369e7a7cb29e4912be Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Sat, 18 Sep 2021 18:21:55 -0400
Subject: [PATCH 07/11] Increase timeout for progress test

---
 server-test/src/test/scala/testpkg/BuildServerTest.scala | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/server-test/src/test/scala/testpkg/BuildServerTest.scala b/server-test/src/test/scala/testpkg/BuildServerTest.scala
index c485373f4..47aad7b31 100644
--- a/server-test/src/test/scala/testpkg/BuildServerTest.scala
+++ b/server-test/src/test/scala/testpkg/BuildServerTest.scala
@@ -102,22 +102,23 @@ object BuildServerTest extends AbstractServerTest {
          |} }""".stripMargin
     )
 
-    assert(svr.waitForString(10.seconds) { s =>
+    // This doesn't always come back in 10s on CI.
+    assert(svr.waitForString(60.seconds) { s =>
       s.contains("build/taskStart") &&
       s.contains(""""message":"Compiling runAndTest"""")
     })
 
-    assert(svr.waitForString(10.seconds) { s =>
+    assert(svr.waitForString(60.seconds) { s =>
       s.contains("build/taskProgress") &&
       s.contains(""""message":"Compiling runAndTest (15%)"""")
     })
 
-    assert(svr.waitForString(10.seconds) { s =>
+    assert(svr.waitForString(60.seconds) { s =>
       s.contains("build/taskProgress") &&
       s.contains(""""message":"Compiling runAndTest (100%)"""")
     })
 
-    assert(svr.waitForString(10.seconds) { s =>
+    assert(svr.waitForString(60.seconds) { s =>
       s.contains("build/taskFinish") &&
       s.contains(""""message":"Compiled runAndTest"""")
     })

From 04672d3118a5e1509db879b1c7812e60ff6e20c2 Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Sun, 19 Sep 2021 01:47:24 -0400
Subject: [PATCH 08/11] Mark failing scripted tests pending

---
 .../src/sbt-test/classloader-cache/spark/{test => disabled}   | 0
 sbt-app/src/sbt-test/compiler-project/run-test/build.sbt      | 2 +-
 .../sbt-test/dependency-graph/ignoreScalaLibrary/build.sbt    | 2 +-
 .../dependency-graph/ignoreScalaLibrary/{test => pending}     | 0
 sbt-app/src/sbt-test/dependency-graph/toFileSubTask/build.sbt | 2 +-
 .../sbt-test/dependency-graph/toFileSubTask/{test => pending} | 0
 sbt-app/src/sbt-test/project/unified/build.sbt                | 4 ++--
 7 files changed, 5 insertions(+), 5 deletions(-)
 rename sbt-app/src/sbt-test/classloader-cache/spark/{test => disabled} (100%)
 rename sbt-app/src/sbt-test/dependency-graph/ignoreScalaLibrary/{test => pending} (100%)
 rename sbt-app/src/sbt-test/dependency-graph/toFileSubTask/{test => pending} (100%)

diff --git a/sbt-app/src/sbt-test/classloader-cache/spark/test b/sbt-app/src/sbt-test/classloader-cache/spark/disabled
similarity index 100%
rename from sbt-app/src/sbt-test/classloader-cache/spark/test
rename to sbt-app/src/sbt-test/classloader-cache/spark/disabled
diff --git a/sbt-app/src/sbt-test/compiler-project/run-test/build.sbt b/sbt-app/src/sbt-test/compiler-project/run-test/build.sbt
index af714fb9e..09ac3d406 100644
--- a/sbt-app/src/sbt-test/compiler-project/run-test/build.sbt
+++ b/sbt-app/src/sbt-test/compiler-project/run-test/build.sbt
@@ -1,4 +1,4 @@
-scalaVersion in ThisBuild := "2.12.3"
+ThisBuild / scalaVersion := "2.12.15"
 
 libraryDependencies ++= Seq(
 	"com.novocode" % "junit-interface" % "0.5" % Test,
diff --git a/sbt-app/src/sbt-test/dependency-graph/ignoreScalaLibrary/build.sbt b/sbt-app/src/sbt-test/dependency-graph/ignoreScalaLibrary/build.sbt
index 7e9f4cce2..b2aec7b01 100644
--- a/sbt-app/src/sbt-test/dependency-graph/ignoreScalaLibrary/build.sbt
+++ b/sbt-app/src/sbt-test/dependency-graph/ignoreScalaLibrary/build.sbt
@@ -1,4 +1,4 @@
-scalaVersion := "2.9.2"
+ThisBuild / scalaVersion := "2.12.15"
 
 libraryDependencies ++= Seq(
   "org.slf4j" % "slf4j-api" % "1.7.2",
diff --git a/sbt-app/src/sbt-test/dependency-graph/ignoreScalaLibrary/test b/sbt-app/src/sbt-test/dependency-graph/ignoreScalaLibrary/pending
similarity index 100%
rename from sbt-app/src/sbt-test/dependency-graph/ignoreScalaLibrary/test
rename to sbt-app/src/sbt-test/dependency-graph/ignoreScalaLibrary/pending
diff --git a/sbt-app/src/sbt-test/dependency-graph/toFileSubTask/build.sbt b/sbt-app/src/sbt-test/dependency-graph/toFileSubTask/build.sbt
index 6b66e7321..f830ec558 100644
--- a/sbt-app/src/sbt-test/dependency-graph/toFileSubTask/build.sbt
+++ b/sbt-app/src/sbt-test/dependency-graph/toFileSubTask/build.sbt
@@ -1,5 +1,5 @@
 // ThisBuild / useCoursier := false
-ThisBuild / scalaVersion := "2.12.6"
+ThisBuild / scalaVersion := "2.12.15"
 ThisBuild / organization := "org.example"
 ThisBuild / version := "0.1"
 
diff --git a/sbt-app/src/sbt-test/dependency-graph/toFileSubTask/test b/sbt-app/src/sbt-test/dependency-graph/toFileSubTask/pending
similarity index 100%
rename from sbt-app/src/sbt-test/dependency-graph/toFileSubTask/test
rename to sbt-app/src/sbt-test/dependency-graph/toFileSubTask/pending
diff --git a/sbt-app/src/sbt-test/project/unified/build.sbt b/sbt-app/src/sbt-test/project/unified/build.sbt
index fd6471758..11d0eb84e 100644
--- a/sbt-app/src/sbt-test/project/unified/build.sbt
+++ b/sbt-app/src/sbt-test/project/unified/build.sbt
@@ -1,3 +1,5 @@
+ThisBuild / scalaVersion := "2.12.15"
+
 import sbt.internal.CommandStrings.{ inspectBrief, inspectDetailed }
 import sbt.internal.Inspect
 import sjsonnew._, BasicJsonProtocol._
@@ -11,8 +13,6 @@ val buildInfo = taskKey[Seq[File]]("The task that generates the build info.")
 
 lazy val root = (project in file("."))
   .settings(
-    Global / cancelable := true,
-    ThisBuild / scalaVersion := "2.12.3",
     console / scalacOptions += "-deprecation",
     Compile / console / scalacOptions += "-Ywarn-numeric-widen",
     projA / Compile / console / scalacOptions += "-feature",

From 0413727796adebdb25d9fdf70ea038723f354ee6 Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Sun, 19 Sep 2021 01:16:45 -0400
Subject: [PATCH 09/11] Drop TrapExit

Fixes https://github.com/sbt/sbt/issues/6558

Problem
-------
sbt uses SecurityManager feature of JDK to trap `sys.exit` call during
`run`-like tasks, since we emulate `run` and `console` as function calls.
JDK 17 deprecated SecurityManager and it's printing warnings.

Solution
--------
About 10 years go, `exit` was a convenient way of quitting both Scala
REPL and sbt shell. Scala 2.11 broke this by removing the `Predef.exit`.
We still need to worry about `run` potentially calling `sys.exit`
but that can be handled using fork feature.
In the long-run, it probably is better to be JDK 17 compatible.
---
 build.sbt                                     |   3 +
 main-actions/src/main/scala/sbt/Console.scala |   2 +-
 main/src/main/scala/sbt/Keys.scala            |   2 +-
 main/src/main/scala/sbt/Main.scala            |  21 +-
 run/src/main/scala/sbt/Run.scala              |  16 +-
 run/src/main/scala/sbt/TrapExit.scala         | 502 +-----------------
 .../package-private/{test => pending}         |   0
 .../src/sbt-test/run/error/{test => disabled} |   0
 .../src/sbt-test/run/fork/{test => disabled}  |   0
 .../src/test/scala/testpkg/EventsTest.scala   |  31 +-
 10 files changed, 41 insertions(+), 536 deletions(-)
 rename sbt-app/src/sbt-test/classloader-cache/package-private/{test => pending} (100%)
 rename sbt-app/src/sbt-test/run/error/{test => disabled} (100%)
 rename sbt-app/src/sbt-test/run/fork/{test => disabled} (100%)

diff --git a/build.sbt b/build.sbt
index 399dcd045..d5f8ac88f 100644
--- a/build.sbt
+++ b/build.sbt
@@ -598,6 +598,9 @@ lazy val runProj = (project in file("run"))
       exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#CustomOutput.copy$default$*"),
       exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#LoggedOutput.copy"),
       exclude[DirectMissingMethodProblem]("sbt.OutputStrategy#LoggedOutput.copy$default$*"),
+      exclude[Problem]("sbt.TrapExit*"),
+      exclude[MissingClassProblem]("sbt.ExitCode"), // private
+      exclude[MissingClassProblem]("sbt.LoggingExceptionHandler"), // private
     )
   )
   .configure(addSbtIO, addSbtCompilerClasspath)
diff --git a/main-actions/src/main/scala/sbt/Console.scala b/main-actions/src/main/scala/sbt/Console.scala
index a40c12a27..c46fde5a2 100644
--- a/main-actions/src/main/scala/sbt/Console.scala
+++ b/main-actions/src/main/scala/sbt/Console.scala
@@ -71,7 +71,7 @@ final class Console(compiler: AnalyzingCompiler) {
       terminal.withRawOutput {
         jline.TerminalFactory.set(terminal.toJLine)
         DeprecatedJLine.setTerminalOverride(jline3term)
-        terminal.withRawInput(Run.executeTrapExit(console0, log))
+        terminal.withRawInput(Run.executeSuccess(console0))
       }
     } finally {
       sys.props("scala.color") = previous
diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala
index 4883a5f5f..30c558009 100644
--- a/main/src/main/scala/sbt/Keys.scala
+++ b/main/src/main/scala/sbt/Keys.scala
@@ -281,7 +281,7 @@ object Keys {
   val runMain = inputKey[Unit]("Runs the main class selected by the first argument, passing the remaining arguments to the main method.").withRank(ATask)
   val discoveredMainClasses = taskKey[Seq[String]]("Auto-detects main classes.").withRank(BMinusTask)
   val runner = taskKey[ScalaRun]("Implementation used to run a main class.").withRank(DTask)
-  val trapExit = settingKey[Boolean]("If true, enables exit trapping and thread management for 'run'-like tasks.  This is currently only suitable for serially-executed 'run'-like tasks.").withRank(CSetting)
+  val trapExit = settingKey[Boolean]("If true, enables exit trapping and thread management for 'run'-like tasks. This was removed in sbt 1.6.0 due to JDK 17 deprecating Security Manager.").withRank(CSetting)
 
   val fork = settingKey[Boolean]("If true, forks a new JVM when running.  If false, runs in the same JVM as the build.").withRank(ASetting)
   val forkOptions = taskKey[ForkOptions]("Configures JVM forking.").withRank(DSetting)
diff --git a/main/src/main/scala/sbt/Main.scala b/main/src/main/scala/sbt/Main.scala
index ab92c37d2..6bb147f7d 100644
--- a/main/src/main/scala/sbt/Main.scala
+++ b/main/src/main/scala/sbt/Main.scala
@@ -210,21 +210,16 @@ object StandardMain {
 
   private[this] val isShutdown = new AtomicBoolean(false)
   def runManaged(s: State): xsbti.MainResult = {
-    val previous = TrapExit.installManager()
+    val hook = ShutdownHooks.add(closeRunnable)
     try {
-      val hook = ShutdownHooks.add(closeRunnable)
-      try {
-        MainLoop.runLogged(s)
-      } catch {
-        case _: InterruptedException if isShutdown.get =>
-          new xsbti.Exit { override def code(): Int = 0 }
-      } finally {
-        try DefaultBackgroundJobService.shutdown()
-        finally hook.close()
-        ()
-      }
+      MainLoop.runLogged(s)
+    } catch {
+      case _: InterruptedException if isShutdown.get =>
+        new xsbti.Exit { override def code(): Int = 0 }
     } finally {
-      TrapExit.uninstallManager(previous)
+      try DefaultBackgroundJobService.shutdown()
+      finally hook.close()
+      ()
     }
   }
 
diff --git a/run/src/main/scala/sbt/Run.scala b/run/src/main/scala/sbt/Run.scala
index 5d5e9307f..4df43f707 100644
--- a/run/src/main/scala/sbt/Run.scala
+++ b/run/src/main/scala/sbt/Run.scala
@@ -58,6 +58,7 @@ class ForkRun(config: ForkOptions) extends ScalaRun {
   private def classpathOption(classpath: Seq[File]) =
     "-classpath" :: Path.makeString(classpath) :: Nil
 }
+
 class Run(private[sbt] val newLoader: Seq[File] => ClassLoader, trapExit: Boolean)
     extends ScalaRun {
   def this(instance: ScalaInstance, trapExit: Boolean, nativeTmp: File) =
@@ -105,9 +106,8 @@ class Run(private[sbt] val newLoader: Seq[File] => ClassLoader, trapExit: Boolea
           // log.trace(e)
           throw e
       }
-    // try { execute(); None } catch { case e: Exception => log.trace(e); Some(e.toString) }
 
-    if (trapExit) Run.executeTrapExit(execute(), log)
+    if (trapExit) Run.executeSuccess(execute())
     else directExecute()
   }
 
@@ -169,12 +169,12 @@ object Run {
     runner.run(mainClass, classpath, options, log)
 
   /** Executes the given function, trapping calls to System.exit. */
-  def executeTrapExit(f: => Unit, log: Logger): Try[Unit] = {
-    val exitCode = TrapExit(f, log)
-    if (exitCode == 0) {
-      log.debug("Exited with code 0")
-      Success(())
-    } else Failure(new MessageOnlyException("Nonzero exit code: " + exitCode))
+  @deprecated("TrapExit feature is removed; just call the function instead", "1.6.0")
+  def executeTrapExit(f: => Unit, log: Logger): Try[Unit] = executeSuccess(f)
+
+  private[sbt] def executeSuccess(f: => Unit): Try[Unit] = {
+    f
+    Success(())
   }
 
   // quotes the option that includes a whitespace
diff --git a/run/src/main/scala/sbt/TrapExit.scala b/run/src/main/scala/sbt/TrapExit.scala
index 2e53ed2c4..8a63bbd10 100644
--- a/run/src/main/scala/sbt/TrapExit.scala
+++ b/run/src/main/scala/sbt/TrapExit.scala
@@ -7,20 +7,7 @@
 
 package sbt
 
-import scala.annotation.nowarn
-import scala.reflect.Manifest
-import scala.collection.concurrent.TrieMap
-import java.lang.ref.WeakReference
-import Thread.currentThread
-import java.security.Permission
-import java.util.concurrent.{ ConcurrentHashMap => CMap }
-import java.lang.Integer.{ toHexString => hex }
-import java.util.function.Supplier
-
 import sbt.util.Logger
-import sbt.util.InterfaceUtil
-import sbt.internal.util.Util.{ AnyOps, none }
-import TrapExit._
 
 /**
  * Provides an approximation to isolated execution within a single JVM.
@@ -33,32 +20,27 @@ import TrapExit._
  * do not terminate, or if concurrent AWT applications are run.
  * This category of code should only be called by forking a new JVM.
  */
-@nowarn
 object TrapExit {
 
   /**
    * Run `execute` in a managed context, using `log` for debugging messages.
    * `installManager` must be called before calling this method.
    */
+  @deprecated("TrapExit feature is removed; just call the function instead", "1.6.0")
   def apply(execute: => Unit, log: Logger): Int =
-    System.getSecurityManager match {
-      case m: TrapExit => m.runManaged(InterfaceUtil.toSupplier(execute), log)
-      case _           => runUnmanaged(execute, log)
-    }
+    runUnmanaged(execute, log)
 
   /**
    * Installs the SecurityManager that implements the isolation and returns the previously installed SecurityManager, which may be null.
    * This method must be called before using `apply`.
    */
-  def installManager(): SecurityManager =
-    System.getSecurityManager match {
-      case m: TrapExit => m
-      case m           => System.setSecurityManager(new TrapExit(m)); m
-    }
+  @deprecated("TrapExit feature is removed; just call the function instead", "1.6.0")
+  def installManager(): Nothing =
+    sys.error("TrapExit feature is removed due to JDK 17 deprecating SecurityManager")
 
   /** Uninstalls the isolation SecurityManager and restores the old security manager. */
-  def uninstallManager(previous: SecurityManager): Unit =
-    System.setSecurityManager(previous)
+  @deprecated("TrapExit feature is removed; just call the function instead", "1.6.0")
+  def uninstallManager(previous: Any): Unit = ()
 
   private[this] def runUnmanaged(execute: => Unit, log: Logger): Int = {
     log.warn("Managed execution not possible: security manager not installed.")
@@ -71,474 +53,4 @@ object TrapExit {
         1
     }
   }
-
-  private type ThreadID = String
-
-  /** `true` if the thread `t` is in the TERMINATED state.x*/
-  private def isDone(t: Thread): Boolean = t.getState == Thread.State.TERMINATED
-
-  private def computeID(g: ThreadGroup): ThreadID =
-    s"g:${hex(System.identityHashCode(g))}:${g.getName}"
-
-  /** Computes an identifier for a Thread that has a high probability of being unique within a single JVM execution. */
-  private def computeID(t: Thread): ThreadID =
-    // can't use t.getId because when getAccess first sees a Thread, it hasn't been initialized yet
-    // can't use t.getName because calling it on AWT thread in certain circumstances generates a segfault (#997):
-    //    Apple AWT: +[ThreadUtilities getJNIEnvUncached] attempting to attach current thread after JNFObtainEnv() failed
-    s"${hex(System.identityHashCode(t))}"
-
-  /** Waits for the given `thread` to terminate.  However, if the thread state is NEW, this method returns immediately. */
-  private def waitOnThread(thread: Thread, log: Logger): Unit = {
-    log.debug("Waiting for thread " + thread.getName + " to terminate.")
-    thread.join
-    log.debug("\tThread " + thread.getName + " exited.")
-  }
-
-  // interrupts the given thread, but first replaces the exception handler so that the InterruptedException is not printed
-  private def safeInterrupt(thread: Thread, log: Logger): Unit = {
-    log.debug("Interrupting thread " + thread.getName)
-    thread.setUncaughtExceptionHandler(new TrapInterrupt(thread.getUncaughtExceptionHandler))
-    thread.interrupt
-    log.debug("\tInterrupted " + thread.getName)
-  }
-  // an uncaught exception handler that swallows InterruptedExceptions and otherwise defers to originalHandler
-  private final class TrapInterrupt(originalHandler: Thread.UncaughtExceptionHandler)
-      extends Thread.UncaughtExceptionHandler {
-    def uncaughtException(thread: Thread, e: Throwable): Unit = {
-      withCause[InterruptedException, Unit](e) { interrupted =>
-        ()
-      } { other =>
-        originalHandler.uncaughtException(thread, e)
-      }
-      thread.setUncaughtExceptionHandler(originalHandler)
-    }
-  }
-
-  /**
-   * Recurses into the causes of the given exception looking for a cause of type CauseType.  If one is found, `withType` is called with that cause.
-   *  If not, `notType` is called with the root cause.
-   */
-  private def withCause[CauseType <: Throwable, T](
-      e: Throwable
-  )(withType: CauseType => T)(notType: Throwable => T)(implicit mf: Manifest[CauseType]): T = {
-    val clazz = mf.runtimeClass
-    if (clazz.isInstance(e))
-      withType(e.asInstanceOf[CauseType])
-    else {
-      val cause = e.getCause
-      if (cause == null)
-        notType(e)
-      else
-        withCause(cause)(withType)(notType)(mf)
-    }
-  }
-
-}
-
-/**
- * Simulates isolation via a SecurityManager.
- * Multiple applications are supported by tracking Thread constructions via `checkAccess`.
- * The Thread that constructed each Thread is used to map a new Thread to an application.
- * This is not reliable on all jvms, so ThreadGroup creations are also tracked via
- * `checkAccess` and traversed on demand to collect threads.
- * This association of Threads with an application allows properly waiting for
- * non-daemon threads to terminate or to interrupt the correct threads when terminating.
- * It also allows disposing AWT windows if the application created any.
- * Only one AWT application is supported at a time, however.
- */
-@nowarn
-private final class TrapExit(delegateManager: SecurityManager) extends SecurityManager {
-
-  /** Tracks the number of running applications in order to short-cut SecurityManager checks when no applications are active.*/
-  private[this] val running = new java.util.concurrent.atomic.AtomicInteger
-
-  /** Maps a thread or thread group to its originating application.  The thread is represented by a unique identifier to avoid leaks. */
-  private[this] val threadToApp = new CMap[ThreadID, App]
-
-  /** Executes `f` in a managed context. */
-  def runManaged(f: Supplier[Unit], xlog: xsbti.Logger): Int = {
-    val _ = running.incrementAndGet()
-    try runManaged0(f, xlog)
-    finally {
-      running.decrementAndGet(); ()
-    }
-  }
-  private[this] def runManaged0(f: Supplier[Unit], xlog: xsbti.Logger): Int = {
-    val log: Logger = xlog
-    val app = new App(f, log)
-    val executionThread = app.mainThread
-    try {
-      executionThread.start() // thread actually evaluating `f`
-      finish(app, log)
-    } catch {
-      case _: InterruptedException => // here, the thread that started the run has been interrupted, not the main thread of the executing code
-        cancel(executionThread, app, log)
-    } finally app.cleanup()
-  }
-
-  /** Interrupt all threads and indicate failure in the exit code. */
-  private[this] def cancel(executionThread: Thread, app: App, log: Logger): Int = {
-    log.warn("Run canceled.")
-    executionThread.interrupt()
-    stopAllThreads(app)
-    1
-  }
-
-  /**
-   * Wait for all non-daemon threads for `app` to exit, for an exception to be thrown in the main thread,
-   * or for `System.exit` to be called in a thread started by `app`.
-   */
-  private[this] def finish(app: App, log: Logger): Int = {
-    log.debug("Waiting for threads to exit or System.exit to be called.")
-    waitForExit(app)
-    log.debug("Interrupting remaining threads (should be all daemons).")
-    stopAllThreads(app) // should only be daemon threads left now
-    log.debug("Sandboxed run complete..")
-    app.exitCode.value.getOrElse(0)
-  }
-
-  // wait for all non-daemon threads to terminate
-  private[this] def waitForExit(app: App): Unit = {
-    var daemonsOnly = true
-    app.processThreads { thread =>
-      // check isAlive because calling `join` on a thread that hasn't started returns immediately
-      //  and App will only remove threads that have terminated, which will make this method loop continuously
-      //  if a thread is created but not started
-      if (thread.isAlive && !thread.isDaemon) {
-        daemonsOnly = false
-        waitOnThread(thread, app.log)
-      }
-    }
-    // processThreads takes a snapshot of the threads at a given moment, so if there were only daemons, the application should shut down
-    if (!daemonsOnly)
-      waitForExit(app)
-  }
-
-  /** Gives managed applications a unique ID to use in the IDs of the main thread and thread group. */
-  private[this] val nextAppID = new java.util.concurrent.atomic.AtomicLong
-  private def nextID(): String = nextAppID.getAndIncrement.toHexString
-
-  /**
-   * Represents an isolated application as simulated by [[TrapExit]].
-   * `execute` is the application code to evaluate.
-   * `log` is used for debug logging.
-   */
-  private final class App(val execute: Supplier[Unit], val log: Logger) extends Runnable {
-
-    /**
-     * Tracks threads and groups created by this application.
-     * To avoid leaks, keys are a unique identifier and values are held via WeakReference.
-     * A TrieMap supports the necessary concurrent updates and snapshots.
-     */
-    private[this] val threads = new TrieMap[ThreadID, WeakReference[Thread]]
-    private[this] val groups = new TrieMap[ThreadID, WeakReference[ThreadGroup]]
-
-    /** Tracks whether AWT has ever been used in this jvm execution. */
-    @volatile
-    var awtUsed = false
-
-    /** The unique ID of the application. */
-    val id = nextID()
-
-    /** The ThreadGroup to use to try to track created threads. */
-    val mainGroup: ThreadGroup = new ThreadGroup("run-main-group-" + id) {
-      private[this] val handler = new LoggingExceptionHandler(log, None)
-      override def uncaughtException(t: Thread, e: Throwable): Unit =
-        handler.uncaughtException(t, e)
-    }
-    val mainThread = new Thread(mainGroup, this, "run-main-" + id)
-
-    /** Saves the ids of the creating thread and thread group to avoid tracking them as coming from this application. */
-    val creatorThreadID = computeID(currentThread)
-    val creatorGroup = currentThread.getThreadGroup
-
-    register(mainThread)
-    register(mainGroup)
-
-    val exitCode = new ExitCode
-
-    def run(): Unit = {
-      try execute.get()
-      catch {
-        case x: Throwable =>
-          exitCode.set(1) //exceptions in the main thread cause the exit code to be 1
-          throw x
-      }
-    }
-
-    /** Records a new group both in the global [[TrapExit]] manager and for this [[App]].*/
-    def register(g: ThreadGroup): Unit =
-      if (g != null && g != creatorGroup && !isSystemGroup(g)) {
-        val groupID = computeID(g)
-        val old = groups.putIfAbsent(groupID, new WeakReference(g))
-        if (old.isEmpty) { // wasn't registered
-          threadToApp.put(groupID, this)
-          ()
-        }
-      }
-
-    /**
-     * Records a new thread both in the global [[TrapExit]] manager and for this [[App]].
-     * Its uncaught exception handler is configured to log exceptions through `log`.
-     */
-    def register(t: Thread): Unit = {
-      val threadID = computeID(t)
-      if (!isDone(t) && threadID != creatorThreadID) {
-        val old = threads.putIfAbsent(threadID, new WeakReference(t))
-        if (old.isEmpty) { // wasn't registered
-          threadToApp.put(threadID, this)
-          setExceptionHandler(t)
-          if (!awtUsed && isEventQueue(t))
-            awtUsed = true
-        }
-      }
-    }
-
-    /** Registers the logging exception handler on `t`, delegating to the existing handler if it isn't the default. */
-    private[this] def setExceptionHandler(t: Thread): Unit = {
-      val group = t.getThreadGroup
-      val previousHandler = t.getUncaughtExceptionHandler match {
-        case null | `group` | (_: LoggingExceptionHandler) => none[Thread.UncaughtExceptionHandler]
-        case x                                             => x.some // delegate to a custom handler only
-      }
-      t.setUncaughtExceptionHandler(new LoggingExceptionHandler(log, previousHandler))
-    }
-
-    /** Removes a thread or group from this [[App]] and the global [[TrapExit]] manager. */
-    private[this] def unregister(id: ThreadID): Unit = {
-      threadToApp.remove(id)
-      threads.remove(id)
-      groups.remove(id)
-      ()
-    }
-
-    /** Final cleanup for this application after it has terminated. */
-    def cleanup(): Unit = {
-      cleanup(threads)
-      cleanup(groups)
-    }
-    private[this] def cleanup(resources: TrieMap[ThreadID, _]): Unit = {
-      val snap = resources.readOnlySnapshot
-      resources.clear()
-      for ((id, _) <- snap)
-        unregister(id)
-    }
-
-    // only want to operate on unterminated threads
-    // want to drop terminated threads, including those that have been gc'd
-    /** Evaluates `f` on each `Thread` started by this [[App]] at single instant shortly after this method is called. */
-    def processThreads(f: Thread => Unit): Unit = {
-      // pulls in threads that weren't recorded by checkAccess(Thread) (which is jvm-dependent)
-      //  but can be reached via the Threads in the ThreadGroups recorded by checkAccess(ThreadGroup) (not jvm-dependent)
-      addUntrackedThreads()
-
-      val snap = threads.readOnlySnapshot
-      for ((id, tref) <- snap) {
-        val t = tref.get
-        if ((t eq null) || isDone(t))
-          unregister(id)
-        else {
-          f(t)
-          if (isDone(t))
-            unregister(id)
-        }
-      }
-    }
-
-    // registers Threads from the tracked ThreadGroups
-    private[this] def addUntrackedThreads(): Unit =
-      groupThreadsSnapshot foreach register
-
-    private[this] def groupThreadsSnapshot: Seq[Thread] = {
-      val snap = groups.readOnlySnapshot.values.map(_.get).filter(_ != null)
-      threadsInGroups(snap.toList, Nil)
-    }
-
-    // takes a snapshot of the threads in `toProcess`, acquiring nested locks on each group to do so
-    // the thread groups are accumulated in `accum` and then the threads in each are collected all at
-    // once while they are all locked.  This is the closest thing to a snapshot that can be accomplished.
-    private[this] def threadsInGroups(
-        toProcess: List[ThreadGroup],
-        accum: List[ThreadGroup]
-    ): List[Thread] = toProcess match {
-      case group :: tail =>
-        // ThreadGroup implementation synchronizes on its methods, so by synchronizing here, we can workaround its quirks somewhat
-        group.synchronized {
-          // not tail recursive because of synchronized
-          threadsInGroups(threadGroups(group) ::: tail, group :: accum)
-        }
-      case Nil => accum.flatMap(threads)
-    }
-
-    // gets the immediate child ThreadGroups of `group`
-    private[this] def threadGroups(group: ThreadGroup): List[ThreadGroup] = {
-      val upperBound = group.activeGroupCount
-      val groups = new Array[ThreadGroup](upperBound)
-      val childrenCount = group.enumerate(groups, false)
-      groups.take(childrenCount).toList
-    }
-
-    // gets the immediate child Threads of `group`
-    private[this] def threads(group: ThreadGroup): List[Thread] = {
-      val upperBound = group.activeCount
-      val threads = new Array[Thread](upperBound)
-      val childrenCount = group.enumerate(threads, false)
-      threads.take(childrenCount).toList
-    }
-  }
-
-  private[this] def stopAllThreads(app: App): Unit = {
-    // only try to dispose frames if we think the App used AWT
-    // otherwise, we initialize AWT as a side effect of asking for the frames
-    // also, we only assume one AWT application at a time
-    if (app.awtUsed)
-      disposeAllFrames(app.log)
-    interruptAllThreads(app)
-  }
-
-  private[this] def interruptAllThreads(app: App): Unit =
-    app processThreads { t =>
-      if (!isSystemThread(t)) safeInterrupt(t, app.log)
-      else app.log.debug(s"Not interrupting system thread $t")
-    }
-
-  /** Gets the managed application associated with Thread `t` */
-  private[this] def getApp(t: Thread): Option[App] =
-    Option(threadToApp.get(computeID(t))) orElse getApp(t.getThreadGroup)
-
-  /** Gets the managed application associated with ThreadGroup `group` */
-  private[this] def getApp(group: ThreadGroup): Option[App] =
-    Option(group).flatMap(g => Option(threadToApp.get(computeID(g))))
-
-  /**
-   * Handles a valid call to `System.exit` by setting the exit code and
-   * interrupting remaining threads for the application associated with `t`, if one exists.
-   */
-  private[this] def exitApp(t: Thread, status: Int): Unit = getApp(t) match {
-    case None => System.err.println(s"Could not exit($status): no application associated with $t")
-    case Some(a) =>
-      a.exitCode.set(status)
-      stopAllThreads(a)
-  }
-
-  /** SecurityManager hook to trap calls to `System.exit` to avoid shutting down the whole JVM.*/
-  override def checkExit(status: Int): Unit = if (active) {
-    val t = currentThread
-    val stack = t.getStackTrace
-    if (stack == null || stack.exists(isRealExit)) {
-      exitApp(t, status)
-      throw new TrapExitSecurityException(status)
-    }
-  }
-
-  /** This ensures that only actual calls to exit are trapped and not just calls to check if exit is allowed.*/
-  private def isRealExit(element: StackTraceElement): Boolean =
-    element.getClassName == "java.lang.Runtime" && element.getMethodName == "exit"
-
-  // These are overridden to do nothing because there is a substantial filesystem performance penalty
-  // when there is a SecurityManager defined.  The default implementations of these construct a
-  // FilePermission, and its initialization involves canonicalization, which is expensive.
-  override def checkRead(file: String): Unit = ()
-  override def checkRead(file: String, context: AnyRef): Unit = ()
-  override def checkWrite(file: String): Unit = ()
-  override def checkDelete(file: String): Unit = ()
-  override def checkExec(cmd: String): Unit = ()
-
-  override def checkPermission(perm: Permission): Unit = {
-    if (delegateManager ne null)
-      delegateManager.checkPermission(perm)
-  }
-  override def checkPermission(perm: Permission, context: AnyRef): Unit = {
-    if (delegateManager ne null)
-      delegateManager.checkPermission(perm, context)
-  }
-
-  /**
-   * SecurityManager hook that is abused to record every created Thread and associate it with a managed application.
-   * This is not reliably called on different jvm implementations.  On openjdk and similar jvms, the Thread constructor
-   * calls setPriority, which triggers this SecurityManager check.  For Java 6 on OSX, this is not called, however.
-   */
-  override def checkAccess(t: Thread): Unit = {
-    if (active) {
-      val group = t.getThreadGroup
-      noteAccess(group) { app =>
-        app.register(group)
-        app.register(t)
-        app.register(currentThread)
-      }
-    }
-    if (delegateManager ne null)
-      delegateManager.checkAccess(t)
-  }
-
-  /**
-   * This is specified to be called in every Thread's constructor and every time a ThreadGroup is created.
-   * This allows us to reliably track every ThreadGroup that is created and map it back to the constructing application.
-   */
-  override def checkAccess(tg: ThreadGroup): Unit = {
-    if (active && !isSystemGroup(tg)) {
-      noteAccess(tg) { app =>
-        app.register(tg)
-        app.register(currentThread)
-      }
-    }
-
-    if (delegateManager ne null)
-      delegateManager.checkAccess(tg)
-  }
-
-  private[this] def noteAccess(group: ThreadGroup)(f: App => Unit): Unit =
-    getApp(currentThread) orElse getApp(group) foreach f
-
-  private[this] def isSystemGroup(group: ThreadGroup): Boolean =
-    (group != null) && (group.getName == "system")
-
-  /** `true` if there is at least one application currently being managed. */
-  private[this] def active = running.get > 0
-
-  private def disposeAllFrames(log: Logger): Unit = {
-    val allFrames = java.awt.Frame.getFrames
-    if (allFrames.nonEmpty) {
-      log.debug(s"Disposing ${allFrames.length} top-level windows...")
-      allFrames.foreach(_.dispose) // dispose all top-level windows, which will cause the AWT-EventQueue-* threads to exit
-      val waitSeconds = 2
-      log.debug(s"Waiting $waitSeconds s to let AWT thread exit.")
-      Thread.sleep(waitSeconds * 1000L) // AWT Thread doesn't exit immediately, so wait to interrupt it
-    }
-  }
-
-  /** Returns true if the given thread is in the 'system' thread group or is an AWT thread other than AWT-EventQueue.*/
-  private def isSystemThread(t: Thread) =
-    if (t.getName.startsWith("AWT-"))
-      !isEventQueue(t)
-    else
-      isSystemGroup(t.getThreadGroup)
-
-  /**
-   * An App is identified as using AWT if it gets associated with the event queue thread.
-   * The event queue thread is not treated as a system thread.
-   */
-  private[this] def isEventQueue(t: Thread): Boolean = t.getName.startsWith("AWT-EventQueue")
-}
-
-/** A thread-safe, write-once, optional cell for tracking an application's exit code.*/
-private final class ExitCode {
-  private var code: Option[Int] = None
-  def set(c: Int): Unit = synchronized { code = code orElse Some(c) }
-  def value: Option[Int] = synchronized { code }
-}
-
-/**
- * The default uncaught exception handler for managed executions.
- * It logs the thread and the exception.
- */
-private final class LoggingExceptionHandler(
-    log: Logger,
-    delegate: Option[Thread.UncaughtExceptionHandler]
-) extends Thread.UncaughtExceptionHandler {
-  def uncaughtException(t: Thread, e: Throwable): Unit = {
-    log.error("(" + t.getName + ") " + e.toString)
-    log.trace(e)
-    delegate.foreach(_.uncaughtException(t, e))
-  }
 }
diff --git a/sbt-app/src/sbt-test/classloader-cache/package-private/test b/sbt-app/src/sbt-test/classloader-cache/package-private/pending
similarity index 100%
rename from sbt-app/src/sbt-test/classloader-cache/package-private/test
rename to sbt-app/src/sbt-test/classloader-cache/package-private/pending
diff --git a/sbt-app/src/sbt-test/run/error/test b/sbt-app/src/sbt-test/run/error/disabled
similarity index 100%
rename from sbt-app/src/sbt-test/run/error/test
rename to sbt-app/src/sbt-test/run/error/disabled
diff --git a/sbt-app/src/sbt-test/run/fork/test b/sbt-app/src/sbt-test/run/fork/disabled
similarity index 100%
rename from sbt-app/src/sbt-test/run/fork/test
rename to sbt-app/src/sbt-test/run/fork/disabled
diff --git a/server-test/src/test/scala/testpkg/EventsTest.scala b/server-test/src/test/scala/testpkg/EventsTest.scala
index aebde3f95..7a4de5f1e 100644
--- a/server-test/src/test/scala/testpkg/EventsTest.scala
+++ b/server-test/src/test/scala/testpkg/EventsTest.scala
@@ -13,7 +13,7 @@ import java.util.concurrent.atomic.AtomicInteger
 // starts svr using server-test/events and perform event related tests
 object EventsTest extends AbstractServerTest {
   override val testDirectory: String = "events"
-  val currentID = new AtomicInteger(0)
+  val currentID = new AtomicInteger(1000)
 
   test("report task failures in case of exceptions") { _ =>
     val id = currentID.getAndIncrement()
@@ -30,9 +30,7 @@ object EventsTest extends AbstractServerTest {
     svr.sendJsonRpc(
       s"""{ "jsonrpc": "2.0", "id":$id, "method": "sbt/exec", "params": { "commandLine": "run" } }"""
     )
-    assert(svr.waitForString(10.seconds) { s =>
-      s contains "Waiting for"
-    })
+    Thread.sleep(1000)
     val cancelID = currentID.getAndIncrement()
     val invalidID = currentID.getAndIncrement()
     svr.sendJsonRpc(
@@ -41,52 +39,49 @@ object EventsTest extends AbstractServerTest {
     assert(svr.waitForString(20.seconds) { s =>
       (s contains """"error":{"code":-32800""")
     })
-    svr.sendJsonRpc(
-      s"""{ "jsonrpc": "2.0", "id":${currentID.getAndIncrement}, "method": "sbt/cancelRequest", "params": { "id": "$id" } }"""
-    )
-    assert(svr.waitForString(10.seconds) { s =>
-      s contains """"result":{"status":"Task cancelled""""
-    })
   }
 
+  /*
   test("cancel on-going task with numeric id") { _ =>
     val id = currentID.getAndIncrement()
     svr.sendJsonRpc(
       s"""{ "jsonrpc": "2.0", "id":$id, "method": "sbt/exec", "params": { "commandLine": "run" } }"""
     )
-    assert(svr.waitForString(10.seconds) { s =>
+    assert(svr.waitForString(20.seconds) { s =>
       s contains "Compiled events"
     })
     assert(svr.waitForString(10.seconds) { s =>
-      s contains "Waiting for"
+      s contains "running Main"
     })
     val cancelID = currentID.getAndIncrement()
     svr.sendJsonRpc(
       s"""{ "jsonrpc": "2.0", "id":$cancelID, "method": "sbt/cancelRequest", "params": { "id": "$id" } }"""
     )
-    assert(svr.waitForString(10.seconds) { s =>
+    assert(svr.waitForString(11.seconds) { s =>
+      println(s)
       s contains """"result":{"status":"Task cancelled""""
     })
   }
+   */
 
+  /*
   test("cancel on-going task with string id") { _ =>
     import sbt.Exec
     val id = Exec.newExecId
     svr.sendJsonRpc(
       s"""{ "jsonrpc": "2.0", "id": "$id", "method": "sbt/exec", "params": { "commandLine": "run" } }"""
     )
-    assert(svr.waitForString(10.seconds) { s =>
+    assert(svr.waitForString(20.seconds) { s =>
       s contains "Compiled events"
     })
-    assert(svr.waitForString(10.seconds) { s =>
-      s contains "Waiting for"
-    })
     val cancelID = Exec.newExecId
     svr.sendJsonRpc(
       s"""{ "jsonrpc": "2.0", "id": "$cancelID", "method": "sbt/cancelRequest", "params": { "id": "$id" } }"""
     )
-    assert(svr.waitForString(10.seconds) { s =>
+    assert(svr.waitForString(11.seconds) { s =>
+      println(s)
       s contains """"result":{"status":"Task cancelled""""
     })
   }
+ */
 }

From f6b993f91bbc5cbe80f533f78da0eec73dcca0c7 Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Sun, 19 Sep 2021 17:34:40 -0400
Subject: [PATCH 10/11] Zinc 1.6.0-M1

---
 build.sbt                  | 2 +-
 project/Dependencies.scala | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/build.sbt b/build.sbt
index d5f8ac88f..774a4d591 100644
--- a/build.sbt
+++ b/build.sbt
@@ -10,7 +10,7 @@ import scala.util.Try
 // ThisBuild settings take lower precedence,
 // but can be shared across the multi projects.
 ThisBuild / version := {
-  val v = "1.5.5-SNAPSHOT"
+  val v = "1.6.0-SNAPSHOT"
   nightlyVersion.getOrElse(v)
 }
 ThisBuild / version2_13 := "2.0.0-SNAPSHOT"
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index d5035cf74..974fa291b 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -12,10 +12,10 @@ object Dependencies {
     sys.env.get("BUILD_VERSION") orElse sys.props.get("sbt.build.version")
 
   // sbt modules
-  private val ioVersion = nightlyVersion.getOrElse("1.5.1")
+  private val ioVersion = nightlyVersion.getOrElse("1.6.0-M1")
   private val lmVersion =
-    sys.props.get("sbt.build.lm.version").orElse(nightlyVersion).getOrElse("1.5.2")
-  val zincVersion = nightlyVersion.getOrElse("1.5.5")
+    sys.props.get("sbt.build.lm.version").orElse(nightlyVersion).getOrElse("1.6.0-M1")
+  val zincVersion = nightlyVersion.getOrElse("1.6.0-M1")
 
   private val sbtIO = "org.scala-sbt" %% "io" % ioVersion
 

From 4370bc29ba1b46f9ffb73be5821585e38dfbe945 Mon Sep 17 00:00:00 2001
From: Eugene Yokota <eed3si9n@gmail.com>
Date: Sun, 19 Sep 2021 19:51:01 -0400
Subject: [PATCH 11/11] Incremental compilation of constant folding

---
 .../source-dependencies/constants/pending        | 12 ------------
 .../sbt-test/source-dependencies/constants/test  | 16 ++++++++++++++++
 2 files changed, 16 insertions(+), 12 deletions(-)
 delete mode 100644 sbt-app/src/sbt-test/source-dependencies/constants/pending
 create mode 100644 sbt-app/src/sbt-test/source-dependencies/constants/test

diff --git a/sbt-app/src/sbt-test/source-dependencies/constants/pending b/sbt-app/src/sbt-test/source-dependencies/constants/pending
deleted file mode 100644
index 7a5ae5879..000000000
--- a/sbt-app/src/sbt-test/source-dependencies/constants/pending
+++ /dev/null
@@ -1,12 +0,0 @@
-# Marked as pending, see https://github.com/sbt/sbt/issues/1543
-# Tests if source dependencies are tracked properly
-# for compile-time constants (like final vals in top-level objects)
-# see https://issues.scala-lang.org/browse/SI-7173 for details
-# why compile-time constants can be tricky to track due to early inlining
-
-$ copy-file changes/B.scala B.scala
-
-$ copy-file changes/A1.scala A.scala
-> run 1
-$ copy-file changes/A2.scala A.scala
-> run 2
diff --git a/sbt-app/src/sbt-test/source-dependencies/constants/test b/sbt-app/src/sbt-test/source-dependencies/constants/test
new file mode 100644
index 000000000..bc2cb09c9
--- /dev/null
+++ b/sbt-app/src/sbt-test/source-dependencies/constants/test
@@ -0,0 +1,16 @@
+> ++2.12.15!
+
+$ copy-file changes/B.scala B.scala
+
+$ copy-file changes/A1.scala A.scala
+> run 1
+$ copy-file changes/A2.scala A.scala
+> run 2
+
+> clean
+> ++2.13.6!
+
+$ copy-file changes/A1.scala A.scala
+> run 1
+$ copy-file changes/A2.scala A.scala
+> run 2