Make selective execution work via Tasks rather than Strings (#6291)

This works around #4119 in
selective execution, which was causing problems in bootstrapping in
#6289. Instead of serializing
strings that we parse again (which fails if they contain `.super`), we
just pass the tasks directly preserving all the information intact

Tested manually

Author: lihaoyi

core/api/src/mill/api/SelectiveExecution.scala

@@ -27,6 +27,8 @@ private[mill] trait SelectiveExecution {
 
   def resolve0(tasks: Seq[String]): Result[Array[String]]
 
+  def resolveTasks0(tasks: Seq[String]): Result[Array[Task.Named[?]]]
+
   def resolveChanged(tasks: Seq[String]): Result[Seq[String]]
 
   def resolveTree(tasks: Seq[String]): Result[ujson.Value]

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

@@ -133,13 +133,18 @@ class SelectiveExecutionImpl(evaluator: Evaluator)
   }
 
   def resolve0(tasks: Seq[String]): Result[Array[String]] = {
+    resolveTasks0(tasks).map(_.map(_.ctx.segments.render))
+  }
+  def resolveTasks0(tasks: Seq[String]): Result[Array[Task.Named[?]]] = {
     for {
       (resolved, changedTasks) <-
         evaluator.resolveTasks(tasks, SelectMode.Separated).zip(this.computeChangedTasks(tasks))
     } yield {
-      val resolvedSet = resolved.map(_.ctx.segments.render).toSet
-      val downstreamSet = changedTasks.downstreamTasks.map(_.ctx.segments.render).toSet
-      resolvedSet.intersect(downstreamSet).toArray.sorted
+      val downstreamTasksRendered = changedTasks.downstreamTasks.map(_.ctx.segments.render).toSet
+
+      resolved
+        .filter(t => downstreamTasksRendered.contains(t.ctx.segments.render))
+        .toArray
     }
   }
 

libs/util/src/mill/util/SelectiveExecutionModule.scala

@@ -79,9 +79,9 @@ trait SelectiveExecutionModule extends mill.api.Module {
       if (!os.exists(evaluator.outPath / OutFiles.millSelectiveExecution)) {
         Result.Failure("`selective.run` can only be run after `selective.prepare`")
       } else {
-        evaluator.selective.resolve0(tasks).flatMap { resolved =>
-          if (resolved.isEmpty) Result.Success(())
-          else evaluator.evaluate(resolved.toSeq, SelectMode.Multi).flatMap {
+        evaluator.selective.resolveTasks0(tasks).flatMap { resolvedTasks =>
+          if (resolvedTasks.isEmpty) Result.Success(())
+          else evaluator.execute(resolvedTasks) match {
             case Evaluator.Result(_, f: Result.Failure, _, _) => f
             case Evaluator.Result(_, Result.Success(_), _, _) =>
           }