POC : static computation of source roots for code-generating tasks

bsp/worker/src/mill/bsp/worker/MillBuildServer.scala

@@ -232,6 +232,7 @@ private class MillBuildServer(
       targetIds = _ => sourcesParams.getTargets.asScala.toSeq,
       tasks = {
         case module: MillBuildRootModule =>
+          // TODO
           Task.Anon {
             module.sources().map(p => sourceItem(p.path, false)) ++
               module.generatedSources().map(p => sourceItem(p.path, true))

contrib/bloop/src/mill/contrib/bloop/BloopImpl.scala

@@ -116,15 +116,19 @@ class BloopImpl(evs: () => Seq[Evaluator], wd: os.Path) extends ExternalModule {
     JavaModuleUtils.transitiveModules(mod, accept)
   }
 
-  protected def computeModules: Seq[JavaModule] = {
+  private def modulesToOutFolderMap: Map[JavaModule, os.Path] = {
     val evals = evs()
     evals.flatMap { eval =>
       if (eval != null)
         JavaModuleUtils.transitiveModules(eval.rootModule, accept)
-          .collect { case jm: JavaModule => jm }
+          .collect { case jm: JavaModule => (jm, eval.outPath) }
       else
         Seq.empty
-    }
+    }.toMap
+  }
+
+  protected def computeModules: Seq[JavaModule] = {
+    modulesToOutFolderMap.keys.toSeq
   }
 
   // class-based pattern matching against path-dependant types doesn't seem to work.
@@ -140,7 +144,8 @@ class BloopImpl(evs: () => Seq[Evaluator], wd: os.Path) extends ExternalModule {
    */
   def moduleSourceMap = Task.Input {
     val sources = Task.traverse(computeModules) { m =>
-      m.allSources.map { paths =>
+      // We're not using `allSources` here, one purpose. See https://github.com/com-lihaoyi/mill/discussions/4530
+      m.ideSources.map { paths =>
         name(m) -> paths.map(_.path)
       }
     }()

main/define/src/mill/define/Task.scala

@@ -37,6 +37,12 @@ abstract class Task[+T] extends Task.Ops[T] with Applyable[Task, T] {
    */
   def flushDest: Boolean = true
 
+  /**
+   * A list of paths under the `Task.dest` folder that should be considered root source directories
+   * when generating configuration for IDEs.
+   */
+  def generatedSourceRoots: Seq[os.SubPath] = Seq.empty
+
   def asTarget: Option[Target[T]] = None
   def asCommand: Option[Command[T]] = None
   def asWorker: Option[Worker[T]] = None
@@ -189,9 +195,13 @@ object Task extends TaskBase {
    */
   def apply(
       t: NamedParameterOnlyDummy = new NamedParameterOnlyDummy,
-      persistent: Boolean = false
-  ): ApplyFactory = new ApplyFactory(persistent)
-  class ApplyFactory private[mill] (val persistent: Boolean) extends TaskBase.TraverseCtxHolder {
+      persistent: Boolean = false,
+      generatedSourceRoots: Seq[os.SubPath] = Seq.empty
+  ): ApplyFactory = new ApplyFactory(persistent, generatedSourceRoots)
+  class ApplyFactory private[mill] (
+      val persistent: Boolean,
+      val generatedSourceRoots: Seq[os.SubPath]
+  ) extends TaskBase.TraverseCtxHolder {
     def apply[T](t: Result[T])(implicit
         rw: RW[T],
         ctx: mill.define.Ctx
@@ -808,8 +818,18 @@ class TargetImpl[+T](
     val t: Task[T],
     val ctx0: mill.define.Ctx,
     val readWriter: RW[_],
-    val isPrivate: Option[Boolean]
+    val isPrivate: Option[Boolean],
+    override val generatedSourceRoots: Seq[os.SubPath]
 ) extends Target[T] {
+
+  // Added for bincompat
+  def this(
+      t: Task[T],
+      ctx0: mill.define.Ctx,
+      readWriter: RW[_],
+      isPrivate: Option[Boolean]
+  ) = this(t, ctx0, readWriter, isPrivate, Seq.empty)
+
   override def asTarget: Option[Target[T]] = Some(this)
   // FIXME: deprecated return type: Change to Option
   override def readWriterOpt: Some[RW[_]] = Some(readWriter)
@@ -819,8 +839,13 @@ class PersistentImpl[+T](
     t: Task[T],
     ctx0: mill.define.Ctx,
     readWriter: RW[_],
-    isPrivate: Option[Boolean]
-) extends TargetImpl[T](t, ctx0, readWriter, isPrivate) {
+    isPrivate: Option[Boolean],
+    generatedSourceRoots: Seq[os.SubPath]
+) extends TargetImpl[T](t, ctx0, readWriter, isPrivate, generatedSourceRoots) {
+  // Added for bincompat
+  def this(t: Task[T], ctx0: mill.define.Ctx, readWriter: RW[_], isPrivate: Option[Boolean]) =
+    this(t, ctx0, readWriter, isPrivate, Seq.empty)
+
   override def flushDest = false
 }
 

scalalib/src/mill/scalalib/JavaModule.scala

@@ -11,7 +11,7 @@ import coursier.{Repository, Type}
 import mainargs.{Flag, arg}
 import mill.Agg
 import mill.api.{Ctx, JarManifest, MillException, PathRef, Result, internal}
-import mill.define.{Command, ModuleRef, Segment, Task, TaskModule}
+import mill.define.{Command, ModuleRef, NamedTask, Segment, Task, TaskModule}
 import mill.scalalib.internal.ModuleUtils
 import mill.scalalib.api.CompilationResult
 import mill.scalalib.bsp.{BspBuildTarget, BspModule, BspUri, JvmBuildTarget}
@@ -847,10 +847,59 @@ trait JavaModule
    */
   def generatedSources: T[Seq[PathRef]] = Task { Seq.empty[PathRef] }
 
+  /**
+   * A set of tasks producing generated code. The difference between this and
+   * [[generatedSources]] lies in the fact that IDE-related tasks
+   * (BSP/Bloop/GenIdea) will not run the tasks, but will use them to statically
+   * determine the location of the source code they will produce by looking up their
+   * [[Task#generatedSourceRoots]], knowing that these roots will be present under
+   * the dest directories once the task is run.
+   */
+  def deferredSourceGenerators: Seq[NamedTask[Unit]] = Seq.empty
+
+  private def deferredSourceRoots(task: NamedTask[Unit])(workspace: os.Path): Seq[os.Path] = {
+    val dest = mill
+      .eval
+      .EvaluatorPaths
+      .resolveDestPaths(workspace / "out", task)
+      .dest
+    val explicitSourceRoots = task.generatedSourceRoots
+    if (explicitSourceRoots.isEmpty) Seq(dest)
+    else explicitSourceRoots.map(subPath => dest / subPath)
+  }
+
+  /**
+   * Computes the list of source roots that will be produced by [[deferredSourceGenerators]] without
+   * actually running the generators in question.
+   */
+  def allDeferredSourceRoots: T[Seq[PathRef]] = T {
+    val ws = T.workspace
+    deferredSourceGenerators.flatMap(t => deferredSourceRoots(t)(ws)).map(PathRef(_))
+  }
+
+  /**
+   * Runs the lazy source generators, returning references to the expanded generated source roots
+   * they are supposed to have written code in.
+   */
+  final def deferredGeneratedSources: T[Seq[PathRef]] = T {
+    val ws = T.workspace
+    T.sequence {
+      deferredSourceGenerators.map { t => t.map((_: Unit) => deferredSourceRoots(t)) }
+    }().flatMap(_.apply(ws)).map(PathRef(_))
+  }
+
+  /**
+   * Task that IDE-configuration tasks should rely on, as they avoid eagerly
+   * running source generators referenced by [[deferredSourceGenerators]]
+   */
+  def ideSources: T[Seq[PathRef]] =
+    Task { sources() ++ generatedSources() ++ allDeferredSourceRoots() }
+
   /**
    * The folders containing all source files fed into the compiler
    */
-  def allSources: T[Seq[PathRef]] = Task { sources() ++ generatedSources() }
+  def allSources: T[Seq[PathRef]] =
+    Task { sources() ++ generatedSources() ++ deferredGeneratedSources() }
 
   /**
    * All individual source files fed into the Java compiler