WIP add Inputs trait and implementing classes

MaciejG604 · MaciejG604 · commit 037e421e402f · 2024-08-20T20:02:38.000+02:00
diff --git a/modules/build/src/main/scala/scala/build/input/compose/Inputs.scala b/modules/build/src/main/scala/scala/build/input/compose/Inputs.scala
@@ -0,0 +1,79 @@
+package scala.build.input.compose
+
+import scala.build.input.WorkspaceOrigin
+import scala.build.input.ModuleInputs
+import scala.build.options.BuildOptions
+
+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. */
+  def targetModule: ModuleInputs
+  /** Build order for modules to execute the command on the [[targetModule]] */
+  def modulesBuildOrder: Seq[ModuleInputs]
+  def workspaceOrigin: WorkspaceOrigin
+  def workspace: os.Path
+
+  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,
+) extends Inputs {
+
+  // Forced to be the directory where module config file (modules.yaml) resides
+  override val workspaceOrigin: WorkspaceOrigin = WorkspaceOrigin.Forced
+
+  lazy val modulesBuildOrder: Seq[ModuleInputs] = {
+    val nameMap = modules.map(m => m.projectName -> m)
+    val dependencyGraph = modules.map(m => m.projectName -> m.moduleDependencies)
+
+    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
+
+    def visit(node: ProjectName): Unit = {
+      if (!visited.contains(node)) {
+        visited += node
+        dependencyGraph.getOrElse(node, Nil).foreach(visit) // Visit all the linked nodes first
+        result.push(node) // Add the current node after visiting linked nodes
+      }
+    }
+
+    dependencyGraph.keys.foreach(visit)
+
+    result.toSeq.reverse
+  }
+
+  def preprocessInputs(preprocess: ModuleInputs => (ModuleInputs, BuildOptions)): (ComposedInputs, Seq[BuildOptions]) = {
+    val (preprocessedModules, buildOptions) =>
+      modules.filter(_.projectName == targetModule.projectName)
+        .map(preprocess)
+        .unzip
+
+      val preprocessedTargetModule = preprocess(targetModule)
+
+      copy(modules = preprocessedModules ++ preprocessedTargetModule, targetModule = preprocessedTargetModule) -> buildOptions
+  }
+}
+
+/** Essentially a wrapper over a single module, no config file for modules involved */
+case class SimpleInputs(
+  singleModule: ModuleInputs,
+) extends Inputs {
+  override val modules: Seq[ModuleInputs] = Seq(singleModule)
+
+  override val targetModule: ModuleInputs = singleModule
+
+  override val modulesBuildOrder = modules
+
+  override val workspace: os.Path = singleModule.workspace
+
+  override val workspaceOrigin: WorkspaceOrigin = singleModule.workspaceOrigin
+
+  def preprocessInputs(preprocess: ModuleInputs => (ModuleInputs, BuildOptions)): (ComposedInputs, Seq[BuildOptions]) =
+    copy(singleModule = preprocess(singleModule)) -> buildOptions
+}
diff --git a/modules/build/src/main/scala/scala/build/input/compose/InputsComposer.scala b/modules/build/src/main/scala/scala/build/input/compose/InputsComposer.scala
@@ -1,4 +1,4 @@
-package scala.build.input
+package scala.build.input.compose
 
 import toml.Value
 import toml.Value.*
@@ -7,6 +7,7 @@ import scala.build.EitherCps.*
 import scala.build.EitherSequence
 import scala.build.bsp.buildtargets.ProjectName
 import scala.build.errors.{BuildException, CompositeBuildException, ModuleConfigurationError}
+import scala.build.input.{InputsComposer, ModuleInputs}
 import scala.build.internal.Constants
 import scala.build.options.BuildOptions
 import scala.collection.mutable
