update

Author: HollandDM

core/codesig/src/mill/codesig/ReachabilityAnalysis.scala

@@ -2,11 +2,10 @@ package mill.codesig
 
 import mill.codesig.JvmModel.*
 import mill.internal.{SpanningForest, Tarjans}
-import ujson.{Arr, Obj}
+import ujson.Obj
 import upickle.default.{Writer, writer}
 
 import scala.collection.immutable.SortedMap
-import scala.collection.mutable
 
 class CallGraphAnalysis(
     localSummary: LocalSummary,
@@ -82,19 +81,18 @@ class CallGraphAnalysis(
   logger.mandatoryLog(transitiveCallGraphHashes0)
   logger.log(transitiveCallGraphHashes)
 
-  lazy val (spanningInvalidationTree: Obj, invalidClassNames: Arr) = prevTransitiveCallGraphHashesOpt() match {
+  lazy val spanningInvalidationTree: Obj = prevTransitiveCallGraphHashesOpt() match {
     case Some(prevTransitiveCallGraphHashes) =>
       CallGraphAnalysis.spanningInvalidationTree(
         prevTransitiveCallGraphHashes,
         transitiveCallGraphHashes0,
         indexToNodes,
         indexGraphEdges
       )
-    case None => ujson.Obj() -> ujson.Arr()
+    case None => ujson.Obj()
   }
 
   logger.mandatoryLog(spanningInvalidationTree)
-  logger.mandatoryLog(invalidClassNames)
 }
 
 object CallGraphAnalysis {
@@ -117,7 +115,7 @@ object CallGraphAnalysis {
       transitiveCallGraphHashes0: Array[(CallGraphAnalysis.Node, Int)],
       indexToNodes: Array[Node],
       indexGraphEdges: Array[Array[Int]]
-  ): (ujson.Obj, ujson.Arr) = {
+  ): ujson.Obj = {
     val transitiveCallGraphHashes0Map = transitiveCallGraphHashes0.toMap
 
     val nodesWithChangedHashes = indexGraphEdges
@@ -137,23 +135,10 @@ object CallGraphAnalysis {
     val reverseGraphEdges =
       indexGraphEdges.indices.map(reverseGraphMap.getOrElse(_, Array[Int]())).toArray
 
-    val spanningForest = SpanningForest.apply(reverseGraphEdges, nodesWithChangedHashes, false)
-
-    val spanningInvalidationTree = SpanningForest.spanningTreeToJsonTree(
-      spanningForest,
+    SpanningForest.spanningTreeToJsonTree(
+      SpanningForest.apply(reverseGraphEdges, nodesWithChangedHashes, false),
       k => indexToNodes(k).toString
     )
-
-    val invalidSet = invalidClassNameSet(
-      spanningForest,
-      indexToNodes.map {
-        case LocalDef(call) => call.cls.name
-        case Call(call) => call.cls.name
-        case ExternalClsCall(cls) => cls.name
-      }
-    )
-
-    (spanningInvalidationTree, invalidSet)
   }
 
   def indexGraphEdges(
@@ -278,24 +263,6 @@ object CallGraphAnalysis {
       }
   }
 
-  private def invalidClassNameSet(
-    spanningForest: SpanningForest.Node,
-    indexToClassName: Array[String]
-  ): Set[String] = {
-    val queue = mutable.ArrayBuffer.empty[(Int, SpanningForest.Node)]
-    val result = mutable.Set.empty[String]
-
-    queue.appendAll(spanningForest.values)
-
-    while (queue.nonEmpty) {
-      val (index, node) = queue.remove(0)
-      result += indexToClassName(index)
-      queue.appendAll(node.values)
-    }
-
-    result.toSet
-  }
-
   /**
    * Represents the three types of nodes in our call graph. These are kept heterogeneous
    * because flattening them out into a homogenous graph of MethodDef -> MethodDef edges

core/define/src/mill/define/Task.scala

@@ -121,7 +121,16 @@ object Task extends TaskBase {
   inline def Command[T](inline t: Result[T])(implicit
       inline w: W[T],
       inline ctx: mill.define.Ctx
-  ): Command[T] = ${ TaskMacros.commandImpl[T]('t)('w, 'ctx, exclusive = '{ false }) }
+  ): Command[T] = ${ TaskMacros.commandImpl[T]('t)('w, 'ctx, exclusive = '{ false }, persistent = '{ false }) }
+
+
+  /**
+   * This version allow [[Command]] to be persistent
+   */
+  inline def Command[T](inline persistent: Boolean)(inline t: Result[T])(implicit
+      inline w: W[T],
+      inline ctx: mill.define.Ctx
+  ): Command[T] = ${ TaskMacros.commandImpl[T]('t)('w, 'ctx, exclusive = '{ false }, persistent = '{ persistent }) }
 
   /**
    * @param exclusive Exclusive commands run serially at the end of an evaluation,
@@ -139,7 +148,7 @@ object Task extends TaskBase {
     inline def apply[T](inline t: Result[T])(implicit
         inline w: W[T],
         inline ctx: mill.define.Ctx
-    ): Command[T] = ${ TaskMacros.commandImpl[T]('t)('w, 'ctx, '{ this.exclusive }) }
+    ): Command[T] = ${ TaskMacros.commandImpl[T]('t)('w, 'ctx, '{ this.exclusive }, '{ false }) }
   }
 
   /**
@@ -390,7 +399,8 @@ class Command[+T](
     val ctx0: mill.define.Ctx,
     val writer: W[?],
     val isPrivate: Option[Boolean],
-    val exclusive: Boolean
+    val exclusive: Boolean,
+    override val persistent: Boolean
 ) extends NamedTask[T] {
 
   override def asCommand: Some[Command[T]] = Some(this)
@@ -537,12 +547,13 @@ private object TaskMacros {
   )(t: Expr[Result[T]])(
       w: Expr[W[T]],
       ctx: Expr[mill.define.Ctx],
-      exclusive: Expr[Boolean]
+      exclusive: Expr[Boolean],
+      persistent: Expr[Boolean]
   ): Expr[Command[T]] = {
     appImpl[Command, T](
       (in, ev) =>
         '{
-          new Command[T]($in, $ev, $ctx, $w, ${ taskIsPrivate() }, exclusive = $exclusive)
+          new Command[T]($in, $ev, $ctx, $w, ${ taskIsPrivate() }, exclusive = $exclusive, persistent = $persistent)
         },
       t
     )

runner/src/mill/runner/MillBuildRootModule.scala

@@ -19,6 +19,8 @@ import scala.util.Try
 
 import mill.define.Target
 import mill.runner.worker.api.MillScalaParser
+import mill.codesig.JvmModel.MethodDef
+import mill.codesig.JvmModel.MethodSig
 
 /**
  * Mill module for pre-processing a Mill `build.mill` and related files and then
@@ -138,6 +140,29 @@ abstract class MillBuildRootModule()(implicit
     }
   }
 
+  @internal
+  override protected def callGraphAnalysisIgnoreCalls(callSiteOpt: Option[MethodDef], calledSig: MethodSig): Boolean = {
+    // We ignore Commands for the same reason as we ignore Targets, and also because
+    // their implementations get gathered up all the via the `Discover` macro, but this
+    // is primarily for use as external entrypoints and shouldn't really be counted as
+    // part of the `millbuild.build#<init>` transitive call graph they would normally
+    // be counted as
+    def isCommand =
+      calledSig.desc.ret.pretty == classOf[mill.define.Command[?]].getName
+
+    // Skip calls to `millDiscover`. `millDiscover` is bundled as part of `RootModule` for
+    // convenience, but it should really never be called by any normal Mill module/task code,
+    // and is only used by downstream code in `mill.eval`/`mill.resolve`. Thus although CodeSig's
+    // conservative analysis considers potential calls from `build_.package_$#<init>` to
+    // `millDiscover()`, we can safely ignore that possibility
+    def isMillDiscover =
+      calledSig.name == "millDiscover$lzyINIT1" ||
+        calledSig.name == "millDiscover" ||
+        callSiteOpt.exists(_.sig.name == "millDiscover")
+    
+    super.callGraphAnalysisIgnoreCalls(callSiteOpt, calledSig) || isCommand || isMillDiscover
+  }
+
   def codeSignatures: T[Map[String, Int]] = Task {
     val (analysisFolder, _) = callGraphAnalysis()
     val transitiveCallGraphHashes0 = upickle.default.read[Map[String, Int]](