Tighten up `LabelledTarget` to contain a `Target[T]` instead of a `Task[T]`

4 files changed, 24 insertions, 19 deletions

diff --git a/core/src/main/scala/mill/define/Task.scala b/core/src/main/scala/mill/define/Task.scala
index 70f93d35..7635a74f 100644
--- a/core/src/main/scala/mill/define/Task.scala
+++ b/core/src/main/scala/mill/define/Task.scala
@@ -26,9 +26,15 @@ abstract class Task[+T] extends Task.Ops[T] with Applyable[T]{
   def sideHash: Int = 0
 
   def flushDest: Boolean = true
+
+  def asTarget: Option[Target[T]] = None
+  def asCommand: Option[Command[T]] = None
+  def asPersistent: Option[Persistent[T]] = None
 }
 
-trait Target[+T] extends Task[T]
+trait Target[+T] extends Task[T]{
+  override def asTarget = Some(this)
+}
 object Target extends Applicative.Applyer[Task, Task, Args]{
 
   implicit def apply[T](t: T): Target[T] = macro targetImpl[T]
@@ -113,11 +119,13 @@ class TargetImpl[+T](t: Task[T], enclosing: String) extends Target[T] {
 class Command[+T](t: Task[T]) extends Task[T] {
   val inputs = Seq(t)
   def evaluate(args: Args) = args[T](0)
+  override def asCommand = Some(this)
 }
 class Persistent[+T](t: Task[T]) extends Target[T] {
   val inputs = Seq(t)
   def evaluate(args: Args) = args[T](0)
   override def flushDest = false
+  override def asPersistent = Some(this)
 }
 object Source{
   implicit def apply(p: ammonite.ops.Path) = new Source(p)
diff --git a/core/src/main/scala/mill/discover/Discovered.scala b/core/src/main/scala/mill/discover/Discovered.scala
index e0232c1a..499a0736 100644
--- a/core/src/main/scala/mill/discover/Discovered.scala
+++ b/core/src/main/scala/mill/discover/Discovered.scala
@@ -34,7 +34,7 @@ object Discovered {
 
 
 
-  def mapping[T: Discovered](t: T): Map[Task[_], LabelledTarget[_]] = {
+  def mapping[T: Discovered](t: T): Map[Target[_], LabelledTarget[_]] = {
     implicitly[Discovered[T]].targets(t).map(x => x.target -> x).toMap
   }
 
diff --git a/core/src/main/scala/mill/discover/Mirror.scala b/core/src/main/scala/mill/discover/Mirror.scala
index 8456d976..ca89bdcb 100644
--- a/core/src/main/scala/mill/discover/Mirror.scala
+++ b/core/src/main/scala/mill/discover/Mirror.scala
@@ -35,7 +35,7 @@ object Mirror{
   /**
     * A target after being materialized in a concrete build
     */
-  case class LabelledTarget[V](target: Task[V],
+  case class LabelledTarget[V](target: Target[V],
                                format: upickle.default.ReadWriter[V],
                                segments: Seq[String])
 
diff --git a/core/src/main/scala/mill/eval/Evaluator.scala b/core/src/main/scala/mill/eval/Evaluator.scala
index e93c2dd0..db364e20 100644
--- a/core/src/main/scala/mill/eval/Evaluator.scala
+++ b/core/src/main/scala/mill/eval/Evaluator.scala
@@ -1,33 +1,30 @@
 package mill.eval
 
 import ammonite.ops._
-import mill.define.Task
+import mill.define.{Target, Task}
 import mill.discover.Mirror.LabelledTarget
 import mill.util.{Args, MultiBiMap, OSet}
 
 import scala.collection.mutable
 class Evaluator(workspacePath: Path,
-                labeling: Map[Task[_], LabelledTarget[_]]){
+                labeling: Map[Target[_], LabelledTarget[_]]){
 
   def evaluate(goals: OSet[Task[_]]): Evaluator.Results = {
     mkdir(workspacePath)
 
     val transitive = Evaluator.transitiveTargets(goals)
     val topoSorted = Evaluator.topoSorted(transitive)
-    val sortedGroups = Evaluator.groupAroundImportantTargets(
-      topoSorted,
-      t => labeling.contains(t) || goals.contains(t)
-    )
+    val sortedGroups = Evaluator.groupAroundImportantTargets(topoSorted){
+      case t: Target[_] if labeling.contains(t) || goals.contains(t) => Right(labeling(t))
+      case t if goals.contains(t) => Left(t)
+    }
 
     val evaluated = new OSet.Mutable[Task[_]]
     val results = mutable.LinkedHashMap.empty[Task[_], Any]
 
     for ((terminal, group)<- sortedGroups.items()){
       val (newResults, newEvaluated) = evaluateGroupCached(
-        labeling.get(terminal) match{
-          case Some(labeled) => Right(labeled)
-          case None => Left(terminal)
-        },
+        terminal,
         group,
         results
       )
@@ -121,23 +118,23 @@ class Evaluator(workspacePath: Path,
 object Evaluator{
   class TopoSorted private[Evaluator](val values: OSet[Task[_]])
   case class Results(values: Seq[Any], evaluated: OSet[Task[_]], transitive: OSet[Task[_]])
-  def groupAroundImportantTargets(topoSortedTargets: TopoSorted,
-                                  important: Task[_] => Boolean): MultiBiMap[Task[_], Task[_]] = {
+  def groupAroundImportantTargets[T](topoSortedTargets: TopoSorted)
+                                    (important: PartialFunction[Task[_], T]): MultiBiMap[T, Task[_]] = {
 
-    val output = new MultiBiMap.Mutable[Task[_], Task[_]]()
-    for (target <- topoSortedTargets.values if important(target)) {
+    val output = new MultiBiMap.Mutable[T, Task[_]]()
+    for ((target, t) <- topoSortedTargets.values.flatMap(t => important.lift(t).map((t, _)))) {
 
       val transitiveTargets = new OSet.Mutable[Task[_]]
       def rec(t: Task[_]): Unit = {
         if (transitiveTargets.contains(t)) () // do nothing
-        else if (important(t) && t != target) () // do nothing
+        else if (important.isDefinedAt(t) && t != target) () // do nothing
         else {
           transitiveTargets.append(t)
           t.inputs.foreach(rec)
         }
       }
       rec(target)
-      output.addAll(target, topoSorted(transitiveTargets).values)
+      output.addAll(t, topoSorted(transitiveTargets).values)
     }
     output
   }