Show workers in resolve / show / inspect too

Author: alexarchambault

main/resolve/src/mill/resolve/Resolve.scala

@@ -41,10 +41,10 @@ object Resolve {
         allowPositionalCommandArgs: Boolean
     ) = {
       val taskList = resolved.map {
-        case r: Resolved.Target =>
+        case r: Resolved.NamedTask =>
           val instantiated = ResolveCore
             .instantiateModule(rootModule, r.segments.init)
-            .flatMap(instantiateTarget(r, _))
+            .flatMap(instantiateNamedTask(r, _))
 
           instantiated.map(Some(_))
 
@@ -76,7 +76,7 @@ object Resolve {
 
               directChildrenOrErr.flatMap(directChildren =>
                 directChildren.head match {
-                  case r: Resolved.Target => instantiateTarget(r, value).map(Some(_))
+                  case r: Resolved.NamedTask => instantiateNamedTask(r, value).map(Some(_))
                   case r: Resolved.Command =>
                     instantiateCommand(
                       rootModule,
@@ -104,13 +104,16 @@ object Resolve {
       items.distinctBy(_.ctx.segments)
   }
 
-  private def instantiateTarget(r: Resolved.Target, p: Module): Either[String, Target[_]] = {
+  private def instantiateNamedTask(
+      r: Resolved.NamedTask,
+      p: Module
+  ): Either[String, NamedTask[_]] = {
     val definition = Reflect
-      .reflect(p.getClass, classOf[Target[_]], _ == r.segments.parts.last, true)
+      .reflect(p.getClass, classOf[NamedTask[_]], _ == r.segments.parts.last, true)
       .head
 
     ResolveCore.catchWrapException(
-      definition.invoke(p).asInstanceOf[Target[_]]
+      definition.invoke(p).asInstanceOf[NamedTask[_]]
     )
   }
 

main/resolve/src/mill/resolve/ResolveCore.scala

@@ -29,7 +29,7 @@ private object ResolveCore {
 
   object Resolved {
     case class Module(segments: Segments, cls: Class[_]) extends Resolved
-    case class Target(segments: Segments) extends Resolved
+    case class NamedTask(segments: Segments) extends Resolved
     case class Command(segments: Segments) extends Resolved
   }
 
@@ -327,7 +327,7 @@ private object ResolveCore {
         .map(
           _.map {
             case (Resolved.Module(s, cls), _) => Resolved.Module(segments ++ s, cls)
-            case (Resolved.Target(s), _) => Resolved.Target(segments ++ s)
+            case (Resolved.NamedTask(s), _) => Resolved.NamedTask(segments ++ s)
             case (Resolved.Command(s), _) => Resolved.Command(segments ++ s)
           }
             .toSet
@@ -376,10 +376,10 @@ private object ResolveCore {
       }
     }
 
-    val targets = Reflect
-      .reflect(cls, classOf[Target[_]], namePred, noParams = true)
+    val namedTasks = Reflect
+      .reflect(cls, classOf[NamedTask[_]], namePred, noParams = true)
       .map { m =>
-        Resolved.Target(Segments.labels(decode(m.getName))) ->
+        Resolved.NamedTask(Segments.labels(decode(m.getName))) ->
           None
       }
 
@@ -388,7 +388,7 @@ private object ResolveCore {
       .map(m => decode(m.getName))
       .map { name => Resolved.Command(Segments.labels(name)) -> None }
 
-    modulesOrErr.map(_ ++ targets ++ commands)
+    modulesOrErr.map(_ ++ namedTasks ++ commands)
   }
 
   def notFoundResult(

main/src/mill/main/RunScript.scala

@@ -62,7 +62,7 @@ object RunScript {
       case 0 =>
         val nameAndJson = for (t <- targets.toSeq) yield {
           t match {
-            case t: mill.define.NamedTask[_] =>
+            case t: mill.define.NamedTask[_] if t.writerOpt.nonEmpty =>
               val jsonFile = EvaluatorPaths.resolveDestPaths(evaluator.outPath, t).meta
               val metadata = upickle.default.read[Evaluator.Cached](ujson.read(jsonFile.toIO))
               Some((t.toString, metadata.value))

main/test/src/mill/main/MainModuleTests.scala

@@ -27,6 +27,12 @@ object MainModuleTests extends TestSuite {
       Map("1" -> "hello", "2" -> "world")
     }
     def helloCommand(x: Int, y: Task[String]) = Task.Command { (x, y(), hello()) }
+    def helloWorker = Task.Worker {
+      // non-serializable, but everything should work fine nonetheless
+      new AutoCloseable {
+        def close() = ()
+      }
+    }
     override lazy val millDiscover: Discover = Discover[this.type]
   }
 
@@ -93,6 +99,16 @@ object MainModuleTests extends TestSuite {
           res.contains("hello")
         )
       }
+      test("worker") - UnitTester(mainModule, null).scoped { eval =>
+        val Right(result) = eval.apply("inspect", "helloWorker")
+
+        val Seq(res: String) = result.value
+        assert(
+          res.startsWith("helloWorker("),
+          res.contains("MainModuleTests.scala:"),
+          res.contains("hello")
+        )
+      }
     }
 
     test("show") {
@@ -173,6 +189,12 @@ object MainModuleTests extends TestSuite {
         val Seq(res) = result.value
         assert(res == ujson.Arr(1337, "lol", ujson.Arr("hello", "world")))
       }
+
+      test("worker") {
+        val Right(result) = evaluator.apply("show", "helloWorker")
+        val Seq(res) = result.value
+        assert(res == ujson.Obj())
+      }
     }
 
     test("showNamed") {
@@ -209,6 +231,18 @@ object MainModuleTests extends TestSuite {
       }
     }
 
+    test("resolve") {
+      UnitTester(mainModule, null).scoped { eval =>
+        val Right(result) = eval.apply("resolve", "_")
+
+        val Seq(res: Seq[String]) = result.value
+        assert(res.contains("hello"))
+        assert(res.contains("hello2"))
+        assert(res.contains("helloCommand"))
+        assert(res.contains("helloWorker"))
+      }
+    }
+
     test("clean") {
       val ev = UnitTester(cleanModule, null)
       val out = ev.evaluator.outPath