Use named parameters for methods with many parameters (#6105)

Pull request: #6105

Author: lefou

core/eval/src/mill/eval/EvaluatorImpl.scala

@@ -65,11 +65,11 @@ final class EvaluatorImpl private[mill] (
   ): mill.api.Result[List[Segments]] = {
     os.checker.withValue(ResolveChecker(workspace)) {
       Resolve.Segments.resolve(
-        rootModule,
-        scriptArgs,
-        selectMode,
-        allowPositionalCommandArgs,
-        resolveToModuleTasks,
+        rootModule = rootModule,
+        scriptArgs = scriptArgs,
+        selectMode = selectMode,
+        allowPositionalCommandArgs = allowPositionalCommandArgs,
+        resolveToModuleTasks = resolveToModuleTasks,
         scriptModuleResolver = scriptModuleResolver(_, resolveScriptModuleDep)
       )
     }
@@ -82,11 +82,11 @@ final class EvaluatorImpl private[mill] (
   ): mill.api.Result[List[Resolved]] = {
     os.checker.withValue(ResolveChecker(workspace)) {
       Resolve.Raw.resolve(
-        rootModule,
-        scriptArgs,
-        selectMode,
-        allowPositionalCommandArgs,
-        resolveToModuleTasks,
+        rootModule = rootModule,
+        scriptArgs = scriptArgs,
+        selectMode = selectMode,
+        allowPositionalCommandArgs = allowPositionalCommandArgs,
+        resolveToModuleTasks = resolveToModuleTasks,
         scriptModuleResolver = scriptModuleResolver(_, resolveScriptModuleDep)
       )
     }
@@ -105,11 +105,11 @@ final class EvaluatorImpl private[mill] (
     os.checker.withValue(ResolveChecker(workspace)) {
       Evaluator.withCurrentEvaluator(this) {
         Resolve.Tasks.resolve(
-          rootModule,
-          scriptArgs,
-          selectMode,
-          allowPositionalCommandArgs,
-          resolveToModuleTasks,
+          rootModule = rootModule,
+          scriptArgs = scriptArgs,
+          selectMode = selectMode,
+          allowPositionalCommandArgs = allowPositionalCommandArgs,
+          resolveToModuleTasks = resolveToModuleTasks,
           scriptModuleResolver = scriptModuleResolver(_, resolveScriptModuleDep)
         )
       }
@@ -124,11 +124,11 @@ final class EvaluatorImpl private[mill] (
     os.checker.withValue(ResolveChecker(workspace)) {
       Evaluator.withCurrentEvaluator(this) {
         Resolve.Inspect.resolve(
-          rootModule,
-          scriptArgs,
-          selectMode,
-          allowPositionalCommandArgs,
-          resolveToModuleTasks,
+          rootModule = rootModule,
+          scriptArgs = scriptArgs,
+          selectMode = selectMode,
+          allowPositionalCommandArgs = allowPositionalCommandArgs,
+          resolveToModuleTasks = resolveToModuleTasks,
           scriptModuleResolver = scriptModuleResolver(_, resolveScriptModuleDep)
         )
       }
@@ -197,11 +197,11 @@ final class EvaluatorImpl private[mill] (
       }
 
     val evaluated: ExecutionResults = execution.executeTasks(
-      selectedTasks,
-      reporter,
-      testReporter,
-      logger,
-      serialCommandExec
+      goals = selectedTasks,
+      reporter = reporter,
+      testReporter = testReporter,
+      logger = logger,
+      serialCommandExec = serialCommandExec
     )
 
     val scriptHeaderWatches =
@@ -290,10 +290,10 @@ final class EvaluatorImpl private[mill] (
       os.checker.withValue(ResolveChecker(workspace)) {
         Evaluator.withCurrentEvaluator(this) {
           Resolve.Tasks.resolve(
-            rootModule,
-            scriptArgs,
-            selectMode,
-            allowPositionalCommandArgs,
+            rootModule = rootModule,
+            scriptArgs = scriptArgs,
+            selectMode = selectMode,
+            allowPositionalCommandArgs = allowPositionalCommandArgs,
             scriptModuleResolver = scriptModuleResolver(_, resolveScriptModuleDep)
           )
         }

core/eval/src/mill/eval/SelectiveExecutionImpl.scala

@@ -27,11 +27,11 @@ private[mill] class SelectiveExecutionImpl(evaluator: Evaluator)
       .map { namedTask =>
         namedTask.ctx.segments.render -> CodeSigUtils
           .codeSigForTask(
-            namedTask,
-            classToTransitiveClasses,
-            allTransitiveClassMethods,
-            codeSignatures,
-            constructorHashSignatures
+            namedTask = namedTask,
+            classToTransitiveClasses = classToTransitiveClasses,
+            allTransitiveClassMethods = allTransitiveClassMethods,
+            codeSignatures = codeSignatures,
+            constructorHashSignatures = constructorHashSignatures
           )
           .sum
       }

core/exec/src/mill/exec/Execution.scala

@@ -170,7 +170,15 @@ private[mill] case class Execution(
               .toMap
 
             futures(terminal) = Future.successful(
-              Some(GroupExecution.Results(taskResults, group.toSeq, false, -1, -1, false, Nil))
+              Some(GroupExecution.Results(
+                newResults = taskResults,
+                newEvaluated = group.toSeq,
+                cached = false,
+                inputsHash = -1,
+                previousInputsHash = -1,
+                valueHashChanged = false,
+                serializedPaths = Nil
+              ))
             )
           } else {
             futures(terminal) = Future.sequence(deps.map(futures)).map { upstreamValues =>
@@ -296,11 +304,11 @@ private[mill] case class Execution(
       val finishedOptsMap = (nonExclusiveResults ++ exclusiveResults).toMap
 
       ExecutionLogs.logInvalidationTree(
-        interGroupDeps,
-        indexToTerminal,
-        outPath,
-        uncached,
-        changedValueHash
+        interGroupDeps = interGroupDeps,
+        indexToTerminal = indexToTerminal,
+        outPath = outPath,
+        uncached = uncached,
+        changedValueHash = changedValueHash
       )
 
       val results0: Array[(Task[?], ExecResult[(Val, Int)])] = indexToTerminal

core/exec/src/mill/exec/GroupExecution.scala

@@ -96,11 +96,11 @@ trait GroupExecution {
           .iterator
           .collect { case namedTask: Task.Named[_] =>
             CodeSigUtils.codeSigForTask(
-              namedTask,
-              classToTransitiveClasses,
-              allTransitiveClassMethods,
-              codeSignatures,
-              constructorHashSignatures
+              namedTask = namedTask,
+              classToTransitiveClasses = classToTransitiveClasses,
+              allTransitiveClassMethods = allTransitiveClassMethods,
+              codeSignatures = codeSignatures,
+              constructorHashSignatures = constructorHashSignatures
             )
           }
           .flatten
@@ -515,20 +515,20 @@ trait GroupExecution {
           try {
             logger.debug(s"Closing previous worker: $labelled")
             GroupExecution.wrap(
-              workspace,
-              deps,
-              outPath,
-              paths,
-              upstreamPathRefs,
-              exclusive,
-              multiLogger,
-              logger,
-              exclusiveSystemStreams,
-              counterMsg,
-              destCreator,
-              getEvaluator().asInstanceOf[Evaluator],
-              terminal,
-              rootModule.getClass.getClassLoader
+              workspace = workspace,
+              deps = deps,
+              outPath = outPath,
+              paths = paths,
+              upstreamPathRefs = upstreamPathRefs,
+              exclusive = exclusive,
+              multiLogger = multiLogger,
+              logger = logger,
+              exclusiveSystemStreams = exclusiveSystemStreams,
+              counterMsg = counterMsg,
+              destCreator = destCreator,
+              evaluator = getEvaluator().asInstanceOf[Evaluator],
+              terminal = terminal,
+              classLoader = rootModule.getClass.getClassLoader
             ) {
               obsolete.close()
             }

core/resolve/test/src/mill/resolve/Checker.scala

@@ -48,23 +48,23 @@ class Checker[T <: RootModule0](module: T) {
 
   def resolveTasks(selectorStrings: Seq[String]) = {
     Resolve.Tasks.resolve(
-      module,
-      selectorStrings,
-      SelectMode.Separated,
-      false,
-      false,
-      _ => Nil
+      rootModule = module,
+      scriptArgs = selectorStrings,
+      selectMode = SelectMode.Separated,
+      allowPositionalCommandArgs = false,
+      resolveToModuleTasks = false,
+      scriptModuleResolver = _ => Nil
     )
   }
 
   def resolveMetadata(selectorStrings: Seq[String]) = {
     Resolve.Segments.resolve(
-      module,
-      selectorStrings,
-      SelectMode.Separated,
-      false,
-      false,
-      _ => Nil
+      rootModule = module,
+      scriptArgs = selectorStrings,
+      selectMode = SelectMode.Separated,
+      allowPositionalCommandArgs = false,
+      resolveToModuleTasks = false,
+      scriptModuleResolver = _ => Nil
     ).map(_.map(_.render))
   }
 }

runner/daemon/src/mill/daemon/MillMain0.scala

@@ -254,13 +254,13 @@ object MillMain0 {
                           _ => _ => None,
                         extraEnv: Seq[(String, String)] = Nil,
                         metaLevelOverride: Option[Int] = None
-                    ) = MillDaemonServer.withOutLock(
-                      config.noBuildLock.value,
-                      config.noWaitForBuildLock.value,
-                      out,
-                      millActiveCommandMessage,
-                      streams,
-                      outLock
+                    ): Watching.Result[RunnerState] = MillDaemonServer.withOutLock(
+                      noBuildLock = config.noBuildLock.value,
+                      noWaitForBuildLock = config.noWaitForBuildLock.value,
+                      out = out,
+                      millActiveCommandMessage = millActiveCommandMessage,
+                      streams = streams,
+                      outLock = outLock
                     ) {
                       def proceed(logger: Logger): Watching.Result[RunnerState] = {
                         // Enter key pressed, removing mill-selective-execution.json to
@@ -306,10 +306,10 @@ object MillMain0 {
                           proceed(logger)
                         case None =>
                           Using.resource(getLogger(
-                            streams,
-                            config,
+                            streams = streams,
+                            config = config,
                             enableTicker = enableTicker,
-                            daemonDir,
+                            daemonDir = daemonDir,
                             colored = colored,
                             colors = colors,
                             out = out
@@ -322,21 +322,21 @@ object MillMain0 {
                     if (config.jshell.value) {
                       val bootstrapped = runMillBootstrap(
                         skipSelectiveExecution = false,
-                        Some(stateCache),
-                        Seq("jshell") ++ config.leftoverArgs.value,
-                        streams,
-                        "jshell",
+                        prevState = Some(stateCache),
+                        tasksAndParams = Seq("jshell") ++ config.leftoverArgs.value,
+                        streams = streams,
+                        millActiveCommandMessage = "jshell",
                         metaLevelOverride = Some(1)
                       )
 
                       (true, bootstrapped.result)
                     } else if (config.repl.value) {
                       val bootstrapped = runMillBootstrap(
                         skipSelectiveExecution = false,
-                        Some(stateCache),
-                        Seq("console") ++ config.leftoverArgs.value,
-                        streams,
-                        "repl",
+                        prevState = Some(stateCache),
+                        tasksAndParams = Seq("console") ++ config.leftoverArgs.value,
+                        streams = streams,
+                        millActiveCommandMessage = "repl",
                         metaLevelOverride = Some(1)
                       )
 
@@ -364,11 +364,11 @@ object MillMain0 {
                       val watchLogger = new PrefixLogger(bspLogger, Seq("watch"))
                       while (keepGoing) {
                         val watchRes = runMillBootstrap(
-                          false,
-                          prevRunnerStateOpt,
-                          Seq("version"),
-                          initCommandLogger.streams,
-                          "BSP:initialize",
+                          skipSelectiveExecution = false,
+                          prevState = prevRunnerStateOpt,
+                          tasksAndParams = Seq("version"),
+                          streams = initCommandLogger.streams,
+                          millActiveCommandMessage = "BSP:initialize",
                           loggerOpt = Some(initCommandLogger),
                           reporter = ev => {
                             val bspIdByModule = mill.bsp.worker.BspEvaluators(
@@ -391,7 +391,7 @@ object MillMain0 {
                         prevRunnerStateOpt = Some(watchRes.result)
 
                         val sessionResultFuture = bspServerHandle.startSession(
-                          watchRes.result.frames.flatMap(_.evaluator),
+                          evaluators = watchRes.result.frames.flatMap(_.evaluator),
                           errored = watchRes.error.nonEmpty,
                           watched = watchRes.watched
                         )
@@ -497,11 +497,11 @@ object MillMain0 {
                           (skipSelectiveExecution: Boolean, prevState: Option[RunnerState]) => {
                             adjustJvmProperties(userSpecifiedProperties, initialSystemProperties)
                             runMillBootstrap(
-                              skipSelectiveExecution,
-                              prevState,
-                              config.leftoverArgs.value,
-                              streams,
-                              config.leftoverArgs.value.mkString(" ")
+                              skipSelectiveExecution = skipSelectiveExecution,
+                              prevState = prevState,
+                              tasksAndParams = config.leftoverArgs.value,
+                              streams = streams,
+                              millActiveCommandMessage = config.leftoverArgs.value.mkString(" ")
                             )
                           }
                       )