Make input tasks only require a JSON writer, not reader

ci/mill-bootstrap.patch

@@ -0,0 +1,142 @@
+diff --git a/build.sc b/build.sc
+index cf9b2036..335e5ec0 100755
+--- a/build.sc
++++ b/build.sc
+@@ -1,16 +1,16 @@
+ import $file.ci.shared
+ import $file.ci.upload
+ import $ivy.`org.scalaj::scalaj-http:2.4.2`
+-import $ivy.`de.tototec::de.tobiasroeser.mill.vcs.version::0.1.2-4-dcde72`
+-import $ivy.`com.github.lolgab::mill-mima::0.0.6`
++//import $ivy.`de.tototec::de.tobiasroeser.mill.vcs.version::0.1.2-4-dcde72`
++//import $ivy.`com.github.lolgab::mill-mima::0.0.6`
+ import $ivy.`net.sourceforge.htmlcleaner:htmlcleaner:2.24`
+ import java.nio.file.attribute.PosixFilePermission
+
+-import com.github.lolgab.mill.mima
+-import com.github.lolgab.mill.mima.ProblemFilter
+-import com.typesafe.tools.mima.core.{DirectMissingMethodProblem, IncompatibleSignatureProblem}
++//import com.github.lolgab.mill.mima
++//import com.github.lolgab.mill.mima.ProblemFilter
++//import com.typesafe.tools.mima.core.{DirectMissingMethodProblem, IncompatibleSignatureProblem}
+ import coursier.maven.MavenRepository
+-import de.tobiasroeser.mill.vcs.version.VcsVersion
++//import de.tobiasroeser.mill.vcs.version.VcsVersion
+ import mill._
+ import mill.define.{Command, Source, Sources, Target, Task}
+ import mill.eval.Evaluator
+@@ -127,12 +127,8 @@ object Deps {
+   val jarjarabrams = ivy"com.eed3si9n.jarjarabrams::jarjar-abrams-core:1.8.0"
+ }
+
+-def millVersion: T[String] = T { VcsVersion.vcsState().format() }
+-def millLastTag: T[String] = T {
+-  VcsVersion.vcsState().lastTag.getOrElse(
+-    sys.error("No (last) git tag found. Your git history seems incomplete!")
+-  )
+-}
++def millVersion: T[String] = T { "0.0.0.test" }
++def millLastTag: T[String] = T { "0.0.0.test" }
+ def millBinPlatform: T[String] = T {
+   val tag = millLastTag()
+   if (tag.contains("-M")) tag
+@@ -170,44 +166,44 @@ trait MillCoursierModule extends CoursierModule {
+   }
+ }
+
+-trait MillMimaConfig extends mima.Mima {
+-  override def mimaPreviousVersions: T[Seq[String]] = Settings.mimaBaseVersions
+-  override def mimaPreviousArtifacts =
+-    if (Settings.mimaBaseVersions.isEmpty) T { Agg[Dep]() }
+-    else super.mimaPreviousArtifacts
+-  override def mimaExcludeAnnotations: T[Seq[String]] = Seq(
+-    "mill.api.internal",
+-    "mill.api.experimental"
+-  )
+-  override def mimaBinaryIssueFilters: Target[Seq[ProblemFilter]] = T {
+-    issueFilterByModule.getOrElse(this, Seq())
+-  }
+-  lazy val issueFilterByModule: Map[MillMimaConfig, Seq[ProblemFilter]] = Map(
+-    main.api -> Seq(
+-      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.api.Ctx.args"),
+-      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.api.Ctx.this"),
+-      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.api.Ctx#Args.args")
+-    ),
+-    main.core -> Seq(
+-      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.define.Target.makeT"),
+-      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.define.Target.args"),
+-      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.define.ParseArgs.standaloneIdent"),
+-      ProblemFilter.exclude[IncompatibleSignatureProblem](
+-        "mill.define.ParseArgs#BraceExpansionParser.plainChars"
+-      ),
+-      ProblemFilter.exclude[IncompatibleSignatureProblem](
+-        "mill.define.ParseArgs#BraceExpansionParser.braceParser"
+-      ),
+-      ProblemFilter.exclude[IncompatibleSignatureProblem](
+-        "mill.define.ParseArgs#BraceExpansionParser.parser"
+-      ),
+-      ProblemFilter.exclude[IncompatibleSignatureProblem](
+-        "mill.define.ParseArgs#BraceExpansionParser.toExpand"
+-      ),
+-      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.eval.EvaluatorPaths.*"),
+-      ProblemFilter.exclude[DirectMissingMethodProblem]("mill.eval.EvaluatorPaths.*")
+-    )
+-  )
++trait MillMimaConfig {
++//  override def mimaPreviousVersions: T[Seq[String]] = Settings.mimaBaseVersions
++//  override def mimaPreviousArtifacts =
++//    if (Settings.mimaBaseVersions.isEmpty) T { Agg[Dep]() }
++//    else super.mimaPreviousArtifacts
++//  override def mimaExcludeAnnotations: T[Seq[String]] = Seq(
++//    "mill.api.internal",
++//    "mill.api.experimental"
++//  )
++//  def mimaBinaryIssueFilters: Target[Seq[ProblemFilter]] = T {
++//    issueFilterByModule.getOrElse(this, Seq())
++//  }
++//  lazy val issueFilterByModule: Map[MillMimaConfig, Seq[ProblemFilter]] = Map(
++//    main.api -> Seq(
++//      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.api.Ctx.args"),
++//      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.api.Ctx.this"),
++//      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.api.Ctx#Args.args")
++//    ),
++//    main.core -> Seq(
++//      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.define.Target.makeT"),
++//      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.define.Target.args"),
++//      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.define.ParseArgs.standaloneIdent"),
++//      ProblemFilter.exclude[IncompatibleSignatureProblem](
++//        "mill.define.ParseArgs#BraceExpansionParser.plainChars"
++//      ),
++//      ProblemFilter.exclude[IncompatibleSignatureProblem](
++//        "mill.define.ParseArgs#BraceExpansionParser.braceParser"
++//      ),
++//      ProblemFilter.exclude[IncompatibleSignatureProblem](
++//        "mill.define.ParseArgs#BraceExpansionParser.parser"
++//      ),
++//      ProblemFilter.exclude[IncompatibleSignatureProblem](
++//        "mill.define.ParseArgs#BraceExpansionParser.toExpand"
++//      ),
++//      ProblemFilter.exclude[IncompatibleSignatureProblem]("mill.eval.EvaluatorPaths.*"),
++//      ProblemFilter.exclude[DirectMissingMethodProblem]("mill.eval.EvaluatorPaths.*")
++//    )
++//  )
+ }
+
+ trait MillApiModule
+@@ -1255,12 +1251,11 @@ def launcher = T {
+ }
+
+ def uploadToGithub(authKey: String) = T.command {
+-  val vcsState = VcsVersion.vcsState()
+-  val label = vcsState.format()
++//  val vcsState = VcsVersion.vcsState()
++//  val label = vcsState.format()
++  val label = millVersion()
+   if (label != millVersion()) sys.error("Modified mill version detected, aborting upload")
+-  val releaseTag = vcsState.lastTag.getOrElse(sys.error(
+-    "Incomplete git history. No tag found.\nIf on CI, make sure your git checkout job includes enough history."
+-  ))
++  val releaseTag = millLastTag()
+
+   if (releaseTag == label) {
+     scalaj.http.Http(

docs/antora/modules/ROOT/pages/Tasks.adoc

@@ -306,7 +306,7 @@ different Task types:
 | |Target |Command |Source/Input |Anonymous Task |Persistent Target |Worker 
 
 |Cached to Disk |X |X | | |X |
-|Must be JSON Writable |X |X | | |X | 
+|Must be JSON Writable |X |X |X| |X |
 |Must be JSON Readable |X | | | |X | 
 |Runnable from the Command Line |X |X | | |X | 
 |Can Take Arguments | |X | |X | | 

main/core/src/mill/define/BaseModule.scala

@@ -21,7 +21,6 @@ abstract class BaseModule(
         implicitly,
         BasePath(millSourcePath0),
         Segments(),
-        mill.define.Overrides(0),
         Ctx.External(external0),
         Ctx.Foreign(foreign0),
         millFile0,

main/core/src/mill/define/Ctx.scala

@@ -64,7 +64,6 @@ case class Ctx(
     segment: Segment,
     millSourcePath: os.Path,
     segments: Segments,
-    overrides: Int,
     external: Boolean,
     foreign: Option[Segments],
     fileName: String,
@@ -81,7 +80,6 @@ object Ctx {
       millName0: sourcecode.Name,
       millModuleBasePath0: BasePath,
       segments0: Segments,
-      overrides0: mill.define.Overrides,
       external0: External,
       foreign0: Foreign,
       fileName: sourcecode.File,
@@ -93,7 +91,6 @@ object Ctx {
       Segment.Label(millName0.value),
       millModuleBasePath0.value,
       segments0,
-      overrides0.value,
       external0.value,
       foreign0.value,
       fileName.value,

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

@@ -185,11 +185,11 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
       )
     )
   }
-  def input[T](value: Result[T])(implicit rw: RW[T], ctx: mill.define.Ctx): Input[T] =
+  def input[T](value: Result[T])(implicit w: upickle.default.Writer[T], ctx: mill.define.Ctx): Input[T] =
     macro inputImpl[T]
 
   def inputImpl[T: c.WeakTypeTag](c: Context)(value: c.Expr[T])(
-      rw: c.Expr[RW[T]],
+      w: c.Expr[upickle.default.Writer[T]],
       ctx: c.Expr[mill.define.Ctx]
   ): c.Expr[Input[T]] = {
     import c.universe._
@@ -199,7 +199,7 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
         new Input[T](
           Applicative.impl[Task, T, mill.api.Ctx](c)(value).splice,
           ctx.splice,
-          rw.splice
+          w.splice
         )
       )
     )
@@ -209,23 +209,20 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
       ctx: mill.define.Ctx,
       w: W[T],
       cls: EnclosingClass,
-      overrides: Overrides
   ): Command[T] = {
-    new Command(t, ctx, w, cls.value, overrides.value)
+    new Command(t, ctx, w, cls.value)
   }
 
   def command[T](t: Result[T])(implicit
       w: W[T],
       ctx: mill.define.Ctx,
       cls: EnclosingClass,
-      overrides: Overrides
   ): Command[T] = macro commandImpl[T]
 
   def commandImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T])(
       w: c.Expr[W[T]],
       ctx: c.Expr[mill.define.Ctx],
       cls: c.Expr[EnclosingClass],
-      overrides: c.Expr[Overrides]
   ): c.Expr[Command[T]] = {
     import c.universe._
     reify(
@@ -234,7 +231,6 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
         ctx.splice,
         w.splice,
         cls.splice.value,
-        overrides.splice.value
       )
     )
   }
