Merge commit '3d9d78524' into merge-upstream

Author: alexarchambault

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/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 = {

frontend/src/test/scala/bloop/util/TestUtil.scala

@@ -267,9 +267,7 @@ object TestUtil {
   }
 
   private[bloop] def runAndTestProperties = {
-    val props = new bloop.cli.CommonOptions.PrettyProperties()
-    props.put("BLOOP_OWNER", "owner")
-    props
+    new bloop.cli.CommonOptions.PrettyProperties(Map("BLOOP_OWNER" -> "owner"))
   }
 
   /**