Implement a new trait Inputs, that aggregates ModuleInputs

Author: MaciejG604

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

@@ -6,20 +6,20 @@ import java.util.concurrent.atomic.AtomicReference
 
 import scala.build.Build
 import scala.build.compiler.BloopCompiler
-import scala.build.input.{ModuleInputs, OnDisk, SingleFile, Virtual}
+import scala.build.input.{ModuleInputs, OnDisk, SingleFile, Virtual, compose}
 
 final class BloopSession(
-  val inputs: Seq[ModuleInputs],
+  val inputs: compose.Inputs,
 //  val inputsHash: String, TODO Fix inputs hash comparing
   val remoteServer: BloopCompiler,
   val bspServer: BspServer,
   val watcher: Build.Watcher
 ) {
   def resetDiagnostics(localClient: BspClient): Unit = for {
-    moduleInputs <- inputs
-    targetId     <- bspServer.targetProjectIdOpt(moduleInputs.projectName)
+    module   <- inputs.modules
+    targetId <- bspServer.targetProjectIdOpt(module.projectName)
   } do
-    moduleInputs.flattened().foreach {
+    module.flattened().foreach {
       case f: SingleFile =>
         localClient.resetDiagnostics(f.path, targetId)
       case _: Virtual =>
@@ -31,7 +31,7 @@ final class BloopSession(
   }
 
   def registerWatchInputs(): Unit = for {
-    module  <- inputs
+    module  <- inputs.modules
     element <- module.elements
   } do
     element match {
@@ -65,7 +65,7 @@ final class BloopSession(
 object BloopSession {
 
   def apply(
-    inputs: Seq[ModuleInputs],
+    inputs: compose.Inputs,
     remoteServer: BloopCompiler,
     bspServer: BspServer,
     watcher: Build.Watcher

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

@@ -3,17 +3,17 @@ package scala.build.bsp
 import java.io.{InputStream, OutputStream}
 
 import scala.build.errors.BuildException
-import scala.build.input.{ModuleInputs, ScalaCliInvokeData}
+import scala.build.input.{ModuleInputs, ScalaCliInvokeData, compose}
 import scala.concurrent.Future
 
 trait Bsp {
-  def run(initialInputs: Seq[ModuleInputs], initialBspOptions: BspReloadableOptions): Future[Unit]
+  def run(initialInputs: compose.Inputs, initialBspOptions: BspReloadableOptions): Future[Unit]
   def shutdown(): Unit
 }
 
 object Bsp {
   def create(
-    argsToInputs: Seq[String] => Either[BuildException, Seq[ModuleInputs]],
+    argsToInputs: Seq[String] => Either[BuildException, compose.Inputs],
     bspReloadableOptionsReference: BspReloadableOptions.Reference,
     threads: BspThreads,
     in: InputStream,

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

@@ -21,7 +21,7 @@ import scala.build.errors.{
   Diagnostic,
   ParsingInputsException
 }
-import scala.build.input.{ModuleInputs, ScalaCliInvokeData}
+import scala.build.input.{ModuleInputs, ScalaCliInvokeData, compose}
 import scala.build.internal.Constants
 import scala.build.options.{BuildOptions, Scope}
 import scala.collection.mutable.ListBuffer
@@ -44,7 +44,7 @@ import scala.util.{Failure, Success}
   *   the output stream of bytes
   */
 final class BspImpl(
-  argsToInputs: Seq[String] => Either[BuildException, Seq[ModuleInputs]],
+  argsToInputs: Seq[String] => Either[BuildException, compose.Inputs],
   bspReloadableOptionsReference: BspReloadableOptions.Reference,
   threads: BspThreads,
   in: InputStream,
@@ -107,7 +107,7 @@ final class BspImpl(
       val persistentLogger = new PersistentDiagnosticLogger(logger)
       val bspServer        = currentBloopSession.bspServer
 
-      val prebuildModules = for (module <- currentBloopSession.inputs) yield {
+      val prebuildModules = for (module <- currentBloopSession.inputs.modulesBuildOrder) yield {
         val mainProjectName = module.projectName
         val testProjectName = module.scopeProjectName(Scope.Test)
 
@@ -392,7 +392,7 @@ final class BspImpl(
                 inputs.generatedSrcRoot(scope),
                 data.classesDir,
                 reloadableOptions.logger,
-                currentBloopSession.inputs.head.workspace, // FIXME .head, maybe add workspace to BloopSession
+                currentBloopSession.inputs.workspace,
                 updateSemanticDbs = true,
                 scalaVersion = sv,
                 buildOptions = data.buildOptions
@@ -440,21 +440,21 @@ final class BspImpl(
     *   a new [[BloopSession]]
     */
   private def newBloopSession(
-    inputs: Seq[ModuleInputs],
+    inputs: compose.Inputs,
     reloadableOptions: BspReloadableOptions,
     presetIntelliJ: Boolean = false
   ): BloopSession = {
     val logger       = reloadableOptions.logger
     val buildOptions = reloadableOptions.buildOptions
-    val workspace    = inputs.head.workspace
+    val workspace    = inputs.workspace
     val createBloopServer =
       () =>
         BloopServer.buildServer(
           reloadableOptions.bloopRifleConfig,
           "scala-cli",
           Constants.version,
-          (workspace / Constants.workspaceDirName).toNIO, // FIXME .head, introduce better types for Seq[ModuleInputs] that will have a common workspace
-          Build.classesRootDir(workspace, inputs.head.projectName).toNIO,
+          (workspace / Constants.workspaceDirName).toNIO,
+          Build.classesRootDir(workspace, inputs.targetModule.projectName).toNIO,
           localClient,
           threads.buildThreads.bloop,
           logger.bloopRifleLogger
@@ -493,7 +493,7 @@ final class BspImpl(
     *   change on subsequent workspace/reload requests)
     */
   override def run(
-    initialInputs: Seq[ModuleInputs],
+    initialInputs: compose.Inputs,
     initialBspOptions: BspReloadableOptions
   ): Future[Unit] = {
     val logger    = initialBspOptions.logger
@@ -597,8 +597,8 @@ final class BspImpl(
     */
   private def reloadBsp(
     currentBloopSession: BloopSession,
-    previousInputs: Seq[ModuleInputs],
-    newInputs: Seq[ModuleInputs],
+    previousInputs: compose.Inputs,
+    newInputs: compose.Inputs,
     reloadableOptions: BspReloadableOptions
   ): CompletableFuture[AnyRef] = {
     val previousTargetIds = currentBloopSession.bspServer.targetIds
@@ -653,10 +653,10 @@ final class BspImpl(
           }
           else newBloopSession0
 
-        val previousProjectNames = previousInputs.flatMap(m =>
+        val previousProjectNames = previousInputs.modules.flatMap(m =>
           Seq(m.scopeProjectName(Scope.Main), m.scopeProjectName(Scope.Test))
         ).toSet
-        val newProjectNames = newInputs.flatMap(m =>
+        val newProjectNames = newInputs.modules.flatMap(m =>
           Seq(m.scopeProjectName(Scope.Main), m.scopeProjectName(Scope.Test))
         ).toSet
 
@@ -688,7 +688,7 @@ final class BspImpl(
     actualLocalClient.logger = logger
     localClient = getLocalClient(verbosity)
     val ideInputsJsonPath =
-      currentBloopSession.inputs.head.workspace / Constants.workspaceDirName / "ide-inputs.json"
+      currentBloopSession.inputs.workspace / Constants.workspaceDirName / "ide-inputs.json"
     if (os.isFile(ideInputsJsonPath)) {
       val maybeResponse = either[BuildException] {
         val ideInputs = value {

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

@@ -5,10 +5,10 @@ import bloop.rifle.BloopRifleConfig
 import scala.build.Logger
 import scala.build.options.BuildOptions
 
-/** The options and configurations that may be picked up on a bsp workspace/reload request.
-  * They don't take into account options from sources.
-  * The only two exceptions are the initial options in BspImpl.run
-  * and in options used to launch new bloop in BspImpl.reloadBsp, which have the [[bloopRifleConfig]] updated.
+/** The options and configurations that may be picked up on a bsp workspace/reload request. They
+  * don't take into account options from sources. The only two exceptions are the initial options in
+  * BspImpl.run and in options used to launch new bloop in BspImpl.reloadBsp, which have the
+  * [[bloopRifleConfig]] updated.
   *
   * @param buildOptions
   *   passed options for building sources

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

@@ -6,7 +6,7 @@ import java.util.concurrent.CompletableFuture
 
 import scala.build.GeneratedSource
 import scala.build.bsp.buildtargets.{ManagesBuildTargets, ProjectName}
-import scala.build.input.ModuleInputs
+import scala.build.input.{ModuleInputs, compose}
 import scala.build.options.Scope
 
 /** A wrapper for [[BspServer]], allowing to reload the workspace on the fly.
@@ -113,6 +113,6 @@ class BuildServerProxy(
     bspServer().addTarget(projectName, workspace, scope, generatedSources)
   def resetTargets(): Unit =
     bspServer().resetTargets()
-  def newInputs(inputs: Seq[ModuleInputs]): Unit =
+  def newInputs(inputs: compose.Inputs): Unit =
     bspServer().newInputs(inputs)
 }

modules/build/src/main/scala/scala/build/bsp/buildtargets/ManagesBuildTargets.scala

@@ -4,7 +4,7 @@ import ch.epfl.scala.bsp4j.BuildTargetIdentifier
 import ch.epfl.scala.bsp4j as b
 
 import scala.build.GeneratedSource
-import scala.build.input.ModuleInputs
+import scala.build.input.{ModuleInputs, compose}
 import scala.build.internal.Constants
 import scala.build.options.Scope
 
@@ -18,7 +18,7 @@ trait ManagesBuildTargets {
     generatedSources: Seq[GeneratedSource] = Nil
   ): Unit
   def resetTargets(): Unit
-  def newInputs(inputs: Seq[ModuleInputs]): Unit
+  def newInputs(inputs: compose.Inputs): Unit
   def setGeneratedSources(projectName: ProjectName, sources: Seq[GeneratedSource]): Unit
 }
 

modules/build/src/main/scala/scala/build/bsp/buildtargets/ManagesBuildTargetsImpl.scala

@@ -5,7 +5,7 @@ import ch.epfl.scala.bsp4j as b
 import scala.build.GeneratedSource
 import scala.build.bsp.buildtargets.ManagesBuildTargets
 import scala.build.errors.{BuildException, WorkspaceError}
-import scala.build.input.ModuleInputs
+import scala.build.input.{ModuleInputs, compose}
 import scala.build.internal.Constants
 import scala.build.options.Scope
 import scala.collection.mutable
@@ -34,9 +34,9 @@ trait ManagesBuildTargetsImpl extends ManagesBuildTargets {
   ): Unit =
     managedTargets.put(projectName, BuildTarget(projectName, workspace, scope, generatedSources))
 
-  override def newInputs(inputs: Seq[ModuleInputs]): Unit = {
+  override def newInputs(inputs: compose.Inputs): Unit = {
     resetTargets()
-    inputs.foreach { module =>
+    inputs.modules.foreach { module =>
       addTarget(module.projectName, module.workspace, Scope.Main)
       addTarget(module.scopeProjectName(Scope.Test), module.workspace, Scope.Test)
     }

modules/build/src/main/scala/scala/build/input/compose/Inputs.scala

@@ -1,39 +1,53 @@
 package scala.build.input.compose
 
-import scala.build.input.WorkspaceOrigin
-import scala.build.input.ModuleInputs
+import scala.build.bsp.buildtargets.ProjectName
+import scala.build.input.{ModuleInputs, WorkspaceOrigin}
 import scala.build.options.BuildOptions
+import scala.collection.mutable
 
 sealed trait Inputs {
-  
+
   def modules: Seq[ModuleInputs]
 
-  /** Module targeted by the user. If a command requires a target to be executed (e.g. run or compile), it should be executed on this module. */
+  /** Module targeted by the user. If a command requires a target to be executed (e.g. run or
+    * compile), it should be executed on this module.
+    */
   def targetModule: ModuleInputs
-  /** Build order for modules to execute the command on the [[targetModule]] */
+
+  /** Order in which to build all modules */
   def modulesBuildOrder: Seq[ModuleInputs]
-  def workspaceOrigin: WorkspaceOrigin
+
+  /** Order in which to build the target module with its dependencies, e.g. to execute a command on
+    * [[targetModule]]
+    */
+  def targetBuildOrder: Seq[ModuleInputs]
+  def workspaceOrigin: Option[WorkspaceOrigin]
   def workspace: os.Path
 
-  def preprocessInputs(preprocess: ModuleInputs => (ModuleInputs, BuildOptions)): (Inputs, Seq[BuildOptions])
+  def preprocessInputs(preprocess: ModuleInputs => (ModuleInputs, BuildOptions))
+    : (Inputs, Seq[BuildOptions])
 }
 
 /** Result of using [[InputsComposer]] with module config file present */
 case class ComposedInputs(
   modules: Seq[ModuleInputs],
   targetModule: ModuleInputs,
-  workspace: os.Path,
+  workspace: os.Path
 ) extends Inputs {
 
   // Forced to be the directory where module config file (modules.yaml) resides
-  override val workspaceOrigin: WorkspaceOrigin = WorkspaceOrigin.Forced
+  override val workspaceOrigin: Option[WorkspaceOrigin] = Some(WorkspaceOrigin.Forced)
 
-  lazy val modulesBuildOrder: Seq[ModuleInputs] = {
-    val nameMap = modules.map(m => m.projectName -> m)
-    val dependencyGraph = modules.map(m => m.projectName -> m.moduleDependencies)
+  private val nameMap: Map[ProjectName, ModuleInputs] = modules.map(m => m.projectName -> m).toMap
+  private val dependencyGraph = modules.map(m => m.projectName -> m.moduleDependencies).toMap
 
-    val visited = mutable.Set.empty[Name] // Track visited nodes
-    val result = mutable.Stack.empty[Name] // Use a stack to build the result in reverse order
+  private def buildOrderForModule(
+    root: ModuleInputs,
+    visitedPreviously: Set[ProjectName]
+  ): Seq[ProjectName] = {
+    val visited = mutable.Set.from(visitedPreviously) // Track visited nodes
+    val result =
+      mutable.Stack.empty[ProjectName] // Use a stack to build the result in reverse order
 
     def visit(node: ProjectName): Unit = {
       if (!visited.contains(node)) {
@@ -43,37 +57,53 @@ case class ComposedInputs(
       }
     }
 
-    dependencyGraph.keys.foreach(visit)
-
-    result.toSeq.reverse
+    visit(root.projectName)
+    result.reverse.toSeq
   }
 
-  def preprocessInputs(preprocess: ModuleInputs => (ModuleInputs, BuildOptions)): (ComposedInputs, Seq[BuildOptions]) = {
-    val (preprocessedModules, buildOptions) =>
-      modules.filter(_.projectName == targetModule.projectName)
+  override lazy val modulesBuildOrder: Seq[ModuleInputs] =
+    modules.foldLeft(Seq.empty[ProjectName]) { (acc, module) =>
+      val buildOrder = buildOrderForModule(module, visitedPreviously = acc.toSet)
+      acc.appendedAll(buildOrder)
+    }.map(nameMap)
+
+  override lazy val targetBuildOrder: Seq[ModuleInputs] =
+    buildOrderForModule(targetModule, Set.empty).map(nameMap)
+
+  def preprocessInputs(preprocess: ModuleInputs => (ModuleInputs, BuildOptions))
+    : (ComposedInputs, Seq[BuildOptions]) = {
+    val (preprocessedModules, buildOptions) =
+      modules.filterNot(_.projectName == targetModule.projectName)
         .map(preprocess)
         .unzip
 
-      val preprocessedTargetModule = preprocess(targetModule)
+    val (preprocessedTargetModule, targetBuildOptions) = preprocess(targetModule)
 
-      copy(modules = preprocessedModules ++ preprocessedTargetModule, targetModule = preprocessedTargetModule) -> buildOptions
+    copy(
+      modules = preprocessedModules.appended(preprocessedTargetModule),
+      targetModule = preprocessedTargetModule
+    ) -> buildOptions.appended(targetBuildOptions)
   }
 }
 
 /** Essentially a wrapper over a single module, no config file for modules involved */
 case class SimpleInputs(
-  singleModule: ModuleInputs,
+  singleModule: ModuleInputs
 ) extends Inputs {
   override val modules: Seq[ModuleInputs] = Seq(singleModule)
 
   override val targetModule: ModuleInputs = singleModule
 
-  override val modulesBuildOrder = modules
+  override val modulesBuildOrder: Seq[ModuleInputs] = modules
+
+  override val targetBuildOrder: Seq[ModuleInputs] = modules
 
   override val workspace: os.Path = singleModule.workspace
 
-  override val workspaceOrigin: WorkspaceOrigin = singleModule.workspaceOrigin
+  override val workspaceOrigin: Option[WorkspaceOrigin] = singleModule.workspaceOrigin
 
-  def preprocessInputs(preprocess: ModuleInputs => (ModuleInputs, BuildOptions)): (ComposedInputs, Seq[BuildOptions]) =
-    copy(singleModule = preprocess(singleModule)) -> buildOptions
+  override def preprocessInputs(preprocess: ModuleInputs => (ModuleInputs, BuildOptions))
+    : (SimpleInputs, Seq[BuildOptions]) =
+    val (preprocessedModule, buildOptions) = preprocess(singleModule)
+    copy(singleModule = preprocessedModule) -> Seq(buildOptions)
 }