Show workers in resolve / show / inspect too

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,16 @@ object MainModuleTests extends TestSuite {
  Map("1" -> "hello", "2" -> "world")
  }
  def helloCommand(x: Int, y: Task[String]) = Task.Command { (x, y(), hello()) }
+
+ /**
+ * The hello worker
+ */
+ 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 +103,17 @@ 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("The hello worker"),
+ res.contains("hello")
+ )
+ }
  }
 
  test("show") {
@@ -173,6 +194,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 +236,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