Merge pull request #96 from alexarchambault/develop

Minor refactoring / adjustments

Author: alexarchambault

.github/workflows/ci.yml

@@ -189,7 +189,7 @@ jobs:
     - uses: coursier/[email protected]
       with:
         jvm: 8
-    - run: ./mill -i ci.copyVcRedist || true
+    - run: ./mill -i ci.copyVcRedist
     - uses: actions/[email protected]
       with:
         name: launchers

modules/build/src/main/scala/scala/build/BloopBuildClient.scala

@@ -5,6 +5,7 @@ import ch.epfl.scala.bsp4j
 import java.io.PrintStream
 
 trait BloopBuildClient extends bsp4j.BuildClient {
+  def setProjectParams(newParams: Seq[String]): Unit
   def setGeneratedSources(newGeneratedSources: Seq[GeneratedSource]): Unit
   def diagnostics: Option[Seq[(Either[String, os.Path], bsp4j.Diagnostic)]]
   def clear(): Unit

modules/build/src/main/scala/scala/build/Build.scala

@@ -124,6 +124,7 @@ object Build {
 
     val generatedSources = sources.generateSources(inputs0.generatedSrcRoot)
 
+    buildClient.setProjectParams(options0.projectParams)
     build(
       inputs0,
       sources,
@@ -301,7 +302,7 @@ object Build {
 
     val classesDir0 = classesDir(inputs.workspace, inputs.projectName)
 
-    val artifacts = options.artifacts(params, logger)
+    val artifacts = options.artifacts(logger)
 
     val pluginScalacOptions = artifacts.compilerPlugins.map {
       case (_, _, path) =>

modules/build/src/main/scala/scala/build/ConsoleBloopBuildClient.scala

@@ -16,6 +16,14 @@ class ConsoleBloopBuildClient(
   var generatedSources: Seq[GeneratedSource] = Nil
 ) extends BloopBuildClient {
 
+  private var projectParams = Seq.empty[String]
+
+  private def projectNameSuffix =
+    if (projectParams.isEmpty) ""
+    else " (" + projectParams.mkString(", ") + ")"
+
+  private def projectName = "project" + projectNameSuffix
+
   private var printedStart = false
   private val gray = "\u001b[90m"
   private val reset = Console.RESET
@@ -25,6 +33,9 @@ class ConsoleBloopBuildClient(
   def setGeneratedSources(newGeneratedSources: Seq[GeneratedSource]) = {
     generatedSources = newGeneratedSources
   }
+  def setProjectParams(newParams: Seq[String]): Unit = {
+    projectParams = newParams
+  }
   def diagnostics: Option[Seq[(Either[String, os.Path], bsp4j.Diagnostic)]] =
     if (keepDiagnostics) Some(diagnostics0.result())
     else None
@@ -115,7 +126,10 @@ class ConsoleBloopBuildClient(
     logger.debug("Received onBuildTaskStart from bloop: " + params)
     for (msg <- Option(params.getMessage) if !msg.contains(" no-op compilation")) {
       printedStart = true
-      out.println(gray + msg + reset)
+      val msg0 =
+        if (params.getDataKind == "compile-task") s"Compiling $projectName"
+        else msg
+      out.println(gray + msg0 + reset)
     }
   }
 
@@ -125,8 +139,18 @@ class ConsoleBloopBuildClient(
   override def onBuildTaskFinish(params: bsp4j.TaskFinishParams): Unit = {
     logger.debug("Received onBuildTaskFinish from bloop: " + params)
     if (printedStart)
-      for (msg <- Option(params.getMessage))
-        out.println(gray + msg + reset)
+      for (msg <- Option(params.getMessage)) {
+        val msg0 =
+          if (params.getDataKind == "compile-report")
+            params.getStatus match {
+              case bsp4j.StatusCode.OK => s"Compiled $projectName"
+              case bsp4j.StatusCode.ERROR => s"Error compiling $projectName"
+              case bsp4j.StatusCode.CANCELLED => s"Compilation cancelled$projectNameSuffix"
+              case _ => s"Compiled $projectName" // ???
+            }
+          else msg
+        out.println(gray + msg0 + reset)
+      }
   }
 
   override def onConnectWithServer(server: bsp4j.BuildServer): Unit = {}

modules/build/src/main/scala/scala/build/Sources.scala

@@ -35,81 +35,12 @@ final case class Sources(
 
 object Sources {
 
-  def process(path: os.Path): Option[(Seq[String], String)] = {
-    val printablePath =
-      if (path.startsWith(Os.pwd)) path.relativeTo(Os.pwd).toString
-      else path.toString
-    val content = os.read(path)
-    process(content, printablePath)
-  }
-  def process(content: String, printablePath: String): Option[(Seq[String], String)] = {
-
-    import fastparse._
-    import scalaparse._
-    import scala.build.internal.ScalaParse._
-
-    val res = parse(content, Header(_))
-
-    val indicesOrFailingIdx0 = res.fold((_, idx, _) => Left(idx), (value, _) => Right(value))
-
-    val indicesOrErrorMsg = indicesOrFailingIdx0 match {
-      case Left(failingIdx) =>
-        val newCode = content.take(failingIdx)
-        val res1 = parse(newCode, Header(_))
-        res1 match {
-          case f: Parsed.Failure =>
-            val msg = formatFastparseError(printablePath, content, f)
-            Left(msg)
-          case s: Parsed.Success[Seq[(Int, Int)]] =>
-            Right(s.value)
-        }
-      case Right(ind) =>
-        Right(ind)
-    }
-
-    // TODO Report error if indicesOrErrorMsg.isLeft?
-
-    val importTrees = indicesOrErrorMsg.right.toSeq.iterator.flatMap(_.iterator).flatMap {
-      case (start, end) =>
-        val code = content.substring(start, end)
-          // .trim // meh
-        val importRes = parse(code, ImportSplitter(_))
-        importRes.fold((_, _, _) => Iterator.empty, (trees, _) => trees.iterator).map { tree =>
-          tree.copy(start = start + tree.start, end = start + tree.end)
-        }
-    }.toVector
-
-    val dependencyTrees = importTrees.filter { t =>
-      val firstSegmentOpt = t.prefix.headOption
-      firstSegmentOpt.contains("$ivy") || firstSegmentOpt.contains("$dep")
-    }
-
-    if (dependencyTrees.isEmpty) None
-    else {
-      // replace statements like
-      //   import $ivy.`foo`,
-      // by
-      //   import $ivy.A   ,
-      // Ideally, we should just wipe those statements, and take care of keeping 'import' and ','
-      // for standard imports.
-      val buf = content.toCharArray
-      for (t <- dependencyTrees) {
-        val substitute = (t.prefix(0) + ".A").padTo(t.end - t.start, ' ')
-        assert(substitute.length == (t.end - t.start))
-        System.arraycopy(substitute.toArray, 0, buf, t.start, substitute.length)
-      }
-      val newCode = new String(buf)
-      Some((dependencyTrees.map(_.prefix.drop(1).mkString(".")), newCode))
-    }
-  }
-
-
   def defaultPreprocessors(codeWrapper: CodeWrapper): Seq[Preprocessor] =
     Seq(
       ScriptPreprocessor(codeWrapper),
       JavaPreprocessor,
       ConfigPreprocessor,
-      ScalaFilePreprocessor
+      ScalaPreprocessor
     )
 
   def forInputs(

modules/build/src/main/scala/scala/build/bsp/BspClient.scala

@@ -86,6 +86,7 @@ class BspClient(
     }
   }
 
+  def setProjectParams(newParams: Seq[String]): Unit = {}
   def diagnostics: Option[Seq[(Either[String, os.Path], b.Diagnostic)]] = None
   def clear(): Unit = {}
 }

modules/build/src/main/scala/scala/build/bsp/BspImpl.scala

@@ -274,6 +274,8 @@ object BspImpl {
     def underlying = actualLocalClient
     def clear() = underlying.clear()
     def diagnostics = underlying.diagnostics
+    def setProjectParams(newParams: Seq[String]) =
+      underlying.setProjectParams(newParams)
     def setGeneratedSources(newGeneratedSources: Seq[GeneratedSource]) =
       underlying.setGeneratedSources(newGeneratedSources)
   }

modules/build/src/main/scala/scala/build/options/BuildOptions.scala

@@ -30,38 +30,46 @@ final case class BuildOptions(
                  replOptions: ReplOptions                 = ReplOptions()
 ) {
 
+  lazy val projectParams: Seq[String] = {
+    val platform =
+      if (scalaJsOptions.enable) "Scala.JS"
+      else if (scalaNativeOptions.enable) "Scala Native"
+      else "JVM"
+    Seq(s"Scala ${scalaParams.scalaVersion}", platform)
+  }
+
   def addRunnerDependency: Option[Boolean] =
     internalDependencies.addRunnerDependencyOpt
       .orElse(if (scalaJsOptions.enable || scalaNativeOptions.enable) Some(false) else None)
 
-  private def scalaLibraryDependencies(params: ScalaParameters): Seq[AnyDependency] =
+  private def scalaLibraryDependencies: Seq[AnyDependency] =
     if (scalaOptions.addScalaLibrary.getOrElse(true)) {
       val lib =
-        if (params.scalaVersion.startsWith("3."))
-          dep"org.scala-lang::scala3-library::${params.scalaVersion}"
+        if (scalaParams.scalaVersion.startsWith("3."))
+          dep"org.scala-lang::scala3-library::${scalaParams.scalaVersion}"
         else
-          dep"org.scala-lang:scala-library:${params.scalaVersion}"
+          dep"org.scala-lang:scala-library:${scalaParams.scalaVersion}"
       Seq(lib)
     }
     else Nil
 
-  def dependencies(params: ScalaParameters): Seq[AnyDependency] =
-    scalaJsOptions.jsDependencies(params.scalaVersion) ++
+  private def dependencies: Seq[AnyDependency] =
+    scalaJsOptions.jsDependencies(scalaParams.scalaVersion) ++
       scalaNativeOptions.nativeDependencies ++
-      scalaLibraryDependencies(params) ++
+      scalaLibraryDependencies ++
       classPathOptions.extraDependencies
 
-  private def semanticDbPlugins(params: ScalaParameters): Seq[AnyDependency] =
-    if (scalaOptions.generateSemanticDbs.getOrElse(false) && params.scalaVersion.startsWith("2."))
+  private def semanticDbPlugins: Seq[AnyDependency] =
+    if (scalaOptions.generateSemanticDbs.getOrElse(false) && scalaParams.scalaVersion.startsWith("2."))
       Seq(
         dep"$semanticDbPluginOrganization:::$semanticDbPluginModuleName:$semanticDbPluginVersion"
       )
     else Nil
 
-  def compilerPlugins(params: ScalaParameters): Seq[AnyDependency] =
-    scalaJsOptions.compilerPlugins(params.scalaVersion) ++
+  def compilerPlugins: Seq[AnyDependency] =
+    scalaJsOptions.compilerPlugins(scalaParams.scalaVersion) ++
       scalaNativeOptions.compilerPlugins ++
-      semanticDbPlugins(params)
+      semanticDbPlugins
 
   def allExtraJars: Seq[Path] =
     classPathOptions.extraJars.map(_.toNIO)
@@ -163,19 +171,19 @@ final case class BuildOptions(
     (sv, sbv)
   }
 
-  def scalaParams: ScalaParameters = {
+  lazy val scalaParams: ScalaParameters = {
     val (scalaVersion, scalaBinaryVersion) = computeScalaVersions(scalaOptions.scalaVersion, scalaOptions.scalaBinaryVersion)
     val maybePlatformSuffix =
       scalaJsOptions.platformSuffix
         .orElse(scalaNativeOptions.platformSuffix)
     ScalaParameters(scalaVersion, scalaBinaryVersion, maybePlatformSuffix)
   }
 
-  def artifacts(params: ScalaParameters, logger: Logger): Artifacts =
+  def artifacts(logger: Logger): Artifacts =
     Artifacts(
-                  params = params,
-         compilerPlugins = compilerPlugins(params),
-            dependencies = dependencies(params),
+                  params = scalaParams,
+         compilerPlugins = compilerPlugins,
+            dependencies = dependencies,
                extraJars = allExtraJars,
       extraCompileOnlyJars = allExtraCompileOnlyJars,
          extraSourceJars = allExtraSourceJars,