Rename ModuleInputs to Module

Author: MaciejG604

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

@@ -30,7 +30,7 @@ import scala.util.control.NonFatal
 import scala.util.{Properties, Try}
 
 trait Build {
-  def inputs: ModuleInputs
+  def inputs: Module
   def options: BuildOptions
   def scope: Scope
   def outputOpt: Option[os.Path]
@@ -43,17 +43,17 @@ trait Build {
 object Build {
 
   final case class Successful(
-    inputs: ModuleInputs,
-    options: BuildOptions,
-    scalaParams: Option[ScalaParameters],
-    scope: Scope,
-    sources: Sources,
-    artifacts: Artifacts,
-    project: Project,
-    output: os.Path,
-    diagnostics: Option[Seq[(Either[String, os.Path], bsp4j.Diagnostic)]],
-    generatedSources: Seq[GeneratedSource],
-    isPartial: Boolean
+                               inputs: Module,
+                               options: BuildOptions,
+                               scalaParams: Option[ScalaParameters],
+                               scope: Scope,
+                               sources: Sources,
+                               artifacts: Artifacts,
+                               project: Project,
+                               output: os.Path,
+                               diagnostics: Option[Seq[(Either[String, os.Path], bsp4j.Diagnostic)]],
+                               generatedSources: Seq[GeneratedSource],
+                               isPartial: Boolean
   ) extends Build {
     def success: Boolean                  = true
     def successfulOpt: Some[this.type]    = Some(this)
@@ -166,24 +166,24 @@ object Build {
   }
 
   final case class Failed(
-    inputs: ModuleInputs,
-    options: BuildOptions,
-    scope: Scope,
-    sources: Sources,
-    artifacts: Artifacts,
-    project: Project,
-    diagnostics: Option[Seq[(Either[String, os.Path], bsp4j.Diagnostic)]]
+                           inputs: Module,
+                           options: BuildOptions,
+                           scope: Scope,
+                           sources: Sources,
+                           artifacts: Artifacts,
+                           project: Project,
+                           diagnostics: Option[Seq[(Either[String, os.Path], bsp4j.Diagnostic)]]
   ) extends Build {
     def success: Boolean         = false
     def successfulOpt: None.type = None
     def outputOpt: None.type     = None
   }
 
   final case class Cancelled(
-    inputs: ModuleInputs,
-    options: BuildOptions,
-    scope: Scope,
-    reason: String
+                              inputs: Module,
+                              options: BuildOptions,
+                              scope: Scope,
+                              reason: String
   ) extends Build {
     def success: Boolean         = false
     def successfulOpt: None.type = None
@@ -195,10 +195,10 @@ object Build {
     * Using only the command-line options not the ones from the sources.
     */
   def updateInputs(
-    inputs: ModuleInputs,
-    options: BuildOptions,
-    testOptions: Option[BuildOptions] = None
-  ): ModuleInputs = {
+                    inputs: Module,
+                    options: BuildOptions,
+                    testOptions: Option[BuildOptions] = None
+  ): Module = {
 
     // If some options are manually overridden, append a hash of the options to the project name
     // Using options, not options0 - only the command-line options are taken into account. No hash is
@@ -215,7 +215,7 @@ object Build {
   }
 
   private def allInputs(
-    inputs: ModuleInputs,
+    inputs: Module,
     options: BuildOptions,
     logger: Logger
   )(using ScalaCliInvokeData) =
@@ -232,9 +232,8 @@ object Build {
     )
 
   private def build(
-    inputs: ModuleInputs,
-    crossSources: CrossSources,
-    options: BuildOptions,
+    inputs: Module,
+    crossSources: CrossSources,options: BuildOptions,
     logger: Logger,
     buildClient: BloopBuildClient,
     compiler: ScalaCompiler,
@@ -247,7 +246,7 @@ object Build {
     val sharedOptions = crossSources.sharedOptions(options)
     val crossOptions  = sharedOptions.crossOptions
 
-    def doPostProcess(build: Build, inputs: ModuleInputs, scope: Scope): Unit = build match {
+    def doPostProcess(build: Build, inputs: Module, scope: Scope): Unit = build match {
       case build: Build.Successful =>
         for (sv <- build.project.scalaCompiler.map(_.scalaVersion))
           postProcess(
@@ -426,17 +425,17 @@ object Build {
   }
 
   private def build(
-    inputs: ModuleInputs,
-    sources: Sources,
-    generatedSources: Seq[GeneratedSource],
-    options: BuildOptions,
-    scope: Scope,
-    logger: Logger,
-    buildClient: BloopBuildClient,
-    compiler: ScalaCompiler,
-    buildTests: Boolean,
-    partial: Option[Boolean],
-    actionableDiagnostics: Option[Boolean]
+                     inputs: Module,
+                     sources: Sources,
+                     generatedSources: Seq[GeneratedSource],
+                     options: BuildOptions,
+                     scope: Scope,
+                     logger: Logger,
+                     buildClient: BloopBuildClient,
+                     compiler: ScalaCompiler,
+                     buildTests: Boolean,
+                     partial: Option[Boolean],
+                     actionableDiagnostics: Option[Boolean]
   )(using ScalaCliInvokeData): Either[BuildException, Build] = either {
 
     val build0 = value {
@@ -498,9 +497,9 @@ object Build {
     root / Constants.workspaceDirName / projectName.name / s"resources-${scope.name}"
 
   def scalaNativeSupported(
-    options: BuildOptions,
-    inputs: ModuleInputs,
-    logger: Logger
+                            options: BuildOptions,
+                            inputs: Module,
+                            logger: Logger
   ): Either[BuildException, Option[ScalaNativeCompatibilityError]] =
     either {
       val scalaParamsOpt = value(options.scalaParams)
@@ -557,7 +556,7 @@ object Build {
     }
 
   def build(
-    inputs: ModuleInputs,
+    inputs: Module,
     options: BuildOptions,
     compilerMaker: ScalaCompilerMaker,
     docCompilerMakerOpt: Option[ScalaCompilerMaker],
@@ -637,16 +636,16 @@ object Build {
   }
 
   def watch(
-    inputs: ModuleInputs,
-    options: BuildOptions,
-    compilerMaker: ScalaCompilerMaker,
-    docCompilerMakerOpt: Option[ScalaCompilerMaker],
-    logger: Logger,
-    crossBuilds: Boolean,
-    buildTests: Boolean,
-    partial: Option[Boolean],
-    actionableDiagnostics: Option[Boolean],
-    postAction: () => Unit = () => ()
+             inputs: Module,
+             options: BuildOptions,
+             compilerMaker: ScalaCompilerMaker,
+             docCompilerMakerOpt: Option[ScalaCompilerMaker],
+             logger: Logger,
+             crossBuilds: Boolean,
+             buildTests: Boolean,
+             partial: Option[Boolean],
+             actionableDiagnostics: Option[Boolean],
+             postAction: () => Unit = () => ()
   )(action: Either[BuildException, Builds] => Unit)(using ScalaCliInvokeData): Watcher = {
 
     val buildClient = BloopBuildClient.create(
@@ -841,15 +840,15 @@ object Build {
     *   a bloop [[Project]]
     */
   def buildProject(
-    inputs: ModuleInputs,
-    sources: Sources,
-    generatedSources: Seq[GeneratedSource],
-    options: BuildOptions,
-    compilerJvmVersionOpt: Option[Positioned[Int]],
-    scope: Scope,
-    logger: Logger,
-    artifacts: Artifacts,
-    maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
+                    inputs: Module,
+                    sources: Sources,
+                    generatedSources: Seq[GeneratedSource],
+                    options: BuildOptions,
+                    compilerJvmVersionOpt: Option[Positioned[Int]],
+                    scope: Scope,
+                    logger: Logger,
+                    artifacts: Artifacts,
+                    maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
   ): Either[BuildException, Project] = either {
 
     val allSources = sources.paths.map(_._1) ++ generatedSources.map(_.generated)
@@ -1033,16 +1032,16 @@ object Build {
   }
 
   def prepareBuild(
-    inputs: ModuleInputs,
-    sources: Sources,
-    generatedSources: Seq[GeneratedSource],
-    options: BuildOptions,
-    compilerJvmVersionOpt: Option[Positioned[Int]],
-    scope: Scope,
-    compiler: ScalaCompiler,
-    logger: Logger,
-    buildClient: BloopBuildClient,
-    maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
+                    inputs: Module,
+                    sources: Sources,
+                    generatedSources: Seq[GeneratedSource],
+                    options: BuildOptions,
+                    compilerJvmVersionOpt: Option[Positioned[Int]],
+                    scope: Scope,
+                    compiler: ScalaCompiler,
+                    logger: Logger,
+                    buildClient: BloopBuildClient,
+                    maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
   ): Either[BuildException, (os.Path, Option[ScalaParameters], Artifacts, Project, Boolean)] =
     either {
 
@@ -1114,15 +1113,15 @@ object Build {
     }
 
   def buildOnce(
-    inputs: ModuleInputs,
-    sources: Sources,
-    generatedSources: Seq[GeneratedSource],
-    options: BuildOptions,
-    scope: Scope,
-    logger: Logger,
-    buildClient: BloopBuildClient,
-    compiler: ScalaCompiler,
-    partialOpt: Option[Boolean]
+                 inputs: Module,
+                 sources: Sources,
+                 generatedSources: Seq[GeneratedSource],
+                 options: BuildOptions,
+                 scope: Scope,
+                 logger: Logger,
+                 buildClient: BloopBuildClient,
+                 compiler: ScalaCompiler,
+                 partialOpt: Option[Boolean]
   ): Either[BuildException, Build] = either {
 
     if (options.platform.value == Platform.Native)
@@ -1284,14 +1283,14 @@ object Build {
     else path.toString
 
   private def jmhBuild(
-    inputs: ModuleInputs,
-    build: Build.Successful,
-    logger: Logger,
-    javaCommand: String,
-    buildClient: BloopBuildClient,
-    compiler: ScalaCompiler,
-    buildTests: Boolean,
-    actionableDiagnostics: Option[Boolean]
+                        inputs: Module,
+                        build: Build.Successful,
+                        logger: Logger,
+                        javaCommand: String,
+                        buildClient: BloopBuildClient,
+                        compiler: ScalaCompiler,
+                        buildTests: Boolean,
+                        actionableDiagnostics: Option[Boolean]
   )(using ScalaCliInvokeData): Either[BuildException, Option[Build]] = either {
     val jmhProjectName = inputs.projectName.name + "_jmh"
     val jmhOutputDir   = inputs.workspace / Constants.workspaceDirName / jmhProjectName

modules/build/src/main/scala/scala/build/CrossSources.scala

@@ -140,7 +140,7 @@ final case class CrossSources(
 
 object CrossSources {
 
-  private def withinTestSubDirectory(p: ScopePath, inputs: ModuleInputs): Boolean =
+  private def withinTestSubDirectory(p: ScopePath, inputs: Module): Boolean =
     p.root.exists { path =>
       val fullPath = path / p.subPath
       inputs.elements.exists {
@@ -156,13 +156,13 @@ object CrossSources {
     *   a CrossSources and Inputs which contains element processed from using directives
     */
   def forModuleInputs(
-    inputs: ModuleInputs,
-    preprocessors: Seq[Preprocessor],
-    logger: Logger,
-    suppressWarningOptions: SuppressWarningOptions,
-    exclude: Seq[Positioned[String]] = Nil,
-    maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
-  )(using ScalaCliInvokeData): Either[BuildException, (CrossSources, ModuleInputs)] = either {
+                       inputs: Module,
+                       preprocessors: Seq[Preprocessor],
+                       logger: Logger,
+                       suppressWarningOptions: SuppressWarningOptions,
+                       exclude: Seq[Positioned[String]] = Nil,
+                       maybeRecoverOnError: BuildException => Option[BuildException] = e => Some(e)
+  )(using ScalaCliInvokeData): Either[BuildException, (CrossSources, Module)] = either {
 
     def preprocessSources(elems: Seq[SingleElement])
       : Either[BuildException, Seq[PreprocessedSource]] =
@@ -379,8 +379,8 @@ object CrossSources {
     *   the resource directories that should be added to the classpath
     */
   private def resolveResourceDirs(
-    allInputs: ModuleInputs,
-    preprocessedSources: Seq[PreprocessedSource]
+                                   allInputs: Module,
+                                   preprocessedSources: Seq[PreprocessedSource]
   ): Seq[WithBuildRequirements[os.Path]] = {
     val fromInputs = allInputs.elements
       .collect { case r: ResourceDirectory => WithBuildRequirements(BuildRequirements(), r.path) }

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

@@ -6,7 +6,7 @@ import coursier.util.Task
 import java.nio.charset.StandardCharsets
 
 import scala.build.info.BuildInfo
-import scala.build.input.ModuleInputs
+import scala.build.input.Module
 import scala.build.internal.{CodeWrapper, WrapperParams}
 import scala.build.options.{BuildOptions, Scope}
 import scala.build.preprocessing.*
@@ -19,7 +19,7 @@ final case class Sources(
   buildOptions: BuildOptions
 ) {
 
-  def withVirtualDir(inputs: ModuleInputs, scope: Scope, options: BuildOptions): Sources = {
+  def withVirtualDir(inputs: Module, scope: Scope, options: BuildOptions): Sources = {
 
     val srcRootPath = inputs.generatedSrcRoot(scope)
     val resourceDirs0 = options.classPathOptions.resourcesVirtualDir.map { path =>

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

@@ -6,7 +6,7 @@ import java.util.concurrent.atomic.AtomicReference
 
 import scala.build.Build
 import scala.build.compiler.BloopCompiler
-import scala.build.input.{ModuleInputs, OnDisk, SingleFile, Virtual, compose}
+import scala.build.input.{Module, OnDisk, SingleFile, Virtual, compose}
 
 final class BloopSession(
   val inputs: compose.Inputs,

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

@@ -3,7 +3,7 @@ package scala.build.bsp
 import java.io.{InputStream, OutputStream}
 
 import scala.build.errors.BuildException
-import scala.build.input.{ModuleInputs, ScalaCliInvokeData, compose}
+import scala.build.input.{Module, ScalaCliInvokeData, compose}
 import scala.concurrent.Future
 
 trait Bsp {