From 6611ccf94d694a1889ed0e6414b0024cb6929ca2 Mon Sep 17 00:00:00 2001 From: Matthew de Detrich Date: Thu, 8 Dec 2022 10:48:23 +0100 Subject: [PATCH 01/19] Set socket backlog to default size of 50 --- .github/workflows/ci.yml | 1 + main-command/src/main/scala/xsbt/IPC.scala | 3 ++- .../src/test/scala/xsbt/IPCSpec.scala | 23 +++++++++++++++++++ 3 files changed, 26 insertions(+), 1 deletion(-) create mode 100644 main-command/src/test/scala/xsbt/IPCSpec.scala diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 6c2cc30a4..8ca875355 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -186,6 +186,7 @@ jobs: shell: bash run: | # test building sbtn on Windows + sbt "commandProj/testOnly xsbt.IPCSpec" sbt "-Dsbt.io.virtual=false" nativeImage # test launcher script echo build using JDK 8, test using JDK 8, on Windows diff --git a/main-command/src/main/scala/xsbt/IPC.scala b/main-command/src/main/scala/xsbt/IPC.scala index 9c353613d..b5ce13ee5 100644 --- a/main-command/src/main/scala/xsbt/IPC.scala +++ b/main-command/src/main/scala/xsbt/IPC.scala @@ -17,6 +17,7 @@ object IPC { private val portMin = 1025 private val portMax = 65536 private val loopback = InetAddress.getByName(null) + private[xsbt] val socketBacklog = 50 // 50 is the default backlog size for the java.net.Socket def client[T](port: Int)(f: IPC => T): T = ipc(new Socket(loopback, port))(f) @@ -34,7 +35,7 @@ object IPC { def createServer(attempts: Int): ServerSocket = if (attempts > 0) { - try new ServerSocket(nextPort, 1, loopback) + try new ServerSocket(nextPort, socketBacklog, loopback) catch { case NonFatal(_) => createServer(attempts - 1) } } else sys.error("Could not connect to socket: maximum attempts exceeded") diff --git a/main-command/src/test/scala/xsbt/IPCSpec.scala b/main-command/src/test/scala/xsbt/IPCSpec.scala new file mode 100644 index 000000000..dfeb1dc4f --- /dev/null +++ b/main-command/src/test/scala/xsbt/IPCSpec.scala @@ -0,0 +1,23 @@ +/* + * sbt + * Copyright 2011 - 2018, Lightbend, Inc. + * Copyright 2008 - 2010, Mark Harrah + * Licensed under Apache License 2.0 (see LICENSE) + */ + +package xsbt + +import org.scalatest.flatspec.AnyFlatSpec +import org.scalatest.matchers.should.Matchers._ + +class IPCSpec extends AnyFlatSpec { + "server" should "allow same number of connections as determined in socket backlog" in { + noException should be thrownBy { + val server = IPC.unmanagedServer + (1 until IPC.socketBacklog + 1).foreach { _ => + IPC.client(server.port)(identity) + } + server.close() + } + } +} From 5515619eccd99fde0722f658abb13396f271bbb0 Mon Sep 17 00:00:00 2001 From: Adrien Piquerez Date: Thu, 10 Aug 2023 16:11:28 +0200 Subject: [PATCH 02/19] Implement buildTarget/javacOptions --- main/src/main/scala/sbt/EvaluateTask.scala | 6 +- main/src/main/scala/sbt/Keys.scala | 16 ++- main/src/main/scala/sbt/internal/Load.scala | 12 +- .../internal/server/BuildServerProtocol.scala | 90 ++++++++---- main/src/test/scala/PluginCommandTest.scala | 2 +- .../sbt/internal/bsp/JavacOptionsItem.scala | 57 ++++++++ .../sbt/internal/bsp/JavacOptionsParams.scala | 37 +++++ .../sbt/internal/bsp/JavacOptionsResult.scala | 32 +++++ .../bsp/codec/JavacOptionsItemFormats.scala | 33 +++++ .../bsp/codec/JavacOptionsParamsFormats.scala | 27 ++++ .../bsp/codec/JavacOptionsResultFormats.scala | 27 ++++ .../sbt/internal/bsp/codec/JsonProtocol.scala | 5 +- protocol/src/main/contraband/bsp.contra | 80 +++++++---- .../test/scala/testpkg/BuildServerTest.scala | 128 ++++++++++-------- 14 files changed, 423 insertions(+), 129 deletions(-) create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsItem.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsParams.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsResult.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsItemFormats.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsParamsFormats.scala create mode 100644 protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsResultFormats.scala diff --git a/main/src/main/scala/sbt/EvaluateTask.scala b/main/src/main/scala/sbt/EvaluateTask.scala index 29749cfde..eea3b357a 100644 --- a/main/src/main/scala/sbt/EvaluateTask.scala +++ b/main/src/main/scala/sbt/EvaluateTask.scala @@ -148,18 +148,20 @@ final case class PluginData( resolvers: Option[Vector[Resolver]], report: Option[UpdateReport], scalacOptions: Seq[String], + javacOptions: Seq[String], unmanagedSourceDirectories: Seq[File], unmanagedSources: Seq[File], managedSourceDirectories: Seq[File], managedSources: Seq[File], + classDirectory: Option[File], buildTarget: Option[BuildTargetIdentifier] ) { val classpath: Seq[Attributed[File]] = definitionClasspath ++ dependencyClasspath } object PluginData { - private[sbt] def apply(dependencyClasspath: Def.Classpath): PluginData = - PluginData(dependencyClasspath, Nil, None, None, Nil, Nil, Nil, Nil, Nil, None) + private[sbt] def apply(depClasspath: Def.Classpath): PluginData = + PluginData(depClasspath, Nil, None, None, Nil, Nil, Nil, Nil, Nil, Nil, None, None) } object EvaluateTask { diff --git a/main/src/main/scala/sbt/Keys.scala b/main/src/main/scala/sbt/Keys.scala index 0fb3c3bdc..3720a3693 100644 --- a/main/src/main/scala/sbt/Keys.scala +++ b/main/src/main/scala/sbt/Keys.scala @@ -419,19 +419,21 @@ object Keys { val bspBuildTargetOutputPathsItem = taskKey[OutputPathsItem]("").withRank(DTask) val bspBuildTargetCompile = inputKey[Unit]("").withRank(DTask) val bspBuildTargetCompileItem = taskKey[Int]("").withRank(DTask) - val bspBuildTargetTest = inputKey[Unit]("Corresponds to buildTarget/test request").withRank(DTask) - val bspBuildTargetRun = inputKey[Unit]("Corresponds to buildTarget/run request").withRank(DTask) - val bspBuildTargetCleanCache = inputKey[Unit]("Corresponds to buildTarget/cleanCache request").withRank(DTask) + val bspBuildTargetTest = inputKey[Unit]("Implementation of buildTarget/test").withRank(DTask) + val bspBuildTargetRun = inputKey[Unit]("Implementation of buildTarget/run").withRank(DTask) + val bspBuildTargetCleanCache = inputKey[Unit]("Implementation of buildTarget/cleanCache").withRank(DTask) val bspBuildTargetScalacOptions = inputKey[Unit]("").withRank(DTask) val bspBuildTargetScalacOptionsItem = taskKey[ScalacOptionsItem]("").withRank(DTask) + val bspBuildTargetJavacOptions = inputKey[Unit]("Implementation of buildTarget/javacOptions").withRank(DTask) + val bspBuildTargetJavacOptionsItem = taskKey[JavacOptionsItem]("Item of buildTarget/javacOptions").withRank(DTask) - val bspBuildTargetJVMRunEnvironment = inputKey[Unit]("Corresponds to the buildTarget/jvmRunEnvironment request").withRank(DTask) - val bspBuildTargetJVMTestEnvironment = inputKey[Unit]("Corresponds to the buildTarget/jvmTestEnvironment request").withRank(DTask) + val bspBuildTargetJVMRunEnvironment = inputKey[Unit]("Implementation of buildTarget/jvmRunEnvironment").withRank(DTask) + val bspBuildTargetJVMTestEnvironment = inputKey[Unit]("Implementation of buildTarget/jvmTestEnvironment").withRank(DTask) val bspBuildTargetJvmEnvironmentItem = taskKey[JvmEnvironmentItem]("Computes JVM environment item").withRank(DTask) - val bspScalaTestClasses = inputKey[Unit]("Corresponds to buildTarget/scalaTestClasses request").withRank(DTask) + val bspScalaTestClasses = inputKey[Unit]("Implementation of buildTarget/scalaTestClasses").withRank(DTask) val bspScalaTestClassesItem = taskKey[Seq[ScalaTestClassesItem]]("").withRank(DTask) - val bspScalaMainClasses = inputKey[Unit]("Corresponds to buildTarget/scalaMainClasses request").withRank(DTask) + val bspScalaMainClasses = inputKey[Unit]("Implementation of buildTarget/scalaMainClasses").withRank(DTask) val bspScalaMainClassesItem = taskKey[ScalaMainClassesItem]("").withRank(DTask) val bspReporter = taskKey[BuildServerReporter]("").withRank(DTask) diff --git a/main/src/main/scala/sbt/internal/Load.scala b/main/src/main/scala/sbt/internal/Load.scala index 3a3da3810..b00e0a911 100755 --- a/main/src/main/scala/sbt/internal/Load.scala +++ b/main/src/main/scala/sbt/internal/Load.scala @@ -1176,21 +1176,25 @@ private[sbt] object Load { val prod = (Configurations.Runtime / exportedProducts).value val cp = (Configurations.Runtime / fullClasspath).value val opts = (Configurations.Compile / scalacOptions).value + val javaOpts = (Configurations.Compile / javacOptions).value val unmanagedSrcDirs = (Configurations.Compile / unmanagedSourceDirectories).value val unmanagedSrcs = (Configurations.Compile / unmanagedSources).value val managedSrcDirs = (Configurations.Compile / managedSourceDirectories).value val managedSrcs = (Configurations.Compile / managedSources).value val buildTarget = (Configurations.Compile / bspTargetIdentifier).value + val clsDir = (Configurations.Compile / classDirectory).value PluginData( removeEntries(cp, prod), prod, Some(fullResolvers.value.toVector), Some(update.value), opts, + javaOpts, unmanagedSrcDirs, unmanagedSrcs, managedSrcDirs, managedSrcs, + Some(clsDir), Some(buildTarget) ) }, @@ -1244,11 +1248,7 @@ private[sbt] object Load { } def noPlugins(dir: File, config: LoadBuildConfiguration): LoadedPlugins = - loadPluginDefinition( - dir, - config, - PluginData(config.globalPluginClasspath, Nil, None, None, Nil, Nil, Nil, Nil, Nil, None) - ) + loadPluginDefinition(dir, config, PluginData(config.globalPluginClasspath)) def buildPlugins(dir: File, s: State, config: LoadBuildConfiguration): LoadedPlugins = loadPluginDefinition(dir, config, buildPluginDefinition(dir, s, config)) @@ -1444,6 +1444,8 @@ final case class LoadBuildConfiguration( Nil, Nil, Nil, + Nil, + None, None ) case None => PluginData(globalPluginClasspath) diff --git a/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala b/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala index e54a0139b..2d89185d5 100644 --- a/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala +++ b/main/src/main/scala/sbt/internal/server/BuildServerProtocol.scala @@ -201,24 +201,12 @@ object BuildServerProtocol { }.evaluated, bspBuildTargetCleanCache / aggregate := false, bspBuildTargetScalacOptions := bspInputTask { (state, _, workspace, filter) => - val builds = workspace.builds Def.task { val items = bspBuildTargetScalacOptionsItem.result.all(filter).value val appProvider = appConfiguration.value.provider() val sbtJars = appProvider.mainClasspath() - val buildItems = builds.map { - build => - val plugins: LoadedPlugins = build._2.unit.plugins - val scalacOptions = plugins.pluginData.scalacOptions - val pluginClassPath = plugins.classpath - val classpath = (pluginClassPath ++ sbtJars).map(_.toURI).toVector - val item = ScalacOptionsItem( - build._1, - scalacOptions.toVector, - classpath, - new File(build._2.localBase, "project/target").toURI - ) - Value(item) + val buildItems = workspace.builds.map { + case (targetId, build) => Value(scalacOptionsBuildItem(sbtJars, targetId, build)) } val successfulItems = anyOrThrow(items ++ buildItems) val result = ScalacOptionsResult(successfulItems.toVector) @@ -226,6 +214,20 @@ object BuildServerProtocol { } }.evaluated, bspBuildTargetScalacOptions / aggregate := false, + bspBuildTargetJavacOptions := bspInputTask { (state, _, workspace, filter) => + Def.task { + val items = bspBuildTargetJavacOptionsItem.result.all(filter).value + val appProvider = appConfiguration.value.provider() + val sbtJars = appProvider.mainClasspath() + val buildItems = workspace.builds.map { + case (targetId, build) => Value(javacOptionsBuildItem(sbtJars, targetId, build)) + } + val successfulItems = anyOrThrow(items ++ buildItems) + val result = JavacOptionsResult(successfulItems.toVector) + state.respondEvent(result) + } + }.evaluated, + bspBuildTargetJavacOptions / aggregate := false, bspScalaTestClasses := bspInputTask { (state, _, workspace, filter) => workspace.warnIfBuildsNonEmpty(Method.ScalaTestClasses, state.log) Def.task { @@ -286,7 +288,20 @@ object BuildServerProtocol { }, bspBuildTargetCompileItem := bspCompileTask.value, bspBuildTargetRun := bspRunTask.evaluated, - bspBuildTargetScalacOptionsItem := scalacOptionsTask.value, + bspBuildTargetScalacOptionsItem := { + val target = Keys.bspTargetIdentifier.value + val scalacOptions = Keys.scalacOptions.value.toVector + val classDirectory = Keys.classDirectory.value + val classpath = classpathTask.value + ScalacOptionsItem(target, scalacOptions, classpath, classDirectory.toURI) + }, + bspBuildTargetJavacOptionsItem := { + val target = Keys.bspTargetIdentifier.value + val javacOptions = Keys.javacOptions.value.toVector + val classDirectory = Keys.classDirectory.value + val classpath = classpathTask.value + JavacOptionsItem(target, javacOptions, classpath, classDirectory.toURI) + }, bspBuildTargetJVMRunEnvironment := bspInputTask { (state, _, _, filter) => Def.task { val items = bspBuildTargetJvmEnvironmentItem.result.all(filter).value @@ -328,7 +343,7 @@ object BuildServerProtocol { } } ) - private object Method { + private[sbt] object Method { final val Initialize = "build/initialize" final val BuildTargets = "workspace/buildTargets" final val Reload = "workspace/reload" @@ -665,6 +680,34 @@ object BuildServerProtocol { ) } + private def scalacOptionsBuildItem( + sbtJars: Seq[File], + targetId: BuildTargetIdentifier, + build: LoadedBuildUnit + ): ScalacOptionsItem = { + val plugins: LoadedPlugins = build.unit.plugins + val scalacOptions = plugins.pluginData.scalacOptions.toVector + val pluginClassPath = plugins.classpath + val classpath = (pluginClassPath ++ sbtJars).map(_.toURI).toVector + val classDirectory = plugins.pluginData.classDirectory.map(_.toURI) + val item = ScalacOptionsItem(targetId, scalacOptions, classpath, classDirectory) + item + } + + private def javacOptionsBuildItem( + sbtJars: Seq[File], + targetId: BuildTargetIdentifier, + build: LoadedBuildUnit + ): JavacOptionsItem = { + val plugins: LoadedPlugins = build.unit.plugins + val javacOptions = plugins.pluginData.javacOptions.toVector + val pluginClassPath = plugins.classpath + val classpath = (pluginClassPath ++ sbtJars).map(_.toURI).toVector + val classDirectory = plugins.pluginData.classDirectory.map(_.toURI) + val item = JavacOptionsItem(targetId, javacOptions, classpath, classDirectory) + item + } + private def bspInputTask[T]( taskImpl: ( State, @@ -697,26 +740,17 @@ object BuildServerProtocol { ) } - private def scalacOptionsTask: Def.Initialize[Task[ScalacOptionsItem]] = Def.taskDyn { - val target = Keys.bspTargetIdentifier.value - val scalacOptions = Keys.scalacOptions.value - val classDirectory = Keys.classDirectory.value + private lazy val classpathTask: Def.Initialize[Task[Vector[URI]]] = Def.taskDyn { val externalDependencyClasspath = Keys.externalDependencyClasspath.value - val internalDependencyClasspath = for { (ref, configs) <- bspInternalDependencyConfigurations.value config <- configs } yield ref / config / Keys.classDirectory - Def.task { val classpath = internalDependencyClasspath.join.value.distinct ++ externalDependencyClasspath.map(_.data) - ScalacOptionsItem( - target, - scalacOptions.toVector, - classpath.map(_.toURI).toVector, - classDirectory.toURI - ) + + classpath.map(_.toURI).toVector } } diff --git a/main/src/test/scala/PluginCommandTest.scala b/main/src/test/scala/PluginCommandTest.scala index b0fa5662b..d49950a6b 100644 --- a/main/src/test/scala/PluginCommandTest.scala +++ b/main/src/test/scala/PluginCommandTest.scala @@ -115,7 +115,7 @@ object FakeState { Nil ) - val pluginData = PluginData(Nil, Nil, None, None, Nil, Nil, Nil, Nil, Nil, None) + val pluginData = PluginData(Nil, Nil, None, None, Nil, Nil, Nil, Nil, Nil, Nil, None, None) val builds: DetectedModules[BuildDef] = new DetectedModules[BuildDef](Nil) val detectedAutoPlugins: Seq[DetectedAutoPlugin] = diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsItem.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsItem.scala new file mode 100644 index 000000000..30157dfb5 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsItem.scala @@ -0,0 +1,57 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp +/** + * @param options Additional arguments to the compiler. + For example, -deprecation. + * @param classpath The dependency classpath for this target, must be + identical to what is passed as arguments to + the -classpath flag in the command line interface + of scalac. + * @param classDirectory The output directory for classfiles produced by this target + */ +final class JavacOptionsItem private ( + val target: sbt.internal.bsp.BuildTargetIdentifier, + val options: Vector[String], + val classpath: Vector[java.net.URI], + val classDirectory: Option[java.net.URI]) extends Serializable { + + + + override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { + case x: JavacOptionsItem => (this.target == x.target) && (this.options == x.options) && (this.classpath == x.classpath) && (this.classDirectory == x.classDirectory) + case _ => false + }) + override def hashCode: Int = { + 37 * (37 * (37 * (37 * (37 * (17 + "sbt.internal.bsp.JavacOptionsItem".##) + target.##) + options.##) + classpath.##) + classDirectory.##) + } + override def toString: String = { + "JavacOptionsItem(" + target + ", " + options + ", " + classpath + ", " + classDirectory + ")" + } + private[this] def copy(target: sbt.internal.bsp.BuildTargetIdentifier = target, options: Vector[String] = options, classpath: Vector[java.net.URI] = classpath, classDirectory: Option[java.net.URI] = classDirectory): JavacOptionsItem = { + new JavacOptionsItem(target, options, classpath, classDirectory) + } + def withTarget(target: sbt.internal.bsp.BuildTargetIdentifier): JavacOptionsItem = { + copy(target = target) + } + def withOptions(options: Vector[String]): JavacOptionsItem = { + copy(options = options) + } + def withClasspath(classpath: Vector[java.net.URI]): JavacOptionsItem = { + copy(classpath = classpath) + } + def withClassDirectory(classDirectory: Option[java.net.URI]): JavacOptionsItem = { + copy(classDirectory = classDirectory) + } + def withClassDirectory(classDirectory: java.net.URI): JavacOptionsItem = { + copy(classDirectory = Option(classDirectory)) + } +} +object JavacOptionsItem { + + def apply(target: sbt.internal.bsp.BuildTargetIdentifier, options: Vector[String], classpath: Vector[java.net.URI], classDirectory: Option[java.net.URI]): JavacOptionsItem = new JavacOptionsItem(target, options, classpath, classDirectory) + def apply(target: sbt.internal.bsp.BuildTargetIdentifier, options: Vector[String], classpath: Vector[java.net.URI], classDirectory: java.net.URI): JavacOptionsItem = new JavacOptionsItem(target, options, classpath, Option(classDirectory)) +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsParams.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsParams.scala new file mode 100644 index 000000000..4cc1ebbe2 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsParams.scala @@ -0,0 +1,37 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp +/** + * Javac options + * The build target javac options request is sent from the client to the server + * to query for the list of compiler options necessary to compile in a given list of targets. + */ +final class JavacOptionsParams private ( + val targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]) extends Serializable { + + + + override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { + case x: JavacOptionsParams => (this.targets == x.targets) + case _ => false + }) + override def hashCode: Int = { + 37 * (37 * (17 + "sbt.internal.bsp.JavacOptionsParams".##) + targets.##) + } + override def toString: String = { + "JavacOptionsParams(" + targets + ")" + } + private[this] def copy(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier] = targets): JavacOptionsParams = { + new JavacOptionsParams(targets) + } + def withTargets(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): JavacOptionsParams = { + copy(targets = targets) + } +} +object JavacOptionsParams { + + def apply(targets: Vector[sbt.internal.bsp.BuildTargetIdentifier]): JavacOptionsParams = new JavacOptionsParams(targets) +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsResult.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsResult.scala new file mode 100644 index 000000000..fb89063b4 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/JavacOptionsResult.scala @@ -0,0 +1,32 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp +final class JavacOptionsResult private ( + val items: Vector[sbt.internal.bsp.JavacOptionsItem]) extends Serializable { + + + + override def equals(o: Any): Boolean = this.eq(o.asInstanceOf[AnyRef]) || (o match { + case x: JavacOptionsResult => (this.items == x.items) + case _ => false + }) + override def hashCode: Int = { + 37 * (37 * (17 + "sbt.internal.bsp.JavacOptionsResult".##) + items.##) + } + override def toString: String = { + "JavacOptionsResult(" + items + ")" + } + private[this] def copy(items: Vector[sbt.internal.bsp.JavacOptionsItem] = items): JavacOptionsResult = { + new JavacOptionsResult(items) + } + def withItems(items: Vector[sbt.internal.bsp.JavacOptionsItem]): JavacOptionsResult = { + copy(items = items) + } +} +object JavacOptionsResult { + + def apply(items: Vector[sbt.internal.bsp.JavacOptionsItem]): JavacOptionsResult = new JavacOptionsResult(items) +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsItemFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsItemFormats.scala new file mode 100644 index 000000000..2605a99dc --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsItemFormats.scala @@ -0,0 +1,33 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp.codec +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait JavacOptionsItemFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val JavacOptionsItemFormat: JsonFormat[sbt.internal.bsp.JavacOptionsItem] = new JsonFormat[sbt.internal.bsp.JavacOptionsItem] { + override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JavacOptionsItem = { + __jsOpt match { + case Some(__js) => + unbuilder.beginObject(__js) + val target = unbuilder.readField[sbt.internal.bsp.BuildTargetIdentifier]("target") + val options = unbuilder.readField[Vector[String]]("options") + val classpath = unbuilder.readField[Vector[java.net.URI]]("classpath") + val classDirectory = unbuilder.readField[Option[java.net.URI]]("classDirectory") + unbuilder.endObject() + sbt.internal.bsp.JavacOptionsItem(target, options, classpath, classDirectory) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.bsp.JavacOptionsItem, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("target", obj.target) + builder.addField("options", obj.options) + builder.addField("classpath", obj.classpath) + builder.addField("classDirectory", obj.classDirectory) + builder.endObject() + } +} +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsParamsFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsParamsFormats.scala new file mode 100644 index 000000000..91bd41177 --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsParamsFormats.scala @@ -0,0 +1,27 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp.codec +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait JavacOptionsParamsFormats { self: sbt.internal.bsp.codec.BuildTargetIdentifierFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val JavacOptionsParamsFormat: JsonFormat[sbt.internal.bsp.JavacOptionsParams] = new JsonFormat[sbt.internal.bsp.JavacOptionsParams] { + override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JavacOptionsParams = { + __jsOpt match { + case Some(__js) => + unbuilder.beginObject(__js) + val targets = unbuilder.readField[Vector[sbt.internal.bsp.BuildTargetIdentifier]]("targets") + unbuilder.endObject() + sbt.internal.bsp.JavacOptionsParams(targets) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.bsp.JavacOptionsParams, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("targets", obj.targets) + builder.endObject() + } +} +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsResultFormats.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsResultFormats.scala new file mode 100644 index 000000000..ee381306a --- /dev/null +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JavacOptionsResultFormats.scala @@ -0,0 +1,27 @@ +/** + * This code is generated using [[https://www.scala-sbt.org/contraband/ sbt-contraband]]. + */ + +// DO NOT EDIT MANUALLY +package sbt.internal.bsp.codec +import _root_.sjsonnew.{ Unbuilder, Builder, JsonFormat, deserializationError } +trait JavacOptionsResultFormats { self: sbt.internal.bsp.codec.JavacOptionsItemFormats with sjsonnew.BasicJsonProtocol => +implicit lazy val JavacOptionsResultFormat: JsonFormat[sbt.internal.bsp.JavacOptionsResult] = new JsonFormat[sbt.internal.bsp.JavacOptionsResult] { + override def read[J](__jsOpt: Option[J], unbuilder: Unbuilder[J]): sbt.internal.bsp.JavacOptionsResult = { + __jsOpt match { + case Some(__js) => + unbuilder.beginObject(__js) + val items = unbuilder.readField[Vector[sbt.internal.bsp.JavacOptionsItem]]("items") + unbuilder.endObject() + sbt.internal.bsp.JavacOptionsResult(items) + case None => + deserializationError("Expected JsObject but found None") + } + } + override def write[J](obj: sbt.internal.bsp.JavacOptionsResult, builder: Builder[J]): Unit = { + builder.beginObject() + builder.addField("items", obj.items) + builder.endObject() + } +} +} diff --git a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala index 3a3ff0906..f6cae48d8 100644 --- a/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala +++ b/protocol/src/main/contraband-scala/sbt/internal/bsp/codec/JsonProtocol.scala @@ -56,10 +56,13 @@ trait JsonProtocol extends sjsonnew.BasicJsonProtocol with sbt.internal.bsp.codec.RunParamsFormats with sbt.internal.bsp.codec.RunResultFormats with sbt.internal.bsp.codec.ScalaBuildTargetFormats - with sbt.internal.bsp.codec.SbtBuildTargetFormats with sbt.internal.bsp.codec.ScalacOptionsParamsFormats with sbt.internal.bsp.codec.ScalacOptionsItemFormats with sbt.internal.bsp.codec.ScalacOptionsResultFormats + with sbt.internal.bsp.codec.JavacOptionsParamsFormats + with sbt.internal.bsp.codec.JavacOptionsItemFormats + with sbt.internal.bsp.codec.JavacOptionsResultFormats + with sbt.internal.bsp.codec.SbtBuildTargetFormats with sbt.internal.bsp.codec.BspConnectionDetailsFormats with sbt.internal.bsp.codec.MetalsMetadataFormats with sbt.internal.bsp.codec.ScalaTestClassesItemFormats diff --git a/protocol/src/main/contraband/bsp.contra b/protocol/src/main/contraband/bsp.contra index 033143005..dd621786a 100644 --- a/protocol/src/main/contraband/bsp.contra +++ b/protocol/src/main/contraband/bsp.contra @@ -625,31 +625,6 @@ type ScalaBuildTarget { jars: [String]! } -# sbt Extension - -## Contains sbt-specific metadata for providing editor support for sbt build files. -## This metadata is embedded in the data: Option[Json] field of the BuildTarget definition -## when the dataKind field contains "sbt". -type SbtBuildTarget { - ## The sbt version. Useful to support version-dependent syntax. - sbtVersion: String! - - ## A sequence of Scala imports that are automatically imported in the sbt build files. - autoImports: [String]! - - ## The Scala build target describing the scala - ## version and scala jars used by this sbt version. - scalaBuildTarget: sbt.internal.bsp.ScalaBuildTarget! - - ## An optional parent if the target has an sbt meta project. - parent: sbt.internal.bsp.BuildTargetIdentifier - - ## The inverse of parent, list of targets that have this build target - ## defined as their parent. It can contain normal project targets or - ## sbt build targets if this target represents an sbt meta-meta build. - children: [sbt.internal.bsp.BuildTargetIdentifier]! -} - ## Scalac options ## The build target scalac options request is sent from the client to the server ## to query for the list of compiler options necessary to compile in a given list of targets. @@ -678,6 +653,61 @@ type ScalacOptionsItem { classDirectory: java.net.URI } +# Java Extension + +## Javac options +## The build target javac options request is sent from the client to the server +## to query for the list of compiler options necessary to compile in a given list of targets. +type JavacOptionsParams { + targets: [sbt.internal.bsp.BuildTargetIdentifier] +} + +type JavacOptionsResult { + items: [sbt.internal.bsp.JavacOptionsItem] +} + +type JavacOptionsItem { + target: sbt.internal.bsp.BuildTargetIdentifier! + + ## Additional arguments to the compiler. + ## For example, -deprecation. + options: [String] + + ## The dependency classpath for this target, must be + ## identical to what is passed as arguments to + ## the -classpath flag in the command line interface + ## of scalac. + classpath: [java.net.URI] + + ## The output directory for classfiles produced by this target + classDirectory: java.net.URI +} + +# sbt Extension + +## Contains sbt-specific metadata for providing editor support for sbt build files. +## This metadata is embedded in the data: Option[Json] field of the BuildTarget definition +## when the dataKind field contains "sbt". +type SbtBuildTarget { + ## The sbt version. Useful to support version-dependent syntax. + sbtVersion: String! + + ## A sequence of Scala imports that are automatically imported in the sbt build files. + autoImports: [String]! + + ## The Scala build target describing the scala + ## version and scala jars used by this sbt version. + scalaBuildTarget: sbt.internal.bsp.ScalaBuildTarget! + + ## An optional parent if the target has an sbt meta project. + parent: sbt.internal.bsp.BuildTargetIdentifier + + ## The inverse of parent, list of targets that have this build target + ## defined as their parent. It can contain normal project targets or + ## sbt build targets if this target represents an sbt meta-meta build. + children: [sbt.internal.bsp.BuildTargetIdentifier]! +} + ## https://build-server-protocol.github.io/docs/server-discovery.html type BspConnectionDetails { ## The name of the build tool diff --git a/server-test/src/test/scala/testpkg/BuildServerTest.scala b/server-test/src/test/scala/testpkg/BuildServerTest.scala index c694f1334..e5c73168f 100644 --- a/server-test/src/test/scala/testpkg/BuildServerTest.scala +++ b/server-test/src/test/scala/testpkg/BuildServerTest.scala @@ -32,8 +32,7 @@ object BuildServerTest extends AbstractServerTest { private def nextId(): Int = idGen.getAndIncrement() test("build/initialize") { _ => - val id = nextId() - initializeRequest(id) + val id = initializeRequest() assert(svr.waitForString(10.seconds) { s => (s contains s""""id":"${id}"""") && (s contains """"resourcesProvider":true""") && @@ -42,10 +41,7 @@ object BuildServerTest extends AbstractServerTest { } test("workspace/buildTargets") { _ => - svr.sendJsonRpc( - s"""{ "jsonrpc": "2.0", "id": "${nextId()}", "method": "workspace/buildTargets", "params": {} }""" - ) - assert(processing("workspace/buildTargets")) + sendRequest("workspace/buildTargets") val result = svr.waitFor[WorkspaceBuildTargetsResult](10.seconds) val utilTarget = result.targets.find(_.displayName.contains("util")).get assert(utilTarget.id.uri.toString.endsWith("#util/Compile")) @@ -58,16 +54,14 @@ object BuildServerTest extends AbstractServerTest { test("buildTarget/sources") { _ => val buildTarget = buildTargetUri("util", "Compile") val badBuildTarget = buildTargetUri("badBuildTarget", "Compile") - svr.sendJsonRpc(buildTargetSources(Seq(buildTarget, badBuildTarget))) - assert(processing("buildTarget/sources")) + buildTargetSources(Seq(buildTarget, badBuildTarget)) val s = svr.waitFor[SourcesResult](10.seconds) val sources = s.items.head.sources.map(_.uri) assert(sources.contains(new File(svr.baseDirectory, "util/src/main/scala").toURI)) } test("buildTarget/sources: base sources") { _ => val buildTarget = buildTargetUri("buildserver", "Compile") - svr.sendJsonRpc(buildTargetSources(Seq(buildTarget))) - assert(processing("buildTarget/sources")) + buildTargetSources(Seq(buildTarget)) val s = svr.waitFor[SourcesResult](10.seconds) val sources = s.items.head.sources val expectedSource = SourceItem( @@ -80,8 +74,7 @@ object BuildServerTest extends AbstractServerTest { test("buildTarget/sources: sbt") { _ => val x = new URI(s"${svr.baseDirectory.getAbsoluteFile.toURI}#buildserver-build") - svr.sendJsonRpc(buildTargetSources(Seq(x))) - assert(processing("buildTarget/sources")) + buildTargetSources(Seq(x)) val s = svr.waitFor[SourcesResult](10.seconds) val sources = s.items.head.sources.map(_.uri).sorted val expectedSources = Vector( @@ -99,17 +92,13 @@ object BuildServerTest extends AbstractServerTest { test("buildTarget/compile") { _ => val buildTarget = buildTargetUri("util", "Compile") - - compile(buildTarget, id = nextId()) - - assert(processing("buildTarget/compile")) + compile(buildTarget) val res = svr.waitFor[BspCompileResult](10.seconds) assert(res.statusCode == StatusCode.Success) } test("buildTarget/compile - reports compilation progress") { _ => val buildTarget = buildTargetUri("runAndTest", "Compile") - compile(buildTarget) // This doesn't always come back in 10s on CI. @@ -271,18 +260,19 @@ object BuildServerTest extends AbstractServerTest { ) } - test("buildTarget/scalacOptions") { _ => + test("buildTarget/scalacOptions, buildTarget/javacOptions") { _ => val buildTarget = buildTargetUri("util", "Compile") val badBuildTarget = buildTargetUri("badBuildTarget", "Compile") - val id = nextId() - svr.sendJsonRpc( - s"""{ "jsonrpc": "2.0", "id": "$id", "method": "buildTarget/scalacOptions", "params": { - | "targets": [{ "uri": "$buildTarget" }, { "uri": "$badBuildTarget" }] - |} }""".stripMargin - ) - assert(processing("buildTarget/scalacOptions")) + val id1 = scalacOptions(Seq(buildTarget, badBuildTarget)) + assert(svr.waitForString(10.seconds) { s => - (s contains s""""id":"$id"""") && + (s contains s""""id":"$id1"""") && + (s contains "scala-library-2.13.11.jar") + }) + + val id2 = javacOptions(Seq(buildTarget, badBuildTarget)) + assert(svr.waitForString(10.seconds) { s => + (s contains s""""id":"$id2"""") && (s contains "scala-library-2.13.11.jar") }) } @@ -306,7 +296,7 @@ object BuildServerTest extends AbstractServerTest { | "targets": [{ "uri": "$buildTarget" }] |} }""".stripMargin ) - assert(processing("buildTarget/cleanCache")) + assertProcessing("buildTarget/cleanCache") val res = svr.waitFor[CleanCacheResult](10.seconds) assert(res.cleaned) assert(targetDir.list().isEmpty) @@ -316,7 +306,7 @@ object BuildServerTest extends AbstractServerTest { svr.sendJsonRpc( s"""{ "jsonrpc": "2.0", "id": "${nextId()}", "method": "workspace/buildTargets", "params": {} }""" ) - assert(processing("workspace/buildTargets")) + assertProcessing("workspace/buildTargets") val result = svr.waitFor[WorkspaceBuildTargetsResult](10.seconds) val allTargets = result.targets.map(_.id.uri) @@ -327,7 +317,7 @@ object BuildServerTest extends AbstractServerTest { | ] |} }""".stripMargin ) - assert(processing("buildTarget/cleanCache")) + assertProcessing("buildTarget/cleanCache") val res = svr.waitFor[CleanCacheResult](10.seconds) assert(res.cleaned) } @@ -337,7 +327,7 @@ object BuildServerTest extends AbstractServerTest { svr.sendJsonRpc( s"""{ "jsonrpc": "2.0", "id": "$id", "method": "workspace/reload"}""" ) - assert(processing("workspace/reload")) + assertProcessing("workspace/reload") assert(svr.waitForString(10.seconds) { s => (s contains s""""id":"$id"""") && (s contains """"result":null""") @@ -355,9 +345,8 @@ object BuildServerTest extends AbstractServerTest { |) |""".stripMargin ) - val id = nextId() + val id = reloadWorkspace() // reload - reloadWorkspace(id) assert( svr.waitForString(10.seconds) { s => s.contains(s""""buildTarget":{"uri":"$metaBuildTarget"}""") && @@ -405,7 +394,7 @@ object BuildServerTest extends AbstractServerTest { | "targets": [{ "uri": "$buildTarget" }, { "uri": "$badBuildTarget" }] |} }""".stripMargin ) - assert(processing("buildTarget/scalaMainClasses")) + assertProcessing("buildTarget/scalaMainClasses") assert(svr.waitForString(30.seconds) { s => (s contains s""""id":"$id"""") && (s contains """"class":"main.Main"""") @@ -422,7 +411,7 @@ object BuildServerTest extends AbstractServerTest { | "data": { "class": "main.Main" } |} }""".stripMargin ) - assert(processing("buildTarget/run")) + assertProcessing("buildTarget/run") assert(svr.waitForString(10.seconds) { s => (s contains "build/logMessage") && (s contains """"message":"Hello World!"""") @@ -443,7 +432,7 @@ object BuildServerTest extends AbstractServerTest { | "params": { "targets": [{ "uri": "$buildTarget" }] } |}""".stripMargin ) - assert(processing("buildTarget/jvmRunEnvironment")) + assertProcessing("buildTarget/jvmRunEnvironment") assert { svr.waitForString(10.seconds) { s => (s contains s""""id":"$id"""") && @@ -465,7 +454,7 @@ object BuildServerTest extends AbstractServerTest { | "params": { "targets": [{ "uri": "$buildTarget" }] } |}""".stripMargin ) - assert(processing("buildTarget/jvmTestEnvironment")) + assertProcessing("buildTarget/jvmTestEnvironment") assert { svr.waitForString(10.seconds) { s => (s contains s""""id":"$id"""") && @@ -487,7 +476,7 @@ object BuildServerTest extends AbstractServerTest { | "targets": [{ "uri": "$buildTarget" }, { "uri": "$badBuildTarget" }] |} }""".stripMargin ) - assert(processing("buildTarget/scalaTestClasses")) + assertProcessing("buildTarget/scalaTestClasses") assert(svr.waitForString(10.seconds) { s => (s contains s""""id":"$id"""") && (s contains """"tests.FailingTest"""") && @@ -504,7 +493,7 @@ object BuildServerTest extends AbstractServerTest { | "targets": [{ "uri": "$buildTarget" }] |} }""".stripMargin ) - assert(processing("buildTarget/test")) + assertProcessing("buildTarget/test") assert(svr.waitForString(10.seconds) { s => (s contains s""""id":"$id"""") && (s contains """"statusCode":2""") @@ -528,7 +517,7 @@ object BuildServerTest extends AbstractServerTest { | } |} }""".stripMargin ) - assert(processing("buildTarget/test")) + assertProcessing("buildTarget/test") assert(svr.waitForString(10.seconds) { s => (s contains s""""id":"$id"""") && (s contains """"statusCode":1""") @@ -557,8 +546,7 @@ object BuildServerTest extends AbstractServerTest { test("buildTarget/compile: respond error") { _ => val buildTarget = buildTargetUri("respondError", "Compile") - val id = nextId() - compile(buildTarget, id) + val id = compile(buildTarget) assert(svr.waitForString(10.seconds) { s => s.contains(s""""id":"$id"""") && s.contains(""""error"""") && @@ -576,7 +564,7 @@ object BuildServerTest extends AbstractServerTest { | "targets": [{ "uri": "$buildTarget" }, { "uri": "$badBuildTarget" }] |} }""".stripMargin ) - assert(processing("buildTarget/resources")) + assertProcessing("buildTarget/resources") assert(svr.waitForString(10.seconds) { s => (s contains s""""id":"$id"""") && (s contains "util/src/main/resources/") }) @@ -590,7 +578,7 @@ object BuildServerTest extends AbstractServerTest { | "targets": [{ "uri": "$buildTarget" }, { "uri": "$badBuildTarget" }] |} }""".stripMargin ) - assert(processing("buildTarget/outputPaths")) + assertProcessing("buildTarget/outputPaths") val actualResult = svr.waitFor[OutputPathsResult](10.seconds) val expectedResult = OutputPathsResult( items = Vector( @@ -608,7 +596,7 @@ object BuildServerTest extends AbstractServerTest { assert(actualResult == expectedResult) } - private def initializeRequest(id: Int): Unit = { + private def initializeRequest(): Int = { val params = InitializeBuildParams( "test client", "1.0.0", @@ -617,35 +605,55 @@ object BuildServerTest extends AbstractServerTest { BuildClientCapabilities(Vector("scala")), None ) - svr.sendJsonRpc(request(id, "build/initialize", params)) + sendRequest("build/initialize", params) } - private def processing(method: String, debug: Boolean = false): Boolean = { - svr.waitForString(10.seconds) { msg => + private def assertProcessing(method: String, debug: Boolean = false): Unit = { + assert(svr.waitForString(10.seconds) { msg => if (debug) println(msg) - msg.contains("build/logMessage") && - msg.contains(s""""message":"Processing $method"""") - } + msg.contains("build/logMessage") && msg.contains(s""""message":"Processing $method"""") + }) } - private def reloadWorkspace(id: Int = nextId()): Unit = - svr.sendJsonRpc(s"""{ "jsonrpc": "2.0", "id": "$id", "method": "workspace/reload"}""") + private def reloadWorkspace(): Int = + sendRequest("workspace/reload") - private def compile(buildTarget: URI, id: Int = nextId()): Unit = { + private def compile(buildTarget: URI): Int = { val params = CompileParams(targets = Vector(BuildTargetIdentifier(buildTarget)), None, Vector.empty) - svr.sendJsonRpc(request(id, "buildTarget/compile", params)) + sendRequest("buildTarget/compile", params) } - private def buildTargetSources(buildTargets: Seq[URI], id: Int = nextId()): String = { + private def scalacOptions(buildTargets: Seq[URI]): Int = { val targets = buildTargets.map(BuildTargetIdentifier.apply).toVector - request(id, "buildTarget/sources", SourcesParams(targets)) + sendRequest("buildTarget/scalacOptions", ScalacOptionsParams(targets)) } - private def request[T: JsonWriter](id: Int, method: String, params: T): String = { - val request = JsonRpcRequestMessage("2.0", id.toString, method, Converter.toJson(params).get) - val json = Converter.toJson(request).get - CompactPrinter(json) + private def javacOptions(buildTargets: Seq[URI]): Int = { + val targets = buildTargets.map(BuildTargetIdentifier.apply).toVector + sendRequest("buildTarget/scalacOptions", ScalacOptionsParams(targets)) + } + + private def buildTargetSources(buildTargets: Seq[URI]): Int = { + val targets = buildTargets.map(BuildTargetIdentifier.apply).toVector + sendRequest("buildTarget/sources", SourcesParams(targets)) + } + + private def sendRequest(method: String): Int = { + val id = nextId() + val msg = JsonRpcRequestMessage("2.0", id.toString, method, None) + val json = Converter.toJson(msg).get + svr.sendJsonRpc(CompactPrinter(json)) + id + } + + private def sendRequest[T: JsonWriter](method: String, params: T): Int = { + val id = nextId() + val msg = JsonRpcRequestMessage("2.0", id.toString, method, Converter.toJson(params).get) + val json = Converter.toJson(msg).get + svr.sendJsonRpc(CompactPrinter(json)) + assertProcessing(method) + id } private def buildTargetUri(project: String, config: String): URI = From bd8b11632c1b0a4fc9b10481b5bf5552d2ff8f39 Mon Sep 17 00:00:00 2001 From: Matthias Kurz Date: Fri, 11 Aug 2023 21:56:46 +0200 Subject: [PATCH 03/19] Remove conscriptConfigs task, not used and needed anymore --- build.sbt | 1 - project/Transform.scala | 21 --------------------- 2 files changed, 22 deletions(-) diff --git a/build.sbt b/build.sbt index ce6a0f709..d67192d36 100644 --- a/build.sbt +++ b/build.sbt @@ -206,7 +206,6 @@ lazy val sbtRoot: Project = (project in file(".")) scalacOptions += "-Ymacro-expand:none", // for both sxr and doc Util.publishPomSettings, otherRootSettings, - Transform.conscriptSettings(bundledLauncherProj), publish := {}, publishLocal := {}, publish / skip := true, diff --git a/project/Transform.scala b/project/Transform.scala index fde66b01c..f63323081 100644 --- a/project/Transform.scala +++ b/project/Transform.scala @@ -2,27 +2,6 @@ import sbt._ import sbt.Keys._ object Transform { - private val conscriptConfigs = taskKey[Unit]("") - - def conscriptSettings(launch: Reference) = Seq( - conscriptConfigs := { - val sourceFile = (launch / Compile / managedResources).value - .find(_.getName == "sbt.boot.properties") - .getOrElse(sys.error("No managed boot.properties file.")) - val source = IO.readLines(sourceFile) - val conscriptBase = (Compile / sourceDirectory).value / "conscript" - IO.delete(conscriptBase) - val pairs = Seq( - "sbt.xMain" -> "xsbt", - "sbt.ScriptMain" -> "scalas", - "sbt.ConsoleMain" -> "screpl", - ) - for ((main, dir) <- pairs) { - val lines = source.map(l => if (l.trim.startsWith("class:")) s" class: $main" else l) - IO.writeLines(conscriptBase / dir / "launchconfig", lines) - } - }, - ) def configSettings = Seq( resourceGenerators += Def.task { From 876a85461d11f73d17b93ca738666d30bdeac07e Mon Sep 17 00:00:00 2001 From: Seth Tisue Date: Sun, 13 Aug 2023 07:18:09 -0700 Subject: [PATCH 04/19] add a Scala 3 seed to the sbt new menu --- main/src/main/scala/sbt/TemplateCommandUtil.scala | 1 + 1 file changed, 1 insertion(+) diff --git a/main/src/main/scala/sbt/TemplateCommandUtil.scala b/main/src/main/scala/sbt/TemplateCommandUtil.scala index 81372960f..afb2c5ac7 100644 --- a/main/src/main/scala/sbt/TemplateCommandUtil.scala +++ b/main/src/main/scala/sbt/TemplateCommandUtil.scala @@ -172,6 +172,7 @@ private[sbt] object TemplateCommandUtil { ScalaToolkitSlug -> "Scala Toolkit (beta) by Scala Center and VirtusLab", TypelevelToolkitSlug -> "Toolkit to start building Typelevel apps", SbtCrossPlatformSlug -> "A cross-JVM/JS/Native project", + "scala/scala3.g8" -> "Scala 3 seed template", "scala/scala-seed.g8" -> "Scala 2 seed template", "playframework/play-scala-seed.g8" -> "A Play project in Scala", "playframework/play-java-seed.g8" -> "A Play project in Java", From 9522b7e4ed685cd134bad948c8309d5e35f2ea0e Mon Sep 17 00:00:00 2001 From: Adrien Piquerez Date: Wed, 16 Aug 2023 13:11:39 +0200 Subject: [PATCH 05/19] add exclusion --- build.sbt | 1 + 1 file changed, 1 insertion(+) diff --git a/build.sbt b/build.sbt index ce6a0f709..aac40f675 100644 --- a/build.sbt +++ b/build.sbt @@ -176,6 +176,7 @@ def mimaSettingsSince(versions: Seq[String]): Seq[Def.Setting[_]] = Def settings exclude[DirectMissingMethodProblem]("sbt.PluginData.apply"), exclude[DirectMissingMethodProblem]("sbt.PluginData.copy"), exclude[DirectMissingMethodProblem]("sbt.PluginData.this"), + exclude[IncompatibleResultTypeProblem]("sbt.PluginData.copy$default$10") ), ) From 667e4b67cdb312b1a648ee75f953f9d4af3bc55c Mon Sep 17 00:00:00 2001 From: Adrien Piquerez Date: Tue, 22 Aug 2023 10:06:26 +0200 Subject: [PATCH 06/19] Fix initialize test --- server-test/src/test/scala/testpkg/BuildServerTest.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/server-test/src/test/scala/testpkg/BuildServerTest.scala b/server-test/src/test/scala/testpkg/BuildServerTest.scala index e5c73168f..dc1486786 100644 --- a/server-test/src/test/scala/testpkg/BuildServerTest.scala +++ b/server-test/src/test/scala/testpkg/BuildServerTest.scala @@ -652,7 +652,7 @@ object BuildServerTest extends AbstractServerTest { val msg = JsonRpcRequestMessage("2.0", id.toString, method, Converter.toJson(params).get) val json = Converter.toJson(msg).get svr.sendJsonRpc(CompactPrinter(json)) - assertProcessing(method) + if (method != "build/initialize") assertProcessing(method) id } From bee6748f2940cde384457c0c98290dec77ef5ed8 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Thu, 24 Aug 2023 13:04:58 -0400 Subject: [PATCH 07/19] Update Ivy and Coursier to latest --- project/Dependencies.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/project/Dependencies.scala b/project/Dependencies.scala index c37ed8e5b..18af50955 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -14,7 +14,7 @@ object Dependencies { // sbt modules private val ioVersion = nightlyVersion.getOrElse("1.9.1") private val lmVersion = - sys.props.get("sbt.build.lm.version").orElse(nightlyVersion).getOrElse("1.9.1") + sys.props.get("sbt.build.lm.version").orElse(nightlyVersion).getOrElse("1.9.2") val zincVersion = nightlyVersion.getOrElse("1.9.3") private val sbtIO = "org.scala-sbt" %% "io" % ioVersion @@ -77,7 +77,7 @@ object Dependencies { def addSbtZincCompile = addSbtModule(sbtZincPath, "zincCompile", zincCompile) def addSbtZincCompileCore = addSbtModule(sbtZincPath, "zincCompileCore", zincCompileCore) - val lmCoursierShaded = "io.get-coursier" %% "lm-coursier-shaded" % "2.1.0" + val lmCoursierShaded = "io.get-coursier" %% "lm-coursier-shaded" % "2.1.1" def sjsonNew(n: String) = Def.setting("com.eed3si9n" %% n % "0.9.1") // contrabandSjsonNewVersion.value From cdaae3bfde7257d7252739506d7dff24774612db Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Thu, 24 Aug 2023 20:55:50 -0400 Subject: [PATCH 08/19] sbt 1.9.4 --- build.sbt | 2 +- sbt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/build.sbt b/build.sbt index d67192d36..9cd3bcaef 100644 --- a/build.sbt +++ b/build.sbt @@ -11,7 +11,7 @@ import scala.util.Try // ThisBuild settings take lower precedence, // but can be shared across the multi projects. ThisBuild / version := { - val v = "1.9.4-SNAPSHOT" + val v = "1.9.5-SNAPSHOT" nightlyVersion.getOrElse(v) } ThisBuild / version2_13 := "2.0.0-SNAPSHOT" diff --git a/sbt b/sbt index e7697e190..994c5e68f 100755 --- a/sbt +++ b/sbt @@ -1,7 +1,7 @@ #!/usr/bin/env bash set +e -declare builtin_sbt_version="1.9.3" +declare builtin_sbt_version="1.9.4" declare -a residual_args declare -a java_args declare -a scalac_args From 7c400081a1151433f5b8681cb95fc3904d958f10 Mon Sep 17 00:00:00 2001 From: azdrojowa123 <33667003+azdrojowa123@users.noreply.github.com> Date: Fri, 25 Aug 2023 18:01:49 +0200 Subject: [PATCH 09/19] Fix help command for shells (#7358) * sbt-help-fix * fix BasicCommands.scala formatting --- main-command/src/main/scala/sbt/BasicCommands.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/main-command/src/main/scala/sbt/BasicCommands.scala b/main-command/src/main/scala/sbt/BasicCommands.scala index 238c2bfca..030c778dd 100644 --- a/main-command/src/main/scala/sbt/BasicCommands.scala +++ b/main-command/src/main/scala/sbt/BasicCommands.scala @@ -129,8 +129,8 @@ object BasicCommands { def runHelp(s: State, h: Help)(arg: Option[String]): State = { val (extraArgs, remainingCommands) = s.remainingCommands match { - case xs :+ exec if exec.commandLine == "shell" => (xs, exec :: Nil) - case xs => (xs, nil[Exec]) + case xs :+ exec if exec.commandLine.endsWith(Shell) => (xs, exec :: Nil) + case xs => (xs, nil[Exec]) } val topic = (arg.toList ++ extraArgs.map(_.commandLine)) match { From bc00cee4df8bda48908699efa852c8c4aa13fb8e Mon Sep 17 00:00:00 2001 From: azdrojowa123 <33667003+azdrojowa123@users.noreply.github.com> Date: Mon, 28 Aug 2023 16:48:06 +0200 Subject: [PATCH 10/19] Add comment to https://github.com/sbt/sbt/pull/7358 (#7362) comment for new condition in sbt.BasicCommands.runHelp --- main-command/src/main/scala/sbt/BasicCommands.scala | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/main-command/src/main/scala/sbt/BasicCommands.scala b/main-command/src/main/scala/sbt/BasicCommands.scala index 030c778dd..dde64c8c2 100644 --- a/main-command/src/main/scala/sbt/BasicCommands.scala +++ b/main-command/src/main/scala/sbt/BasicCommands.scala @@ -129,6 +129,10 @@ object BasicCommands { def runHelp(s: State, h: Help)(arg: Option[String]): State = { val (extraArgs, remainingCommands) = s.remainingCommands match { + /* + exec.commandLine.endsWith(Shell) is done to allow shells other than original shell works correctly with help command. + It's assumed here that shell name must end with "shell" suffix which is true for e.g. shell, oldshell or idea-shell (https://github.com/JetBrains/sbt-idea-shell/blob/072b10e405860feb834402563773f12976be34b9/src/main/scala/org/jetbrains/sbt/constants.scala#L7) + */ case xs :+ exec if exec.commandLine.endsWith(Shell) => (xs, exec :: Nil) case xs => (xs, nil[Exec]) } From bc93eceff7179442c0e3525106c5f6a8ce30ab70 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Costa?= Date: Wed, 6 Sep 2023 16:34:02 +0200 Subject: [PATCH 11/19] Fix java opts load order on windows --- launcher-package/src/universal/bin/sbt.bat | 28 ++++++++++++---------- 1 file changed, 15 insertions(+), 13 deletions(-) diff --git a/launcher-package/src/universal/bin/sbt.bat b/launcher-package/src/universal/bin/sbt.bat index f44af2219..dc1f3c8a1 100755 --- a/launcher-package/src/universal/bin/sbt.bat +++ b/launcher-package/src/universal/bin/sbt.bat @@ -112,20 +112,22 @@ if not defined _JAVACMD ( if not defined _JAVACMD set _JAVACMD=java -rem users can set JAVA_OPTS via .jvmopts (sbt-extras style) -if exist .jvmopts for /F %%A in (.jvmopts) do ( - set _jvmopts_line=%%A - if not "!_jvmopts_line:~0,1!" == "#" ( - if defined _JAVA_OPTS ( - set _JAVA_OPTS=!_JAVA_OPTS! %%A - ) else ( - set _JAVA_OPTS=%%A - ) - ) -) +rem We use the value of the JAVA_OPTS environment variable if defined, rather than the config. +if not defined _JAVA_OPTS if defined JAVA_OPTS set _JAVA_OPTS=%JAVA_OPTS% -rem We use the value of the JAVA_OPTS environment variable if defined, rather than the config. -if not defined _JAVA_OPTS if defined JAVA_OPTS set _JAVA_OPTS=%JAVA_OPTS% +rem users can set JAVA_OPTS via .jvmopts (sbt-extras style) +if exist .jvmopts for /F %%A in (.jvmopts) do ( + set _jvmopts_line=%%A + if not "!_jvmopts_line:~0,1!" == "#" ( + if defined _JAVA_OPTS ( + set _JAVA_OPTS=!_JAVA_OPTS! %%A + ) else ( + set _JAVA_OPTS=%%A + ) + ) +) + +rem If nothing is defined, use the defaults. if not defined _JAVA_OPTS if defined default_java_opts set _JAVA_OPTS=!default_java_opts! rem We use the value of the SBT_OPTS environment variable if defined, rather than the config. From a5f0b37728750b5e826c6fd947da506390ef3f60 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 11 Sep 2023 04:39:58 +0000 Subject: [PATCH 12/19] Bump actions/checkout from 3 to 4 Bumps [actions/checkout](https://github.com/actions/checkout) from 3 to 4. - [Release notes](https://github.com/actions/checkout/releases) - [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md) - [Commits](https://github.com/actions/checkout/compare/v3...v4) --- updated-dependencies: - dependency-name: actions/checkout dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] --- .github/workflows/ci.yml | 8 ++++---- .github/workflows/cla.yml | 2 +- .github/workflows/dependency-graph.yml | 2 +- .github/workflows/nightly.yml | 8 ++++---- 4 files changed, 10 insertions(+), 10 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 746cadd5e..acbf5bf73 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -63,21 +63,21 @@ jobs: SPARK_LOCAL_IP: "127.0.0.1" steps: - name: Checkout sbt/sbt - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Checkout sbt/io - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: repository: sbt/io ref: develop path: io - name: Checkout sbt/librarymanagement - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: repository: sbt/librarymanagement ref: develop path: librarymanagement - name: Checkout sbt/zinc - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: repository: sbt/zinc ref: develop diff --git a/.github/workflows/cla.yml b/.github/workflows/cla.yml index abbf9f3ba..f9ead39fd 100644 --- a/.github/workflows/cla.yml +++ b/.github/workflows/cla.yml @@ -4,7 +4,7 @@ jobs: check: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - name: Check CLA env: AUTHOR: ${{ github.event.pull_request.user.login }} diff --git a/.github/workflows/dependency-graph.yml b/.github/workflows/dependency-graph.yml index 391176fb3..8e5f9dc7a 100644 --- a/.github/workflows/dependency-graph.yml +++ b/.github/workflows/dependency-graph.yml @@ -12,5 +12,5 @@ jobs: name: Submit Dependency Graph runs-on: ubuntu-latest # or windows-latest, or macOS-latest steps: - - uses: actions/checkout@v3 + - uses: actions/checkout@v4 - uses: scalacenter/sbt-dependency-submission@v2 diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 500f02eaa..88e6f48c1 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -21,21 +21,21 @@ jobs: JAVA_OPTS: -Xms800M -Xmx800M -Xss6M -XX:ReservedCodeCacheSize=128M -server -Dsbt.io.virtual=false -Dfile.encoding=UTF-8 steps: - name: Checkout sbt/sbt - uses: actions/checkout@v3 + uses: actions/checkout@v4 - name: Checkout sbt/io - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: repository: sbt/io ref: develop path: io - name: Checkout sbt/librarymanagement - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: repository: sbt/librarymanagement ref: develop path: librarymanagement - name: Checkout sbt/zinc - uses: actions/checkout@v3 + uses: actions/checkout@v4 with: repository: sbt/zinc ref: develop From b1e9308ebe4c10c3457d730e0f19cdaee12834c7 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Mon, 11 Sep 2023 23:15:15 -0400 Subject: [PATCH 13/19] Use binary compiler bridge Problem ------- Starting Scala 2.13.12, Scala 2 has in-sourced the compiler bridge implementtion, which hopefully will be kept up to date more than the ones in Zinc. Solution -------- This switches to using the pre-compiled compiler bridge for >=2.13.12. --- main/src/main/scala/sbt/Defaults.scala | 4 +++- sbt-app/src/sbt-test/actions/cross-advanced/build.sbt | 7 ++++--- sbt-app/src/sbt-test/actions/cross-advanced/test | 2 +- .../src/sbt-test/actions/cross-incremental/build.sbt | 2 +- .../src/sbt-test/actions/cross-multiproject/build.sbt | 2 +- sbt-app/src/sbt-test/actions/cross-multiproject/test | 2 +- .../actions/cross-strict-aggregation/build.sbt | 2 +- .../sbt-test/actions/cross-strict-aggregation/test | 2 +- sbt-app/src/sbt-test/actions/doc/build.sbt | 2 +- .../separate-analysis-per-scala/build.sbt | 2 +- .../console/project-compiler-bridge/build.sbt | 2 +- .../dependency-graph/asciiGraphWidth/build.sbt | 2 +- .../build.sbt | 2 +- .../sbt-test/dependency-graph/whatDependsOn/build.sbt | 2 +- .../sbt-test/dependency-management/cp-order/build.sbt | 2 +- .../dependency-management/credentials/build.sbt | 2 +- .../evicted-semver-spec/build.sbt | 2 +- .../dependency-management/missingok/build.sbt | 2 +- .../src/sbt-test/plugins/dotty-sandwich-sjs/build.sbt | 2 +- sbt-app/src/sbt-test/plugins/dotty-sandwich/build.sbt | 2 +- sbt-app/src/sbt-test/project/val-order/build.sbt | 2 +- .../src/sbt-test/source-dependencies/constants/test | 2 +- .../source-dependencies/pipelining-java/build.sbt | 2 +- .../sbt-test/source-dependencies/pipelining/build.sbt | 2 +- sbt-app/src/sbt-test/tests/hedgehog/build.sbt | 2 +- sbt-app/src/sbt-test/tests/scalatest/build.sbt | 2 +- sbt-app/src/sbt-test/tests/weaver-cats/build.sbt | 2 +- sbt-app/src/sbt-test/tests/zio-test/build.sbt | 2 +- .../src/main/scala/sbt/internal/inc/ZincLmUtil.scala | 11 ++++++++++- 29 files changed, 43 insertions(+), 31 deletions(-) diff --git a/main/src/main/scala/sbt/Defaults.scala b/main/src/main/scala/sbt/Defaults.scala index e7a601c30..8a8728892 100644 --- a/main/src/main/scala/sbt/Defaults.scala +++ b/main/src/main/scala/sbt/Defaults.scala @@ -715,7 +715,9 @@ object Defaults extends BuildCommon { clean := clean.dependsOn(cleanIvy).value, scalaCompilerBridgeBinaryJar := Def.settingDyn { val sv = scalaVersion.value - if (ScalaArtifacts.isScala3(sv)) fetchBridgeBinaryJarTask(sv) + if (ScalaArtifacts.isScala3(sv) || VersionNumber(sv) + .matchesSemVer(SemanticSelector(s"=2.13 >=${ZincLmUtil.scala2SbtBridgeStart}"))) + fetchBridgeBinaryJarTask(sv) else Def.task[Option[File]](None) }.value, scalaCompilerBridgeSource := ZincLmUtil.getDefaultBridgeSourceModule(scalaVersion.value), 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 c9ad52715..e84586e99 100644 --- a/sbt-app/src/sbt-test/actions/cross-advanced/build.sbt +++ b/sbt-app/src/sbt-test/actions/cross-advanced/build.sbt @@ -1,6 +1,7 @@ lazy val check = taskKey[Unit]("") lazy val compile2 = taskKey[Unit]("") lazy val scala212 = "2.12.18" +lazy val scala213 = "2.13.12" lazy val root = (project in file(".")) .aggregate(foo, bar, client) @@ -11,7 +12,7 @@ lazy val root = (project in file(".")) lazy val foo = project .settings( - crossScalaVersions := Seq(scala212, "2.13.11"), + crossScalaVersions := Seq(scala212, scala213), libraryDependencies += "org.scalatest" %% "scalatest" % "3.1.0", check := { @@ -43,7 +44,7 @@ lazy val bar = project lazy val baz = project .settings( - crossScalaVersions := Seq("2.13.11"), + crossScalaVersions := Seq(scala213), check := { // This tests that +baz/check will respect bar's crossScalaVersions and not switch val x = (LocalProject("bar") / scalaVersion).value @@ -54,7 +55,7 @@ lazy val baz = project lazy val client = project .settings( - crossScalaVersions := Seq(scala212, "2.13.11"), + crossScalaVersions := Seq(scala212, scala213), 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 e413a129a..15c90ead4 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.18", "2.13.11") +> set root/crossScalaVersions := Seq("2.12.18", "2.13.12") > + build $ exists foo/target/scala-2.12 $ exists foo/target/scala-2.13 diff --git a/sbt-app/src/sbt-test/actions/cross-incremental/build.sbt b/sbt-app/src/sbt-test/actions/cross-incremental/build.sbt index 5554632a2..8176b96da 100644 --- a/sbt-app/src/sbt-test/actions/cross-incremental/build.sbt +++ b/sbt-app/src/sbt-test/actions/cross-incremental/build.sbt @@ -1,5 +1,5 @@ scalaVersion := "2.12.18" -crossScalaVersions := List("2.12.18", "2.13.11") +crossScalaVersions := List("2.12.18", "2.13.12") val setLastModified = taskKey[Unit]("Sets the last modified time for classfiles") setLastModified := { diff --git a/sbt-app/src/sbt-test/actions/cross-multiproject/build.sbt b/sbt-app/src/sbt-test/actions/cross-multiproject/build.sbt index c4c532266..1b411f1db 100644 --- a/sbt-app/src/sbt-test/actions/cross-multiproject/build.sbt +++ b/sbt-app/src/sbt-test/actions/cross-multiproject/build.sbt @@ -1,5 +1,5 @@ lazy val scala212 = "2.12.18" -lazy val scala213 = "2.13.11" +lazy val scala213 = "2.13.12" ThisBuild / crossScalaVersions := Seq(scala212, scala213) ThisBuild / scalaVersion := scala212 diff --git a/sbt-app/src/sbt-test/actions/cross-multiproject/test b/sbt-app/src/sbt-test/actions/cross-multiproject/test index c39be13ba..699f1221c 100644 --- a/sbt-app/src/sbt-test/actions/cross-multiproject/test +++ b/sbt-app/src/sbt-test/actions/cross-multiproject/test @@ -36,7 +36,7 @@ $ exists extras/target/scala-2.12 # test safe switching > clean -> ++ 2.13.11 -v compile +> ++ 2.13.12 -v compile $ exists lib/target/scala-2.13 -$ exists lib/target/scala-2.12 # -$ exists sbt-foo/target/scala-2.12 diff --git a/sbt-app/src/sbt-test/actions/cross-strict-aggregation/build.sbt b/sbt-app/src/sbt-test/actions/cross-strict-aggregation/build.sbt index 374a3d6ab..7eb67145a 100644 --- a/sbt-app/src/sbt-test/actions/cross-strict-aggregation/build.sbt +++ b/sbt-app/src/sbt-test/actions/cross-strict-aggregation/build.sbt @@ -1,5 +1,5 @@ lazy val scala212 = "2.12.18" -lazy val scala213 = "2.13.11" +lazy val scala213 = "2.13.12" ThisBuild / scalaVersion := scala212 diff --git a/sbt-app/src/sbt-test/actions/cross-strict-aggregation/test b/sbt-app/src/sbt-test/actions/cross-strict-aggregation/test index c52d1275a..7d4933f36 100644 --- a/sbt-app/src/sbt-test/actions/cross-strict-aggregation/test +++ b/sbt-app/src/sbt-test/actions/cross-strict-aggregation/test @@ -4,7 +4,7 @@ > clean -> ++2.13.11 compile +> ++2.13.12 compile $ exists core/target/scala-2.13 -$ exists module/target/scala-2.13 diff --git a/sbt-app/src/sbt-test/actions/doc/build.sbt b/sbt-app/src/sbt-test/actions/doc/build.sbt index 3bfa108cd..fbf26e66f 100644 --- a/sbt-app/src/sbt-test/actions/doc/build.sbt +++ b/sbt-app/src/sbt-test/actions/doc/build.sbt @@ -5,7 +5,7 @@ import Parsers._ lazy val root = (project in file(".")) .settings( crossPaths := false, - crossScalaVersions := Seq("2.12.18", "2.13.11"), + crossScalaVersions := Seq("2.12.18", "2.13.12"), scalaVersion := "2.12.18", Compile / doc / scalacOptions += "-Xfatal-warnings", commands += Command.command("excludeB") { s => diff --git a/sbt-app/src/sbt-test/compiler-project/separate-analysis-per-scala/build.sbt b/sbt-app/src/sbt-test/compiler-project/separate-analysis-per-scala/build.sbt index 6b4c2e3ba..33657a7c4 100644 --- a/sbt-app/src/sbt-test/compiler-project/separate-analysis-per-scala/build.sbt +++ b/sbt-app/src/sbt-test/compiler-project/separate-analysis-per-scala/build.sbt @@ -1,5 +1,5 @@ lazy val scala212 = "2.12.18" -lazy val scala213 = "2.13.11" +lazy val scala213 = "2.13.12" ThisBuild / scalaVersion := scala212 lazy val root = (project in file(".")) diff --git a/sbt-app/src/sbt-test/console/project-compiler-bridge/build.sbt b/sbt-app/src/sbt-test/console/project-compiler-bridge/build.sbt index 35363129b..0843374a5 100644 --- a/sbt-app/src/sbt-test/console/project-compiler-bridge/build.sbt +++ b/sbt-app/src/sbt-test/console/project-compiler-bridge/build.sbt @@ -1,4 +1,4 @@ -scalaVersion := "2.13.11" +scalaVersion := "2.13.12" // Send some bogus initial command so that it doesn't get stuck. // The task itself will still succeed. diff --git a/sbt-app/src/sbt-test/dependency-graph/asciiGraphWidth/build.sbt b/sbt-app/src/sbt-test/dependency-graph/asciiGraphWidth/build.sbt index 698b97b4e..167083797 100644 --- a/sbt-app/src/sbt-test/dependency-graph/asciiGraphWidth/build.sbt +++ b/sbt-app/src/sbt-test/dependency-graph/asciiGraphWidth/build.sbt @@ -1,5 +1,5 @@ ThisBuild / version := "0.1.0-SNAPSHOT" -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" name := "asciiGraphWidthSpecs" diff --git a/sbt-app/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/build.sbt b/sbt-app/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/build.sbt index a7bcd4c9f..1c7a78e3f 100644 --- a/sbt-app/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/build.sbt +++ b/sbt-app/src/sbt-test/dependency-graph/whatDependsOn-without-previous-initialization/build.sbt @@ -1,5 +1,5 @@ ThisBuild / version := "0.1.0-SNAPSHOT" -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" name := "whatDependsOn" diff --git a/sbt-app/src/sbt-test/dependency-graph/whatDependsOn/build.sbt b/sbt-app/src/sbt-test/dependency-graph/whatDependsOn/build.sbt index a7bcd4c9f..1c7a78e3f 100644 --- a/sbt-app/src/sbt-test/dependency-graph/whatDependsOn/build.sbt +++ b/sbt-app/src/sbt-test/dependency-graph/whatDependsOn/build.sbt @@ -1,5 +1,5 @@ ThisBuild / version := "0.1.0-SNAPSHOT" -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" name := "whatDependsOn" diff --git a/sbt-app/src/sbt-test/dependency-management/cp-order/build.sbt b/sbt-app/src/sbt-test/dependency-management/cp-order/build.sbt index e075e4fd0..2764be76f 100644 --- a/sbt-app/src/sbt-test/dependency-management/cp-order/build.sbt +++ b/sbt-app/src/sbt-test/dependency-management/cp-order/build.sbt @@ -1,4 +1,4 @@ -scalaVersion := "2.13.11" +scalaVersion := "2.13.12" csrConfiguration := csrConfiguration.value.withCache(target.value / "coursier-cache") libraryDependencies += "com.typesafe.play" %% "play-test" % "2.8.0-RC1" % Test // worked around in 2.8.0 diff --git a/sbt-app/src/sbt-test/dependency-management/credentials/build.sbt b/sbt-app/src/sbt-test/dependency-management/credentials/build.sbt index 867786f77..32b6610dc 100644 --- a/sbt-app/src/sbt-test/dependency-management/credentials/build.sbt +++ b/sbt-app/src/sbt-test/dependency-management/credentials/build.sbt @@ -1,4 +1,4 @@ -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache" ivyPaths := IvyPaths(baseDirectory.value, Some(target.value / "ivy-cache")) diff --git a/sbt-app/src/sbt-test/dependency-management/evicted-semver-spec/build.sbt b/sbt-app/src/sbt-test/dependency-management/evicted-semver-spec/build.sbt index 073028662..71d49afbf 100644 --- a/sbt-app/src/sbt-test/dependency-management/evicted-semver-spec/build.sbt +++ b/sbt-app/src/sbt-test/dependency-management/evicted-semver-spec/build.sbt @@ -1,7 +1,7 @@ import xsbti.AppConfiguration // ThisBuild / useCoursier := false ThisBuild / organization := "com.example" -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" ThisBuild / versionScheme := Some("semver-spec") ThisBuild / csrCacheDirectory := (ThisBuild / baseDirectory).value / "coursier-cache" diff --git a/sbt-app/src/sbt-test/dependency-management/missingok/build.sbt b/sbt-app/src/sbt-test/dependency-management/missingok/build.sbt index 8b24e0d5e..aa97b584f 100644 --- a/sbt-app/src/sbt-test/dependency-management/missingok/build.sbt +++ b/sbt-app/src/sbt-test/dependency-management/missingok/build.sbt @@ -1,4 +1,4 @@ -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" libraryDependencies ++= Seq( "com.chuusai" %% "shapeless" % "2.3.3", // non-existing diff --git a/sbt-app/src/sbt-test/plugins/dotty-sandwich-sjs/build.sbt b/sbt-app/src/sbt-test/plugins/dotty-sandwich-sjs/build.sbt index c7b8ec465..5fd5c06b8 100644 --- a/sbt-app/src/sbt-test/plugins/dotty-sandwich-sjs/build.sbt +++ b/sbt-app/src/sbt-test/plugins/dotty-sandwich-sjs/build.sbt @@ -1,4 +1,4 @@ -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" ThisBuild / scalacOptions += "-Ytasty-reader" lazy val scala3code = project diff --git a/sbt-app/src/sbt-test/plugins/dotty-sandwich/build.sbt b/sbt-app/src/sbt-test/plugins/dotty-sandwich/build.sbt index dc5cfcb3d..a8e206007 100644 --- a/sbt-app/src/sbt-test/plugins/dotty-sandwich/build.sbt +++ b/sbt-app/src/sbt-test/plugins/dotty-sandwich/build.sbt @@ -1,7 +1,7 @@ ThisBuild / scalaVersion := "3.1.3" ThisBuild / scalacOptions += "-Ytasty-reader" -lazy val scala213 = "2.13.11" +lazy val scala213 = "2.13.12" lazy val root = (project in file(".")) .aggregate(fooApp, fooCore, barApp, barCore) diff --git a/sbt-app/src/sbt-test/project/val-order/build.sbt b/sbt-app/src/sbt-test/project/val-order/build.sbt index 43de68746..683c645b6 100644 --- a/sbt-app/src/sbt-test/project/val-order/build.sbt +++ b/sbt-app/src/sbt-test/project/val-order/build.sbt @@ -1,4 +1,4 @@ -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" ThisBuild / version := "0.1.0-SNAPSHOT" lazy val check = taskKey[Unit]("") diff --git a/sbt-app/src/sbt-test/source-dependencies/constants/test b/sbt-app/src/sbt-test/source-dependencies/constants/test index d1b542f86..f3da8143a 100644 --- a/sbt-app/src/sbt-test/source-dependencies/constants/test +++ b/sbt-app/src/sbt-test/source-dependencies/constants/test @@ -8,7 +8,7 @@ $ copy-file changes/A2.scala A.scala > run 2 > clean -> ++2.13.11! +> ++2.13.12! $ copy-file changes/A1.scala A.scala > run 1 diff --git a/sbt-app/src/sbt-test/source-dependencies/pipelining-java/build.sbt b/sbt-app/src/sbt-test/source-dependencies/pipelining-java/build.sbt index 220f54838..7c8f19928 100644 --- a/sbt-app/src/sbt-test/source-dependencies/pipelining-java/build.sbt +++ b/sbt-app/src/sbt-test/source-dependencies/pipelining-java/build.sbt @@ -1,4 +1,4 @@ -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" ThisBuild / usePipelining := true lazy val root = (project in file(".")) diff --git a/sbt-app/src/sbt-test/source-dependencies/pipelining/build.sbt b/sbt-app/src/sbt-test/source-dependencies/pipelining/build.sbt index e35910cc1..96b5b5a17 100644 --- a/sbt-app/src/sbt-test/source-dependencies/pipelining/build.sbt +++ b/sbt-app/src/sbt-test/source-dependencies/pipelining/build.sbt @@ -1,4 +1,4 @@ -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" ThisBuild / usePipelining := true lazy val root = (project in file(".")) diff --git a/sbt-app/src/sbt-test/tests/hedgehog/build.sbt b/sbt-app/src/sbt-test/tests/hedgehog/build.sbt index 61ed9f03c..dc0a0b0ed 100644 --- a/sbt-app/src/sbt-test/tests/hedgehog/build.sbt +++ b/sbt-app/src/sbt-test/tests/hedgehog/build.sbt @@ -1,4 +1,4 @@ -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" val hedgehogVersion = "0.10.0" diff --git a/sbt-app/src/sbt-test/tests/scalatest/build.sbt b/sbt-app/src/sbt-test/tests/scalatest/build.sbt index 44d5653a0..8ec076ab9 100644 --- a/sbt-app/src/sbt-test/tests/scalatest/build.sbt +++ b/sbt-app/src/sbt-test/tests/scalatest/build.sbt @@ -1,4 +1,4 @@ -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" ThisBuild / version := "0.1.0-SNAPSHOT" ThisBuild / organization := "com.example" ThisBuild / organizationName := "example" diff --git a/sbt-app/src/sbt-test/tests/weaver-cats/build.sbt b/sbt-app/src/sbt-test/tests/weaver-cats/build.sbt index 12ded730a..eb9ab64ca 100644 --- a/sbt-app/src/sbt-test/tests/weaver-cats/build.sbt +++ b/sbt-app/src/sbt-test/tests/weaver-cats/build.sbt @@ -1,3 +1,3 @@ -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" libraryDependencies += "com.disneystreaming" %% "weaver-cats" % "0.8.3" % Test diff --git a/sbt-app/src/sbt-test/tests/zio-test/build.sbt b/sbt-app/src/sbt-test/tests/zio-test/build.sbt index 31c84bf49..60996aead 100644 --- a/sbt-app/src/sbt-test/tests/zio-test/build.sbt +++ b/sbt-app/src/sbt-test/tests/zio-test/build.sbt @@ -1,4 +1,4 @@ -ThisBuild / scalaVersion := "2.13.11" +ThisBuild / scalaVersion := "2.13.12" libraryDependencies += "dev.zio" %% "zio-test" % "2.0.2" % Test libraryDependencies += "dev.zio" %% "zio-test-sbt" % "2.0.2" % Test diff --git a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala index 31e558486..a15473901 100644 --- a/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala +++ b/zinc-lm-integration/src/main/scala/sbt/internal/inc/ZincLmUtil.scala @@ -15,8 +15,10 @@ import sbt.librarymanagement.{ DependencyResolution, ModuleID, ScalaArtifacts, + SemanticSelector, UnresolvedWarningConfiguration, - UpdateConfiguration + UpdateConfiguration, + VersionNumber, } import sbt.librarymanagement.syntax._ import xsbti.ArtifactInfo.SbtOrganization @@ -25,6 +27,8 @@ import xsbti.compile.{ ClasspathOptions, ScalaInstance => XScalaInstance } object ZincLmUtil { + final val scala2SbtBridgeStart = "2.13.12" + /** * Instantiate a Scala compiler that is instrumented to analyze dependencies. * This Scala compiler is useful to create your own instance of incremental @@ -86,6 +90,11 @@ object ZincLmUtil { if (ScalaArtifacts.isScala3(scalaVersion)) { ModuleID(ScalaArtifacts.Organization, "scala3-sbt-bridge", scalaVersion) .withConfigurations(Some(Compile.name)) + } else if (VersionNumber(scalaVersion).matchesSemVer( + SemanticSelector(s"=2.13 >=$scala2SbtBridgeStart") + )) { + ModuleID(ScalaArtifacts.Organization, "scala2-sbt-bridge", scalaVersion) + .withConfigurations(Some(Compile.name)) } else { val compilerBridgeId = scalaVersion match { case sc if sc startsWith "2.10." => "compiler-bridge_2.10" From 47344d264d430519cc325df44e10686e4bc6047b Mon Sep 17 00:00:00 2001 From: Matthew de Detrich Date: Wed, 13 Sep 2023 22:34:41 +0200 Subject: [PATCH 14/19] Remove invalid test --- .github/workflows/ci.yml | 1 - .../src/test/scala/xsbt/IPCSpec.scala | 23 ------------------- 2 files changed, 24 deletions(-) delete mode 100644 main-command/src/test/scala/xsbt/IPCSpec.scala diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index a6fddebb6..acbf5bf73 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -186,7 +186,6 @@ jobs: shell: bash run: | # test building sbtn on Windows - sbt "commandProj/testOnly xsbt.IPCSpec" sbt "-Dsbt.io.virtual=false" nativeImage # test launcher script echo build using JDK 8, test using JDK 8, on Windows diff --git a/main-command/src/test/scala/xsbt/IPCSpec.scala b/main-command/src/test/scala/xsbt/IPCSpec.scala deleted file mode 100644 index dfeb1dc4f..000000000 --- a/main-command/src/test/scala/xsbt/IPCSpec.scala +++ /dev/null @@ -1,23 +0,0 @@ -/* - * sbt - * Copyright 2011 - 2018, Lightbend, Inc. - * Copyright 2008 - 2010, Mark Harrah - * Licensed under Apache License 2.0 (see LICENSE) - */ - -package xsbt - -import org.scalatest.flatspec.AnyFlatSpec -import org.scalatest.matchers.should.Matchers._ - -class IPCSpec extends AnyFlatSpec { - "server" should "allow same number of connections as determined in socket backlog" in { - noException should be thrownBy { - val server = IPC.unmanagedServer - (1 until IPC.socketBacklog + 1).foreach { _ => - IPC.client(server.port)(identity) - } - server.close() - } - } -} From c551c0fbcd477f85852a64f9ed012c961297be43 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Wed, 13 Sep 2023 22:54:46 -0400 Subject: [PATCH 15/19] Zinc 1.9.4 --- .github/workflows/ci.yml | 7 +++---- project/Dependencies.scala | 6 +++--- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index acbf5bf73..3c4913f7c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -53,7 +53,6 @@ jobs: 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.18 - SCALA_213: 2.13.11 SCALA_3: 3.1.0 UTIL_TESTS: "utilCache/test utilControl/test utilInterface/test utilLogging/test utilPosition/test utilRelation/test utilScripted/test utilTracking/test" SBT_LOCAL: false @@ -120,7 +119,7 @@ jobs: ./sbt -v --client "serverTestProj/test" ./sbt -v --client doc ./sbt -v --client "all $UTIL_TESTS" - ./sbt -v --client ++$SCALA_213 + ./sbt -v --client ++2.13.x ./sbt -v --client "all $UTIL_TESTS" - name: Build and test (2) if: ${{ matrix.jobtype == 2 }} @@ -141,7 +140,7 @@ jobs: if: ${{ matrix.jobtype == 5 }} shell: bash run: | - ./sbt -v "++$SCALA_213!; test; ++$SCALA_3!; all utilControl/test utilRelation/test utilPosition/test" + ./sbt -v "++2.13.x; all utilControl/test utilRelation/test utilPosition/test; ++$SCALA_3!; all utilControl/test utilRelation/test utilPosition/test" - name: Build and test (6) if: ${{ matrix.jobtype == 6 }} shell: bash @@ -153,7 +152,7 @@ jobs: cd ../ sbt -Dsbtlm.path=$HOME/work/sbt/sbt/librarymanagement -Dsbtzinc.path=$HOME/work/sbt/sbt/zinc -Dsbt.build.version=$BUILD_VERSION -Dsbt.build.fatal=false "+lowerUtils/publishLocal; {librarymanagement}/publishLocal; {zinc}/publishLocal; upperModules/publishLocal" rm -r $(find $HOME/.sbt/boot -name "*-SNAPSHOT") || true - sbt -v -Dsbt.version=$BUILD_VERSION "++$SCALA_213; all $UTIL_TESTS; ++$SCALA_212; all $UTIL_TESTS; scripted actions/* source-dependencies/*1of3 dependency-management/*1of4 java/*" + sbt -v -Dsbt.version=$BUILD_VERSION "++2.13.x; all $UTIL_TESTS; ++$SCALA_212; all $UTIL_TESTS; scripted actions/* source-dependencies/*1of3 dependency-management/*1of4 java/*" - name: Build and test (7) if: ${{ matrix.jobtype == 7 }} shell: bash diff --git a/project/Dependencies.scala b/project/Dependencies.scala index 18af50955..b152ebfeb 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -5,7 +5,7 @@ import sbt.contraband.ContrabandPlugin.autoImport._ object Dependencies { // WARNING: Please Scala update versions in PluginCross.scala too val scala212 = "2.12.18" - val scala213 = "2.13.11" + val scala213 = "2.13.12" val checkPluginCross = settingKey[Unit]("Make sure scalaVersion match up") val baseScalaVersion = scala212 def nightlyVersion: Option[String] = @@ -14,8 +14,8 @@ object Dependencies { // sbt modules private val ioVersion = nightlyVersion.getOrElse("1.9.1") private val lmVersion = - sys.props.get("sbt.build.lm.version").orElse(nightlyVersion).getOrElse("1.9.2") - val zincVersion = nightlyVersion.getOrElse("1.9.3") + sys.props.get("sbt.build.lm.version").orElse(nightlyVersion).getOrElse("1.9.3") + val zincVersion = nightlyVersion.getOrElse("1.9.4") private val sbtIO = "org.scala-sbt" %% "io" % ioVersion From c532d7e69f05b05ef15ecd328ceec36b0d107466 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Thu, 14 Sep 2023 00:56:37 -0400 Subject: [PATCH 16/19] sbt 1.9.5 --- build.sbt | 2 +- sbt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/build.sbt b/build.sbt index 9cd3bcaef..21dc04ef2 100644 --- a/build.sbt +++ b/build.sbt @@ -11,7 +11,7 @@ import scala.util.Try // ThisBuild settings take lower precedence, // but can be shared across the multi projects. ThisBuild / version := { - val v = "1.9.5-SNAPSHOT" + val v = "1.9.6-SNAPSHOT" nightlyVersion.getOrElse(v) } ThisBuild / version2_13 := "2.0.0-SNAPSHOT" diff --git a/sbt b/sbt index 994c5e68f..ccffe917e 100755 --- a/sbt +++ b/sbt @@ -1,7 +1,7 @@ #!/usr/bin/env bash set +e -declare builtin_sbt_version="1.9.4" +declare builtin_sbt_version="1.9.5" declare -a residual_args declare -a java_args declare -a scalac_args From 4701bf767716758088f72ce44d388e33104af9d3 Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 15 Sep 2023 10:35:54 -0400 Subject: [PATCH 17/19] Zinc 1.9.5 --- project/Dependencies.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/project/Dependencies.scala b/project/Dependencies.scala index b152ebfeb..a9cfdfbca 100644 --- a/project/Dependencies.scala +++ b/project/Dependencies.scala @@ -15,7 +15,7 @@ object Dependencies { private val ioVersion = nightlyVersion.getOrElse("1.9.1") private val lmVersion = sys.props.get("sbt.build.lm.version").orElse(nightlyVersion).getOrElse("1.9.3") - val zincVersion = nightlyVersion.getOrElse("1.9.4") + val zincVersion = nightlyVersion.getOrElse("1.9.5") private val sbtIO = "org.scala-sbt" %% "io" % ioVersion From ef8652f93a06bdf24435ec2dd459a7055adab1db Mon Sep 17 00:00:00 2001 From: Eugene Yokota Date: Fri, 15 Sep 2023 11:57:17 -0400 Subject: [PATCH 18/19] sbt 1.9.6 --- build.sbt | 2 +- sbt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/build.sbt b/build.sbt index 21dc04ef2..1199e135b 100644 --- a/build.sbt +++ b/build.sbt @@ -11,7 +11,7 @@ import scala.util.Try // ThisBuild settings take lower precedence, // but can be shared across the multi projects. ThisBuild / version := { - val v = "1.9.6-SNAPSHOT" + val v = "1.9.7-SNAPSHOT" nightlyVersion.getOrElse(v) } ThisBuild / version2_13 := "2.0.0-SNAPSHOT" diff --git a/sbt b/sbt index ccffe917e..01bdeb220 100755 --- a/sbt +++ b/sbt @@ -1,7 +1,7 @@ #!/usr/bin/env bash set +e -declare builtin_sbt_version="1.9.5" +declare builtin_sbt_version="1.9.6" declare -a residual_args declare -a java_args declare -a scalac_args From 8ce5f2e336279803184f9fcb9c952803385ae5d6 Mon Sep 17 00:00:00 2001 From: Matthew de Detrich Date: Fri, 15 Sep 2023 20:48:49 +0200 Subject: [PATCH 19/19] Document scriptedSbt --- main/src/main/scala/sbt/ScriptedPlugin.scala | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main/src/main/scala/sbt/ScriptedPlugin.scala b/main/src/main/scala/sbt/ScriptedPlugin.scala index 00bc687bf..85f8c9181 100644 --- a/main/src/main/scala/sbt/ScriptedPlugin.scala +++ b/main/src/main/scala/sbt/ScriptedPlugin.scala @@ -36,7 +36,7 @@ object ScriptedPlugin extends AutoPlugin { val ScriptedConf = Configurations.config("scripted-sbt") hide val ScriptedLaunchConf = Configurations.config("scripted-sbt-launch") hide - val scriptedSbt = settingKey[String]("") + val scriptedSbt = settingKey[String]("sbt version that is used when running scripted tests") val sbtLauncher = taskKey[File]("") val sbtTestDirectory = settingKey[File]("") val scriptedBufferLog = settingKey[Boolean]("")