@@ -317,7 +313,6 @@ class Command[+T](
     ctx0: mill.define.Ctx,
     val writer: W[_],
     val cls: Class[_],
-    val overrides: Int
 ) extends NamedTaskImpl[T](ctx0, t) {
   override def asCommand = Some(this)
 }
@@ -333,20 +328,16 @@ class Persistent[+T](t: Task[T], ctx0: mill.define.Ctx, readWrite: RW[_])
   override def flushDest = false
 }
 
-class Input[T](t: Task[T], ctx0: mill.define.Ctx, val readWrite: RW[_])
-    extends NamedTaskImpl[T](ctx0, t)
-    with Target[T] {
+class Input[T](t: Task[T], ctx0: mill.define.Ctx, val writer: upickle.default.Writer[_])
+    extends NamedTaskImpl[T](ctx0, t) {
   override def sideHash = util.Random.nextInt()
 }
 
 class Sources(t: Task[Seq[PathRef]], ctx0: mill.define.Ctx)
     extends Input[Seq[PathRef]](
       t,
       ctx0,
-      RW.join(
-        upickle.default.SeqLikeReader[Seq, PathRef],
-        upickle.default.SeqLikeWriter[Seq, PathRef]
-      )
+      upickle.default.SeqLikeWriter[Seq, PathRef]
     )
 
 class Source(t: Task[PathRef], ctx0: mill.define.Ctx)

main/core/src/mill/eval/Evaluator.scala

@@ -18,13 +18,14 @@ import scala.jdk.CollectionConverters._
 import scala.reflect.ClassTag
 import scala.util.control.NonFatal
 
-case class Labelled[T](task: NamedTask[T], segments: Segments) {
+case class Labelled[T](task: NamedTask[T], segments: Segments){
   def format = task match {
     case t: Target[T] => Some(t.readWrite.asInstanceOf[upickle.default.ReadWriter[T]])
     case _ => None
   }
   def writer = task match {
     case t: mill.define.Command[T] => Some(t.writer.asInstanceOf[upickle.default.Writer[T]])
+    case t: mill.define.Input[T] => Some(t.writer.asInstanceOf[upickle.default.Writer[T]])
     case t: Target[T] => Some(t.readWrite.asInstanceOf[upickle.default.ReadWriter[T]])
     case _ => None
   }
@@ -93,7 +94,7 @@ case class Evaluator(
         (int: Int) => Option.empty[CompileProblemReporter],
       testReporter: TestReporter = DummyTestReporter
   ): Evaluator.Results = {
-    val (sortedGroups, transitive) = Evaluator.plan(rootModule, goals)
+    val (sortedGroups, transitive) = Evaluator.plan(goals)
 
     val evaluated = new Agg.Mutable[Task[_]]
     val results = mutable.LinkedHashMap.empty[Task[_], mill.api.Result[(Any, Int)]]
@@ -175,7 +176,7 @@ case class Evaluator(
     os.makeDir.all(outPath)
     val timeLog = new ParallelProfileLogger(outPath, System.currentTimeMillis())
 
-    val (sortedGroups, transitive) = Evaluator.plan(rootModule, goals)
+    val (sortedGroups, transitive) = Evaluator.plan(goals)
 
     val interGroupDeps = findInterGroupDeps(sortedGroups)
     import scala.concurrent._
@@ -656,47 +657,30 @@ object Evaluator {
     def values = rawValues.collect { case mill.api.Result.Success(v) => v }
   }
 
-  def plan(rootModule: BaseModule, goals: Agg[Task[_]]) = {
+  def plan(goals: Agg[Task[_]]) = {
     val transitive = Graph.transitiveTargets(goals)
     val topoSorted = Graph.topoSorted(transitive)
+    val seen = collection.mutable.Set.empty[Segments]
+    val overriden = collection.mutable.Set.empty[Task[_]]
+    topoSorted.values.reverse.foreach{
+      case x: NamedTask[_] =>
+        if (!seen.contains(x.ctx.segments)) seen.add(x.ctx.segments)
+        else overriden.add(x)
+      case _ => //donothing
+    }
+
     val sortedGroups = Graph.groupAroundImportantTargets(topoSorted) {
       case t: NamedTask[Any] =>
         val segments = t.ctx.segments
-        val finalTaskOverrides = t match {
-          case t: Target[_] =>
-            rootModule.millInternal.segmentsToTargets.get(segments).fold(0)(_.ctx.overrides)
-
-          case c: mill.define.Command[_] =>
-            def findMatching(cls: Class[_]): Option[Seq[(Int, MainData[_, _])]] = {
-              rootModule.millDiscover.value.get(cls) match {
-                case Some(v) => Some(v)
-                case None =>
-                  cls.getSuperclass match {
-                    case null => None
-                    case superCls => findMatching(superCls)
-                  }
-              }
-            }
-
-            findMatching(c.cls) match {
-              case Some(v) =>
-                v.find(_._2.name == c.ctx.segment.pathSegments.head).get._1
-              // For now we don't properly support overrides for external modules
-              // that do not appear in the Evaluator's main Discovered listing
-              case None => 0
-            }
-
-          case c: mill.define.Worker[_] => 0
-        }
 
         val additional =
-          if (finalTaskOverrides == t.ctx.overrides) Nil
-          else
-            Seq(Segment.Label("overriden")) ++ t.ctx.enclosing.split("\\.|#| ").map(Segment.Label)
+          if (!overriden(t)) Nil
+          else Seq(Segment.Label("overriden")) ++ t.ctx.enclosing.split("\\.|#| ").map(Segment.Label)
 
         Right(Labelled(t, segments ++ additional))
       case t if goals.contains(t) => Left(t)
     }
+
     (sortedGroups, transitive)
   }
 

main/src/mill/main/MainModule.scala

@@ -117,7 +117,7 @@ trait MainModule extends mill.Module {
     ) match {
       case Left(err) => Left(err)
       case Right(rs) =>
-        val (sortedGroups, _) = Evaluator.plan(evaluator.rootModule, rs)
+        val (sortedGroups, _) = Evaluator.plan(rs)
         Right(sortedGroups.keys().collect { case Right(r) => r }.toArray)
     }
   }