Cleanup terminal handling (#4477)

Since #4181 landed, we no longer
need to track `Terminal.Labelled#segments` separately and can just use
`Terminal.Labelled#task#ctx#segments#render`

Author: lihaoyi

example/fundamentals/libraries/4-mainargs/build.mill

@@ -91,10 +91,10 @@ def customPlanCommand(evaluator: Evaluator, tasks: String*) = Task.Command {
   ) match {
     case Left(err) => Left(err)
     case Right(resolved) =>
-      val (sortedGroups, _) = evaluator.plan(resolved)
-      val plan = sortedGroups
+      val plan = evaluator.plan(resolved)
+        .sortedGroups
         .keys()
-        .collect { case r: Terminal.Labelled[_] => r.render }
+        .map(_.render)
         .toArray
 
       plan.foreach(println)

example/large/selective/9-selective-execution/build.mill

@@ -181,8 +181,6 @@ bar.sources
   }
 }
 
-
-
 */
 
 // Similarly, if we make a change `qux/`, using selective execution will only run tests

main/api/src/mill/api/AggWrapper.scala

@@ -149,7 +149,8 @@ private[mill] sealed class AggWrapper(strictUniqueness: Boolean) {
       def iterator: Iterator[V] = items
       override def hashCode(): Int = items.map(_.hashCode()).sum
       override def equals(other: Any): Boolean = other match {
-        case s: Agg[?] => items.sameElements(s.items)
+        case s: Loose.Agg[?] => items.sameElements(s.items)
+        case s: Strict.Agg[?] => items.sameElements(s.items)
         case _ => super.equals(other)
       }
       override def toString: String = items.mkString("Agg(", ", ", ")")

main/eval/src/mill/eval/CodeSigUtils.scala

@@ -1,25 +1,23 @@
 package mill.eval
 
-import mill.api.{BuildInfo, MillException}
-import mill.define.{NamedTask, Task}
-import mill.util.MultiBiMap
+import mill.api.{BuildInfo, MillException, Strict}
+import mill.define.NamedTask
 
 import scala.reflect.NameTransformer.encode
 import java.lang.reflect.Method
 
 private[mill] object CodeSigUtils {
-  def precomputeMethodNamesPerClass(sortedGroups: MultiBiMap[Terminal, Task[_]])
+  def precomputeMethodNamesPerClass(transitiveNamed: Strict.Agg[NamedTask[?]])
       : (Map[Class[_], IndexedSeq[Class[_]]], Map[Class[_], Map[String, Method]]) = {
     def resolveTransitiveParents(c: Class[_]): Iterator[Class[_]] = {
       Iterator(c) ++
         Option(c.getSuperclass).iterator.flatMap(resolveTransitiveParents) ++
         c.getInterfaces.iterator.flatMap(resolveTransitiveParents)
     }
 
-    val classToTransitiveClasses: Map[Class[?], IndexedSeq[Class[?]]] = sortedGroups
-      .values()
-      .flatten
-      .collect { case namedTask: NamedTask[?] => namedTask.ctx.enclosingCls }
+    val classToTransitiveClasses: Map[Class[?], IndexedSeq[Class[?]]] = transitiveNamed
+      .iterator
+      .map { case namedTask: NamedTask[?] => namedTask.ctx.enclosingCls }
       .map(cls => cls -> resolveTransitiveParents(cls).toVector)
       .toMap
 

main/eval/src/mill/eval/Evaluator.scala

@@ -60,7 +60,7 @@ trait Evaluator extends AutoCloseable {
   def withBaseLogger(newBaseLogger: ColorLogger): Evaluator
   def withFailFast(newFailFast: Boolean): Evaluator
   def allowPositionalCommandArgs: Boolean = false
-  def plan(goals: Agg[Task[_]]): (MultiBiMap[Terminal, Task[_]], Agg[Task[_]])
+  def plan(goals: Agg[Task[_]]): Plan
 
   /**
    * Evaluate given task(s) and return the successful result(s), or throw an exception.

main/eval/src/mill/eval/EvaluatorCore.scala

@@ -71,20 +71,20 @@ private[mill] trait EvaluatorCore extends GroupEvaluator {
     os.makeDir.all(outPath)
 
     val threadNumberer = new ThreadNumberer()
-    val (sortedGroups, transitive) = Plan.plan(goals)
-    val interGroupDeps = EvaluatorCore.findInterGroupDeps(sortedGroups)
-    val terminals0 = sortedGroups.keys().toVector
+    val plan = Plan.plan(goals)
+    val interGroupDeps = EvaluatorCore.findInterGroupDeps(plan.sortedGroups)
+    val terminals0 = plan.sortedGroups.keys().toVector
     val failed = new AtomicBoolean(false)
     val count = new AtomicInteger(1)
-    val indexToTerminal = sortedGroups.keys().toArray
+    val indexToTerminal = plan.sortedGroups.keys().toArray
 
     EvaluatorLogs.logDependencyTree(interGroupDeps, indexToTerminal, outPath)
 
     // Prepare a lookup tables up front of all the method names that each class owns,
     // and the class hierarchy, so during evaluation it is cheap to look up what class
     // each target belongs to determine of the enclosing class code signature changed.
     val (classToTransitiveClasses, allTransitiveClassMethods) =
-      CodeSigUtils.precomputeMethodNamesPerClass(sortedGroups)
+      CodeSigUtils.precomputeMethodNamesPerClass(Plan.transitiveNamed(goals))
 
     val uncached = new ConcurrentHashMap[Terminal, Unit]()
     val changedValueHash = new ConcurrentHashMap[Terminal, Unit]()
@@ -106,7 +106,7 @@ private[mill] trait EvaluatorCore extends GroupEvaluator {
       for (terminal <- terminals) {
         val deps = interGroupDeps(terminal)
 
-        val group = sortedGroups.lookupKey(terminal)
+        val group = plan.sortedGroups.lookupKey(terminal)
         val exclusiveDeps = deps.filter(d => d.task.isExclusiveCommand)
 
         if (!terminal.task.isExclusiveCommand && exclusiveDeps.nonEmpty) {
@@ -162,7 +162,7 @@ private[mill] trait EvaluatorCore extends GroupEvaluator {
 
                 val res = evaluateGroupCached(
                   terminal = terminal,
-                  group = sortedGroups.lookupKey(terminal),
+                  group = plan.sortedGroups.lookupKey(terminal),
                   results = upstreamResults,
                   countMsg = countMsg,
                   verboseKeySuffix = verboseKeySuffix,
@@ -205,15 +205,13 @@ private[mill] trait EvaluatorCore extends GroupEvaluator {
     }
 
     val tasks0 = terminals0.filter {
-      case Terminal.Labelled(c: Command[_], _) => false
+      case Terminal.Labelled(c: Command[_]) => false
       case _ => true
     }
 
-    val (_, tasksTransitive0) = Plan.plan(Agg.from(tasks0.map(_.task)))
-
-    val tasksTransitive = tasksTransitive0.toSet
+    val tasksTransitive = Plan.transitiveTargets(Agg.from(tasks0.map(_.task))).toSet
     val (tasks, leafExclusiveCommands) = terminals0.partition {
-      case Terminal.Labelled(t, _) => tasksTransitive.contains(t) || !t.isExclusiveCommand
+      case Terminal.Labelled(t) => tasksTransitive.contains(t) || !t.isExclusiveCommand
       case _ => !serialCommandExec
     }
 
@@ -237,7 +235,7 @@ private[mill] trait EvaluatorCore extends GroupEvaluator {
 
     val results0: Vector[(Task[_], TaskResult[(Val, Int)])] = terminals0
       .flatMap { t =>
-        sortedGroups.lookupKey(t).flatMap { t0 =>
+        plan.sortedGroups.lookupKey(t).flatMap { t0 =>
           finishedOptsMap(t) match {
             case None => Some((t0, TaskResult(Aborted, () => Aborted)))
             case Some(res) => res.newResults.get(t0).map(r => (t0, r))
@@ -255,8 +253,8 @@ private[mill] trait EvaluatorCore extends GroupEvaluator {
       Strict.Agg.from(
         finishedOptsMap.values.flatMap(_.toSeq.flatMap(_.newEvaluated)).iterator.distinct
       ),
-      transitive,
-      getFailing(sortedGroups, results),
+      plan.transitive,
+      getFailing(plan.sortedGroups, results),
       results.map { case (k, v) => (k, v.map(_._1)) }
     )
   }

main/eval/src/mill/eval/EvaluatorImpl.scala

@@ -47,7 +47,7 @@ private[mill] case class EvaluatorImpl(
   override def withFailFast(newFailFast: Boolean): Evaluator =
     this.copy(failFast = newFailFast)
 
-  override def plan(goals: Agg[Task[_]]): (MultiBiMap[Terminal, Task[_]], Agg[Task[_]]) = {
+  override def plan(goals: Agg[Task[_]]): Plan = {
     Plan.plan(goals)
   }
 

main/eval/src/mill/eval/Graph.scala

@@ -111,7 +111,7 @@ private[mill] trait GroupEvaluator {
 
         case labelled: Terminal.Labelled[_] =>
           val out = if (!labelled.task.ctx.external) outPath else externalOutPath
-          val paths = EvaluatorPaths.resolveDestPaths(out, labelled.segments)
+          val paths = EvaluatorPaths.resolveDestPaths(out, labelled.task.ctx.segments)
           val cached = loadCachedJson(logger, inputsHash, labelled, paths)
 
           // `cached.isEmpty` means worker metadata file removed by user so recompute the worker
@@ -343,7 +343,7 @@ private[mill] trait GroupEvaluator {
       .orElse {
         labelled.task.asWorker.map { w =>
           ujson.Obj(
-            "worker" -> ujson.Str(labelled.segments.render),
+            "worker" -> ujson.Str(labelled.task.ctx.segments.render),
             "toString" -> ujson.Str(v.value.toString),
             "inputsHash" -> ujson.Num(inputsHash)
           )
@@ -397,7 +397,7 @@ private[mill] trait GroupEvaluator {
           catch {
             case e: PathRef.PathRefValidationException =>
               logger.debug(
-                s"${labelled.segments.render}: re-evaluating; ${e.getMessage}"
+                s"${labelled.render}: re-evaluating; ${e.getMessage}"
               )
               None
             case NonFatal(_) => None
@@ -430,12 +430,12 @@ private[mill] trait GroupEvaluator {
         case (_, Val(obsolete: AutoCloseable)) =>
           // worker cached but obsolete, needs to be closed
           try {
-            logger.debug(s"Closing previous worker: ${labelled.segments.render}")
+            logger.debug(s"Closing previous worker: ${labelled.render}")
             obsolete.close()
           } catch {
             case NonFatal(e) =>
               logger.error(
-                s"${labelled.segments.render}: Errors while closing obsolete worker: ${e.getMessage()}"
+                s"${labelled.render}: Errors while closing obsolete worker: ${e.getMessage()}"
               )
           }
           // make sure, we can no longer re-use a closed worker