Merge upstream changes

.git-blame-ignore-revs

@@ -3,3 +3,6 @@
 
 # Scala Steward: Reformat with scalafmt 3.6.1
 77bc6a5845189a9659476d29fd7c02be5327ab8a
+
+# Scala Steward: Reformat with scalafmt 3.7.0
+938cf56606b4900cbd7679725441fbbbe979bcaf

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = "3.6.1"
+version = "3.7.2"
 runner.dialect = scala213
 maxColumn = 100
 docstrings.style = Asterisk

backend/src/main/scala/bloop/task/Task.scala

@@ -132,7 +132,7 @@ sealed trait Task[+A] { self =>
 
   final def transform[R](fa: A => R, fe: Throwable => R): Task[R] =
     Task.Transform(
-      (t: MonixTask[A]) => t.transform(fa, fe),
+      (t: MonixTask[A]) => t.redeem(fe, fa),
       self,
       List.empty
     )
@@ -639,7 +639,7 @@ object Task {
 
   def liftMonixTask[A](t: MonixTask[A], cancel: () => Unit): Task[A] =
     Task.create { (sh, cb) =>
-      t.runAsync(sh)
+      t.runToFuture(sh)
         .onComplete {
           case Success(v) => cb.onSuccess(v)
           case Failure(e) => cb.onError(e)

backend/src/main/scala/bloop/util/Java8Compat.scala

@@ -15,7 +15,7 @@ import scala.util.control.NonFatal
 
 import monix.execution.Cancelable
 import monix.execution.CancelableFuture
-import monix.execution.cancelables.SingleAssignmentCancelable
+import monix.execution.cancelables.SingleAssignCancelable
 import monix.execution.schedulers.TrampolinedRunnable
 
 /**
@@ -58,7 +58,7 @@ object Java8Compat {
   )(implicit ec: ExecutionContext): CancelableFuture[A] = {
 
     val p = Promise[A]()
-    val cRef = SingleAssignmentCancelable()
+    val cRef = SingleAssignCancelable()
 
     // Light async boundary to guard against stack overflows
     ec.execute(new TrampolinedRunnable {

backend/src/main/scala/sbt/internal/inc/bloop/internal/BloopAnalysisCallback.scala

@@ -129,7 +129,7 @@ final class BloopAnalysisCallback(
       val map = if (reported) reportedProblems else unreportedProblems
       map
         .getOrElseUpdate(source.toPath(), new mutable.ListBuffer())
-        .+=(InterfaceUtil.problem(category, pos, msg, severity, None))
+        .+=(InterfaceUtil.problem(category, pos, msg, severity, None, None, Nil))
     }
   }
 

backend/src/main/scala/sbt/internal/inc/bloop/internal/BloopHighLevelCompiler.scala

@@ -133,6 +133,10 @@ final class BloopHighLevelCompiler(
               logger
             )
           } catch {
+            case t: StackOverflowError =>
+              val msg = "Encountered a StackOverflowError coming from the compiler. You might need to restart your Bloop build server"
+              logger.error(s"${msg}:\n${t.getStackTrace().mkString("\n")}")
+              throw new CompileFailed(new Array(0), msg, new Array(0), t)
             case NonFatal(t) =>
               // If scala compilation happens, complete the java promise so that it doesn't block
               JavaCompleted.tryFailure(t)

backend/src/main/scala/sbt/internal/inc/bloop/internal/ConcurrentAnalysisCallback.scala

@@ -134,7 +134,7 @@ final class ConcurrentAnalysisCallback(
       val map = if (reported) reportedProblems else unreportedProblems
       map
         .getOrElseUpdate(source.toPath(), new ConcurrentLinkedQueue)
-        .add(InterfaceUtil.problem(category, pos, msg, severity, None))
+        .add(InterfaceUtil.problem(category, pos, msg, severity, None, None, Nil))
     }
   }
 

backend/src/test/scala/bloop/task/TaskSpec.scala

@@ -128,7 +128,7 @@ class TaskSpec {
           Cancelable.empty
         }
         .runAsync
-    val out = Await.result(future, 1.second)
+    val out = Await.result(future, 1.second).toLong
     assertEquals(out, 42)
   }
 
@@ -141,14 +141,14 @@ class TaskSpec {
       )(_ + _)
       .runAsync
 
-    val out = Await.result(future, 1.second)
+    val out = Await.result(future, 1.second).toLong
     assertEquals(out, 3)
   }
 
   @Test
   def memoize1: Unit = {
     val memoizedTime = Task
-      .create[Long] { (sh, cb) =>
+      .create[Long] { (_, cb) =>
         cb.onSuccess(System.currentTimeMillis())
         Cancelable.empty
       }
@@ -166,7 +166,7 @@ class TaskSpec {
   @Test
   def memoize2: Unit = {
     val memoizedTime = Task
-      .create[Long] { (sh, cb) =>
+      .create[Long] { (_, cb) =>
         cb.onSuccess(System.currentTimeMillis())
         Cancelable.empty
       }

frontend/src/main/scala/bloop/bsp/BloopLanguageClient.scala

@@ -90,8 +90,8 @@ class BloopLanguageClient(
     for {
       id <- response match {
         case Response.None => Some(RequestId.Null)
-        case Response.Success(_, requestId, jsonrpc, _) => Some(requestId)
-        case Response.Error(_, requestId, jsonrpc, _) => Some(requestId)
+        case Response.Success(_, requestId, _, _) => Some(requestId)
+        case Response.Error(_, requestId, _, _) => Some(requestId)
       }
       callback <- activeServerRequests.remove(id).orElse {
         logger.error(s"Response to unknown request: $response")

frontend/src/main/scala/bloop/bsp/BloopRpcServices.scala

@@ -61,7 +61,7 @@ object BloopRpcServices {
           import endpoint.{codecA, codecB}
           val method = endpoint.method
           message match {
-            case Request(`method`, params, id, jsonrpc, headers) =>
+            case Request(`method`, params, id, _, _) =>
               val paramsJson = extractJsonParams(params)
               Try(readFromArray[A](paramsJson.value)) match {
                 case Success(value) =>
@@ -97,14 +97,14 @@ object BloopRpcServices {
           import endpoint.codecA
           val method = endpoint.method
           message match {
-            case Notification(`method`, params, _, headers) =>
+            case Notification(`method`, params, _, _) =>
               val paramsJson = extractJsonParams(params)
               Try(readFromArray[A](paramsJson.value)) match {
-                case Success(value) => f(value).map(a => Response.None)
+                case Success(value) => f(value).map(_ => Response.None)
                 case Failure(err) =>
                   fail(s"Failed to parse notification $message. Params: $paramsJson. Errors: $err")
               }
-            case Notification(invalidMethod, _, _, headers) =>
+            case Notification(invalidMethod, _, _, _) =>
               fail(s"Expected method '$method', obtained '$invalidMethod'")
             case _ => fail(s"Expected notification, obtained $message")
           }

frontend/src/main/scala/bloop/cli/CommonOptions.scala

@@ -30,42 +30,37 @@ case class CommonOptions(
     @Hidden env: CommonOptions.PrettyProperties = CommonOptions.currentEnv
 ) {
   def workingPath: AbsolutePath = AbsolutePath(workingDirectory)
+
+  def withEnv(env: CommonOptions.PrettyProperties): CommonOptions =
+    copy(env = env)
 }
 
 object CommonOptions {
   final val default: CommonOptions = CommonOptions()
 
   // Our own version of properties in which we override `toString`
-  final class PrettyProperties extends Properties {
-    override def toString: String = synchronized {
-      super.keySet().toArray.map(_.toString).mkString(", ")
+  final class PrettyProperties(val toMap: Map[String, String]) {
+    override def toString: String = {
+      toMap.keySet.mkString(", ")
     }
 
-    def toMap: Map[String, String] = {
-      import scala.collection.JavaConverters._
-      this.asScala.toMap
+    def containsKey(key: String): Boolean = toMap.contains(key)
+    def withProperty(key: String, value: String): PrettyProperties = {
+      new PrettyProperties(toMap + (key -> value))
     }
   }
 
   object PrettyProperties {
     def from(p: Properties): PrettyProperties = {
-      val pp = new PrettyProperties()
-      // Scala bug #10418 work-around
-      import scala.collection.JavaConverters._
-      p.asScala.foreach {
-        case (k, v) =>
-          pp.setProperty(k, v)
-      }
-
-      pp
+      import scala.collection.JavaConverters.propertiesAsScalaMapConverter
+      val propertiesMap = p.asScala.toMap
+      new PrettyProperties(propertiesMap)
     }
   }
 
   final lazy val currentEnv: PrettyProperties = {
     import scala.collection.JavaConverters._
-    System.getenv().asScala.foldLeft(new PrettyProperties()) {
-      case (props, (key, value)) => props.setProperty(key, value); props
-    }
+    new PrettyProperties(System.getenv().asScala.toMap)
   }
 
   implicit lazy val parser: Parser[CommonOptions] = Parser.derive

frontend/src/main/scala/bloop/engine/ExecutionContext.scala

@@ -46,7 +46,7 @@ object ExecutionContext {
     Scheduler.Implicits.global
   }
 
-  val ioReporter = UncaughtExceptionReporter.LogExceptionsToStandardErr
+  val ioReporter = UncaughtExceptionReporter.default
   lazy val ioExecutor: ThreadPoolExecutor = {
     val threadFactory = monixThreadFactoryBuilder("bloop-io", ioReporter, daemonic = true)
     new ThreadPoolExecutor(

frontend/src/main/scala/bloop/engine/tasks/compilation/CompileGraph.scala

@@ -244,7 +244,7 @@ object CompileGraph {
           runningCompilation.traversal.executeOn(ExecutionContext.ioScheduler)
 
         val deduplicateStreamSideEffectsHandle =
-          replayEventsTask.runAsync(ExecutionContext.ioScheduler)
+          replayEventsTask.runToFuture(ExecutionContext.ioScheduler)
 
         /**
          * Deduplicate and change the implementation of the task returning the

frontend/src/main/scala/bloop/engine/tasks/toolchains/ScalaJsToolchain.scala

@@ -146,7 +146,7 @@ object ScalaJsToolchain extends ToolchainCompanion[ScalaJsToolchain] {
         DependencyResolution
           .Artifact("org.scala-js", s"scalajs-env-jsdom-nodejs_$scalaVersion", "1.1.0"),
         DependencyResolution
-          .Artifact("org.scala-js", s"scalajs-logging_$scalaVersion", "1.4.0")
+          .Artifact("org.scala-js", s"scalajs-logging_$scalaVersion", "1.1.1")
       )
   }
 

frontend/src/main/scala/bloop/exec/JvmProcessForker.scala

@@ -44,12 +44,13 @@ trait JvmProcessForker {
    * @param mainClass       The fully qualified name of the class to run
    * @param args            The arguments to pass to the main method.
    * @param jvmOptions      The java options to pass to the jvm.
+   * @param envVars         Env vars which should be passed to the jvm.
    * @param logger          Where to log the messages from execution
    * @param opts            The options to run the program with
    * @param extraClasspath  Paths to append to the classpath before running
    * @return 0 if the execution exited successfully, a non-zero number otherwise
    */
-  def runMain(
+  final def runMain(
       cwd: AbsolutePath,
       mainClass: String,
       args: Array[String],
@@ -58,6 +59,28 @@ trait JvmProcessForker {
       logger: Logger,
       opts: CommonOptions,
       extraClasspath: Array[AbsolutePath] = Array.empty
+  ): Task[Int] = {
+    val newEnv = envVars.foldLeft(opts.env) {
+      case (properties, line) =>
+        val eqIdx = line.indexOf("=")
+        if (eqIdx > 0 && eqIdx != line.length - 1) {
+          val key = line.substring(0, eqIdx)
+          val value = line.substring(eqIdx + 1)
+          properties.withProperty(key, value)
+        } else properties
+    }
+    val commonOptionWithEnv = opts.withEnv(newEnv)
+    runMain(cwd, mainClass, args, jvmOptions, logger, commonOptionWithEnv, extraClasspath)
+  }
+
+  protected[exec] def runMain(
+      cwd: AbsolutePath,
+      mainClass: String,
+      args: Array[String],
+      jvmOptions: Array[String],
+      logger: Logger,
+      opts: CommonOptions,
+      extraClasspath: Array[AbsolutePath]
   ): Task[Int]
 }
 
@@ -99,22 +122,13 @@ final class JvmForker(config: JdkConfig, classpath: Array[AbsolutePath]) extends
       mainClass: String,
       args: Array[String],
       jargs: Array[String],
-      envVars: List[String],
       logger: Logger,
       opts: CommonOptions,
       extraClasspath: Array[AbsolutePath]
   ): Task[Int] = {
     val jvmOptions = jargs ++ config.javaOptions
     val fullClasspath = classpath ++ extraClasspath
     val fullClasspathStr = fullClasspath.map(_.syntax).mkString(File.pathSeparator)
-    envVars.foreach(line => {
-      val eqIdx = line.indexOf("=")
-      if (eqIdx > 0 && eqIdx != line.length - 1) {
-        val key = line.substring(0, eqIdx)
-        val value = line.substring(eqIdx + 1)
-        opts.env.setProperty(key, value)
-      }
-    })
 
     // Windows max cmd line length is 32767, which seems to be the least of the common shells.
     val processCmdCharLimit = 30000
@@ -228,13 +242,12 @@ final class JvmDebuggingForker(underlying: JvmProcessForker) extends JvmProcessF
       mainClass: String,
       args: Array[String],
       jargs0: Array[String],
-      envVars: List[String],
       logger: Logger,
       opts: CommonOptions,
       extraClasspath: Array[AbsolutePath]
   ): Task[Int] = {
     val jargs = jargs0 :+ enableDebugInterface
-    underlying.runMain(cwd, mainClass, args, jargs, envVars, logger, opts, extraClasspath)
+    underlying.runMain(cwd, mainClass, args, jargs, logger, opts, extraClasspath)
   }
 
   private def enableDebugInterface: String = {