Use InputsComposer in Bsp

Author: MaciejG604

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

@@ -1020,7 +1020,8 @@ object Build {
       resourceDirs = sources.resourceDirs,
       scope = scope,
       javaHomeOpt = Option(options.javaHomeLocation().value),
-      javacOptions = javacOptions
+      javacOptions = javacOptions,
+      moduleDependencies = inputs.moduleDependencies
     )
     project
   }

modules/build/src/main/scala/scala/build/Project.scala

@@ -29,7 +29,8 @@ final case class Project(
   resourceDirs: Seq[os.Path],
   javaHomeOpt: Option[os.Path],
   scope: Scope,
-  javacOptions: List[String]
+  javacOptions: List[String],
+  moduleDependencies: Seq[ProjectName]
 ) {
 
   import Project._
@@ -66,7 +67,8 @@ final case class Project(
         platform = Some(platform),
         `scala` = scalaConfigOpt,
         java = Some(BloopConfig.Java(javacOptions)),
-        resolution = resolution
+        resolution = resolution,
+        dependencies = moduleDependencies.map(_.name).toList
       )
   }
 

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

@@ -9,27 +9,33 @@ import scala.build.compiler.BloopCompiler
 import scala.build.input.{ModuleInputs, OnDisk, SingleFile, Virtual}
 
 final class BloopSession(
-  val inputs: ModuleInputs,
-  val inputsHash: String,
+  val inputs: Seq[ModuleInputs],
+//  val inputsHash: String, TODO Fix inputs hash comparing
   val remoteServer: BloopCompiler,
   val bspServer: BspServer,
   val watcher: Build.Watcher
 ) {
   // TODO this resets diagnostics using paths that do not belong to the build targets
-  def resetDiagnostics(localClient: BspClient): Unit =
-    for (targetId <- bspServer.targetIds)
-      inputs.flattened().foreach {
-        case f: SingleFile =>
-          localClient.resetDiagnostics(f.path, targetId)
-        case _: Virtual =>
-      }
+  def resetDiagnostics(localClient: BspClient): Unit = for {
+    moduleInputs <- inputs
+    targetId     <- bspServer.targetProjectIdOpt(moduleInputs.projectName)
+  } do
+    moduleInputs.flattened().foreach {
+      case f: SingleFile =>
+        localClient.resetDiagnostics(f.path, targetId)
+      case _: Virtual =>
+    }
+
   def dispose(): Unit = {
     watcher.dispose()
     remoteServer.shutdown()
   }
 
-  def registerWatchInputs(): Unit =
-    inputs.elements.foreach {
+  def registerWatchInputs(): Unit = for {
+    module  <- inputs
+    element <- module.elements
+  } do
+    element match {
       case elem: OnDisk =>
         val eventFilter: PathWatchers.Event => Boolean = { event =>
           val newOrDeletedFile =
@@ -38,8 +44,11 @@ final class BloopSession(
           lazy val p        = os.Path(event.getTypedPath.getPath.toAbsolutePath)
           lazy val relPath  = p.relativeTo(elem.path)
           lazy val isHidden = relPath.segments.exists(_.startsWith("."))
-          def isScalaFile   = relPath.last.endsWith(".sc") || relPath.last.endsWith(".scala")
-          def isJavaFile    = relPath.last.endsWith(".java")
+
+          def isScalaFile = relPath.last.endsWith(".sc") || relPath.last.endsWith(".scala")
+
+          def isJavaFile = relPath.last.endsWith(".java")
+
           newOrDeletedFile && !isHidden && (isScalaFile || isJavaFile)
         }
         val watcher0 = watcher.newWatcher()
@@ -57,11 +66,11 @@ final class BloopSession(
 object BloopSession {
 
   def apply(
-    inputs: ModuleInputs,
+    inputs: Seq[ModuleInputs],
     remoteServer: BloopCompiler,
     bspServer: BspServer,
     watcher: Build.Watcher
-  ): BloopSession = new BloopSession(inputs, inputs.sourceHash(), remoteServer, bspServer, watcher)
+  ): BloopSession = new BloopSession(inputs, remoteServer, bspServer, watcher)
 
   final class Reference {
     private val ref = new AtomicReference[BloopSession](null)

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

@@ -7,13 +7,13 @@ import scala.build.input.{ModuleInputs, ScalaCliInvokeData}
 import scala.concurrent.Future
 
 trait Bsp {
-  def run(initialInputs: ModuleInputs, initialBspOptions: BspReloadableOptions): Future[Unit]
+  def run(initialInputs: Seq[ModuleInputs], initialBspOptions: BspReloadableOptions): Future[Unit]
   def shutdown(): Unit
 }
 
 object Bsp {
   def create(
-    argsToInputs: Seq[String] => Either[BuildException, ModuleInputs],
+    argsToInputs: Seq[String] => Either[BuildException, Seq[ModuleInputs]],
     bspReloadableOptionsReference: BspReloadableOptions.Reference,
     threads: BspThreads,
     in: InputStream,