@@ -113,7 +114,7 @@ object InputsComposer {
 /** Creates [[ModuleInputs]] given the initial arguments passed to the command, Looks for module
   * config .toml file and if found composes module inputs according to the defined config, otherwise
   * if module config is not found or if [[allowForbiddenFeatures]] is not set, returns only one
-  * basic module created from initial args (see [[basicInputs]])
+  * basic module created from initial args (see [[simpleInputs]])
   *
   * @param args
   *   initial args passed to command
@@ -133,9 +134,9 @@ final case class InputsComposer(
   import InputsComposer.*
 
   /** Inputs with no dependencies coming only from args */
-  def basicInputs = for (inputs <- inputsFromArgs(args, None)) yield Seq(inputs)
+  private def simpleInputs = for (inputs <- inputsFromArgs(args, None)) yield SimpleInputs(inputs)
 
-  def getModuleInputs: Either[BuildException, Seq[ModuleInputs]] =
+  def getInputs: Either[BuildException, Inputs] =
     if allowForbiddenFeatures then
       findModuleConfig(args, cwd) match {
         case Right(Some(moduleConfigPath)) =>
@@ -149,10 +150,10 @@ final case class InputsComposer(
             _            <- checkForCycles(modules)
             moduleInputs <- fromModuleDefinitions(modules, moduleConfigPath)
           } yield moduleInputs
-        case Right(None) => basicInputs
+        case Right(None) => simpleInputs
         case Left(err)   => Left(err)
       }
-    else basicInputs
+    else simpleInputs
 
 //  private def readScalaVersion(value: Value): Either[String, String] = value match {
 //    case Str(version) => Right(version)
@@ -197,26 +198,29 @@ final case class InputsComposer(
   private def fromModuleDefinitions(
     modules: Seq[ModuleDefinition],
     moduleConfigPath: os.Path
-  ): Either[BuildException, Seq[ModuleInputs]] = either {
+  ): Either[BuildException, ComposedInputs] = either {
     val workspacePath = moduleConfigPath / os.up
-    val moduleInputsInfo = modules.map { m =>
+    val moduleInputsInfo: Map[ModuleDefinition, ModuleInputs] = modules.map { m =>
       val moduleName        = ProjectName(m.name)
       val argsWithWorkspace = m.roots.map(r => os.Path(r, workspacePath).toString)
       val moduleInputs      = inputsFromArgs(argsWithWorkspace, Some(moduleName))
       m -> value(moduleInputs).copy(mayAppendHash = false)
     }
 
     val projectNameMap: Map[String, ProjectName] =
-      moduleInputsInfo.map((moduleDef, inputs) => moduleDef.name -> inputs.projectName).toMap
+      moduleInputsInfo.map((moduleDef, module) => moduleDef.name -> module.projectName).toMap
 
-    val moduleInputs = moduleInputsInfo.map { (moduleDef, inputs) =>
+    val moduleInputs = moduleInputsInfo.map { (moduleDef, module) =>
       val moduleDeps: Seq[ProjectName] = moduleDef.dependsOn.map(projectNameMap)
 
-      inputs.dependsOn(moduleDeps)
+      module.dependsOn(moduleDeps)
         .withForcedWorkspace(workspacePath)
         .copy(mayAppendHash = false)
     }
 
-    moduleInputs
+    val targetModule = modules.find(_.roots.toSet equals args.toSet)
+      .getOrElse(moduleInputs.head)
+
+    ComposedInputs(modules = moduleInputs, targetModule = targetModule, workspace = workspacePath)
   }
 }
diff --git a/modules/build/src/test/scala/scala/build/input/InputsComposerTest.scala b/modules/build/src/test/scala/scala/build/input/InputsComposerTest.scala
@@ -3,6 +3,7 @@ package scala.build.input
 import scala.build.Build
 import scala.build.bsp.buildtargets.ProjectName
 import scala.build.errors.BuildException
+import scala.build.input.compose.InputsComposer
 import scala.build.internal.Constants
 import scala.build.options.BuildOptions
 import scala.build.tests.{TestInputs, TestUtil}
@@ -57,7 +58,7 @@ class InputsComposerTest extends TestUtil.ScalaCliBuildSuite {
           Right(Build.updateInputs(emptyInputs, BuildOptions()))
         }
       val modules = InputsComposer(Seq(root.toString), root, argsToInputs, true)
-        .getModuleInputs
+        .getInputs
         .toSeq
         .flatten
 
diff --git a/modules/cli/src/main/scala/scala/cli/commands/bsp/Bsp.scala b/modules/cli/src/main/scala/scala/cli/commands/bsp/Bsp.scala
@@ -6,6 +6,7 @@ import com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMaker
 
 import scala.build.EitherCps.{either, value}
 import scala.build.*
+import scala.build.input.compose
 import scala.build.bsp.{BspReloadableOptions, BspThreads}
 import scala.build.errors.BuildException
 import scala.build.input.ModuleInputs
@@ -83,7 +84,7 @@ object Bsp extends ScalaCommand[BspOptions] {
 
     refreshPowerMode(getLauncherOptions(), getSharedOptions(), getEnvsFromFile())
 
-    val preprocessInputs: Seq[String] => Either[BuildException, Seq[(ModuleInputs, BuildOptions)]] =
+    val preprocessInputs: Seq[String] => Either[BuildException, (compose.Inputs, Seq[BuildOptions])] =
       argsSeq =>
         either {
           val sharedOptions   = getSharedOptions()
@@ -96,12 +97,12 @@ object Bsp extends ScalaCommand[BspOptions] {
           val latestLogger     = sharedOptions.logging.logger
           val persistentLogger = new PersistentDiagnosticLogger(latestLogger)
 
-          val initialInputs: Seq[ModuleInputs] = value(sharedOptions.composeInputs(argsSeq))
+          val initialInputs: compose.Inputs = value(sharedOptions.composeInputs(argsSeq))
 
           if (sharedOptions.logging.verbosity >= 3)
             pprint.err.log(initialInputs)
 
-          for (moduleInputs <- initialInputs) yield {
+          initialInputs.preprocessInputs { moduleInputs =>
             val crossResult = CrossSources.forModuleInputs(
               moduleInputs,
               Sources.defaultPreprocessors(
@@ -137,8 +138,8 @@ object Bsp extends ScalaCommand[BspOptions] {
 
     // TODO reported override option values
     // FIXME Only some options need to be unified for the whole project, like scala version, JVM
-    val combinedBuildOptions = inputsAndBuildOptions.map(_._2).reduceLeft(_ orElse _)
-    val inputs            = inputsAndBuildOptions.map(_._1)
+    val combinedBuildOptions = inputsAndBuildOptions._2.reduceLeft(_ orElse _)
+    val inputs            = inputsAndBuildOptions._1
 
     if (options.shared.logging.verbosity >= 3)
       pprint.err.log(combinedBuildOptions)
@@ -179,14 +180,12 @@ object Bsp extends ScalaCommand[BspOptions] {
       )
     }
 
-    CurrentParams.workspaceOpt =
-      Some(inputs.head.workspace) // FIXME .head, introduce better types for Seq[ModuleInputs] that will have a common workspace
-    val actionableDiagnostics =
-      options.shared.logging.verbosityOptions.actions
+    CurrentParams.workspaceOpt = Some(inputs.workspace)
+    val actionableDiagnostics = options.shared.logging.verbosityOptions.actions
 
     BspThreads.withThreads { threads =>
       val bsp = scala.build.bsp.Bsp.create(
-        preprocessInputs.andThen(_.map(_.map(_._1))),
+        preprocessInputs.andThen(_.map(_._1)),
         bspReloadableOptionsReference,
         threads,
         System.in,
diff --git a/modules/cli/src/main/scala/scala/cli/commands/setupide/SetupIde.scala b/modules/cli/src/main/scala/scala/cli/commands/setupide/SetupIde.scala
@@ -7,12 +7,13 @@ import com.github.plokhotnyuk.jsoniter_scala.macros.JsonCodecMaker
 import com.google.gson.GsonBuilder
 
 import java.nio.charset.{Charset, StandardCharsets}
-
 import scala.build.EitherCps.{either, value}
 import scala.build.*
 import scala.build.bsp.IdeInputs
 import scala.build.errors.{BuildException, WorkspaceError}
-import scala.build.input.{InputsComposer, ModuleInputs, OnDisk, Virtual, WorkspaceOrigin}
+import scala.build.input.compose
+import scala.build.input.compose.{ComposedInputs, InputsComposer, SimpleInputs}
+import scala.build.input.{ModuleInputs, OnDisk, Virtual, WorkspaceOrigin}
 import scala.build.internal.Constants
 import scala.build.internals.EnvVar
 import scala.build.options.{BuildOptions, Scope}
@@ -68,12 +69,12 @@ object SetupIde extends ScalaCommand[SetupIdeOptions] {
 
   override def runCommand(options: SetupIdeOptions, args: RemainingArgs, logger: Logger): Unit = {
     val buildOptions = buildOptionsOrExit(options)
-    val moduleInputs = options.shared.composeInputs(args.all).orExit(logger)
-    CurrentParams.workspaceOpt = Some(moduleInputs.head.workspace)
+    val inputs = options.shared.composeInputs(args.all).orExit(logger)
+    CurrentParams.workspaceOpt = Some(inputs.workspace)
 
     val bspPath = writeBspConfiguration(
       options,
-      moduleInputs,
+      inputs,
       buildOptions,
       previousCommandName = None,
       args = args.all
@@ -92,7 +93,7 @@ object SetupIde extends ScalaCommand[SetupIdeOptions] {
   ): Unit =
     writeBspConfiguration(
       SetupIdeOptions(shared = options),
-      Seq(inputs),
+      SimpleInputs(inputs),
       buildOptions,
       previousCommandName,
       args
@@ -106,13 +107,13 @@ object SetupIde extends ScalaCommand[SetupIdeOptions] {
 
   private def writeBspConfiguration(
     options: SetupIdeOptions,
-    moduleInputs: Seq[ModuleInputs],
+    inputs: compose.Inputs,
     buildOptions: BuildOptions,
     previousCommandName: Option[String],
     args: Seq[String]
   ): Either[BuildException, Option[os.Path]] = either {
 
-    val virtualInputs = moduleInputs.flatMap(_.elements).collect {
+    val virtualInputs = inputs.modules.flatMap(_.elements).collect {
       case v: Virtual => v
     }
     if (virtualInputs.nonEmpty)
@@ -125,9 +126,9 @@ object SetupIde extends ScalaCommand[SetupIdeOptions] {
     val logger = options.shared.logger
 
     if (buildOptions.classPathOptions.allExtraDependencies.toSeq.nonEmpty)
-      for (module <- moduleInputs) do value(downloadDeps(module, buildOptions, logger))
+      for (module <- inputs.modules) do value(downloadDeps(module, buildOptions, logger))
 
-    val workspace = moduleInputs.head.workspace
+    val workspace = inputs.workspace
 
     val (bspName, bspJsonDestination) = bspDetails(workspace, options.bspFile)
     val scalaCliBspJsonDestination = workspace / Constants.workspaceDirName / "ide-options-v2.json"
@@ -138,12 +139,12 @@ object SetupIde extends ScalaCommand[SetupIdeOptions] {
     val scalaCliBspEnvsJsonDestination = workspace / Constants.workspaceDirName / "ide-envs.json"
 
     // FIXME single modules can also be defined with module config toml file
-    val inputArgs = if moduleInputs.size > 1 then
-      InputsComposer.findModuleConfig(args, Os.pwd)
-        .orExit(logger)
-        .fold(args)(p => Seq(p.toString))
-    else
-      moduleInputs.head.elements
+    val inputArgs = inputs match
+      case ComposedInputs(modules, targetModule, workspace) =>
+        InputsComposer.findModuleConfig(args, Os.pwd)
+          .orExit(logger)
+          .fold(args)(p => Seq(p.toString))
+      case SimpleInputs(singleModule) => singleModule.elements
         .collect { case d: OnDisk => d.path.toString }
 
     val ideInputs = IdeInputs(
@@ -192,7 +193,7 @@ object SetupIde extends ScalaCommand[SetupIdeOptions] {
     val envsForBsp          = sys.env.filter((key, _) => EnvVar.allBsp.map(_.name).contains(key))
     val scalaCliBspEnvsJson = writeToArray(envsForBsp)
 
-    if (moduleInputs.head.workspaceOrigin.contains(WorkspaceOrigin.HomeDir))
+    if (inputs.workspaceOrigin.contains(WorkspaceOrigin.HomeDir))
       value(Left(new WorkspaceError(
         s"""$baseRunnerName can not determine where to write its BSP configuration.
            |Set an explicit BSP directory path via `--bsp-directory`.
diff --git a/modules/cli/src/main/scala/scala/cli/commands/shared/SharedOptions.scala b/modules/cli/src/main/scala/scala/cli/commands/shared/SharedOptions.scala
@@ -24,9 +24,10 @@ import scala.build.bsp.buildtargets.ProjectName
 import scala.build.compiler.{BloopCompilerMaker, ScalaCompilerMaker, SimpleScalaCompilerMaker}
 import scala.build.directives.DirectiveDescription
 import scala.build.errors.{AmbiguousPlatformError, BuildException, ConfigDbException, Severity}
+import scala.build.input.compose
+import scala.build.input.compose.InputsComposer
 import scala.build.input.{
   Element,
-  InputsComposer,
   ModuleInputs,
   ResourceDirectory,
   ScalaCliInvokeData
@@ -656,7 +657,7 @@ final case class SharedOptions(
   def composeInputs(
     args: Seq[String],
     defaultInputs: () => Option[ModuleInputs] = () => ModuleInputs.default()
-  )(using ScalaCliInvokeData): Either[BuildException, Seq[ModuleInputs]] = {
+  )(using ScalaCliInvokeData): Either[BuildException, compose.Inputs] = {
     val updatedModuleInputsFromArgs
       : (Seq[String], Option[ProjectName]) => Either[BuildException, ModuleInputs] =
       (args, projectNameOpt) =>
@@ -670,7 +671,7 @@ final case class SharedOptions(
       Os.pwd,
       updatedModuleInputsFromArgs,
       ScalaCli.allowRestrictedFeatures
-    ).getModuleInputs
+    ).getInputs
   }
 
   def inputs(
