WIP: provide Mapping as a Ctx argument that can be accessed from within Tasks, for usage within `GenIdea` and similar

10 files changed, 45 insertions, 33 deletions

diff --git a/core/src/main/scala/mill/eval/Evaluator.scala b/core/src/main/scala/mill/eval/Evaluator.scala
index 4f0ace0c..5ca89793 100644
--- a/core/src/main/scala/mill/eval/Evaluator.scala
+++ b/core/src/main/scala/mill/eval/Evaluator.scala
@@ -13,10 +13,12 @@ import mill.util._
 
 import scala.collection.mutable
 
-class Evaluator(workspacePath: Path,
-                labeling: Map[Target[_], LabelledTarget[_]],
-                log: Logger,
-                val classLoaderSig: Seq[(Path, Long)] = Evaluator.classLoaderSig){
+class Evaluator[T](workspacePath: Path,
+                   val mapping: Discovered.Mapping[T],
+                   log: Logger,
+                   val classLoaderSig: Seq[(Path, Long)] = Evaluator.classLoaderSig){
+
+  val labeling = mapping.value
   val workerCache = mutable.Map.empty[Ctx.Loader[_], Any]
 
   def evaluate(goals: OSet[Task[_]]): Evaluator.Results = {
@@ -48,15 +50,7 @@ class Evaluator(workspacePath: Path,
     Evaluator.Results(goals.indexed.map(results), evaluated, transitive, failing)
   }
 
-  def resolveDestPaths(t: LabelledTarget[_]): (Path, Path) = {
-    val segmentStrings = t.segments.flatMap{
-      case Mirror.Segment.Label(s) => Seq(s)
-      case Mirror.Segment.Cross(values) => values.map(_.toString)
-    }
-    val targetDestPath = workspacePath / segmentStrings
-    val metadataPath = targetDestPath / up / (targetDestPath.last + ".mill.json")
-    (targetDestPath, metadataPath)
-  }
+
 
   def evaluateGroupCached(terminal: Either[Task[_], LabelledTarget[_]],
                           group: OSet[Task[_]],
@@ -74,7 +68,7 @@ class Evaluator(workspacePath: Path,
       case Left(task) =>
         evaluateGroup(group, results, targetDestPath = None, maybeTargetLabel = None)
       case Right(labelledTarget) =>
-        val (destPath, metadataPath) = resolveDestPaths(labelledTarget)
+        val (destPath, metadataPath) = Evaluator.resolveDestPaths(workspacePath, labelledTarget)
         val cached = for{
           json <- scala.util.Try(upickle.json.read(read(metadataPath))).toOption
           (cachedHash, terminalResult) <- scala.util.Try(upickle.default.readJs[(Int, upickle.Js.Value)](json)).toOption
@@ -168,7 +162,8 @@ class Evaluator(workspacePath: Path,
               def load[T](x: Ctx.Loader[T]): T = {
                 workerCache.getOrElseUpdate(x, x.make()).asInstanceOf[T]
               }
-            }
+            },
+            mapping
           )
 
           val out = System.out
@@ -211,6 +206,16 @@ class Evaluator(workspacePath: Path,
 
 
 object Evaluator{
+  def resolveDestPaths(workspacePath: Path, t: LabelledTarget[_]): (Path, Path) = {
+    val segmentStrings = t.segments.flatMap{
+      case Mirror.Segment.Label(s) => Seq(s)
+      case Mirror.Segment.Cross(values) => values.map(_.toString)
+    }
+    val targetDestPath = workspacePath / segmentStrings
+    val metadataPath = targetDestPath / up / (targetDestPath.last + ".mill.json")
+    (targetDestPath, metadataPath)
+  }
+
   // check if the build itself has changed
   def classLoaderSig = Thread.currentThread().getContextClassLoader match {
     case scl: SpecialClassLoader => scl.classpathSignature
diff --git a/core/src/main/scala/mill/main/MainRunner.scala b/core/src/main/scala/mill/main/MainRunner.scala
index 9239463f..b99c4dc4 100644
--- a/core/src/main/scala/mill/main/MainRunner.scala
+++ b/core/src/main/scala/mill/main/MainRunner.scala
@@ -9,7 +9,7 @@ class MainRunner(config: ammonite.main.Cli.Config)
     config,
     System.out, System.err, System.in, System.out, System.err
   ){
-  var lastEvaluator: Option[(Seq[(Path, Long)], Discovered.Mapping[_], Evaluator)] = None
+  var lastEvaluator: Option[(Seq[(Path, Long)], Discovered.Mapping[_], Evaluator[_])] = None
   override def runScript(scriptPath: Path, scriptArgs: List[String]) =
     watchLoop(
       isRepl = false,
diff --git a/core/src/main/scala/mill/main/MainWrapper.scala b/core/src/main/scala/mill/main/MainWrapper.scala
index 813cd06b..403740aa 100644
--- a/core/src/main/scala/mill/main/MainWrapper.scala
+++ b/core/src/main/scala/mill/main/MainWrapper.scala
@@ -12,7 +12,7 @@ trait MainWrapper[T]{
     new mill.main.ReplApplyHandler(
       new mill.eval.Evaluator(
         ammonite.ops.pwd / 'out,
-        mapping.value,
+        mapping,
         new mill.util.PrintLogger(true)
       )
     )
diff --git a/core/src/main/scala/mill/main/ReplApplyHandler.scala b/core/src/main/scala/mill/main/ReplApplyHandler.scala
index bb55c03f..f91d0ff2 100644
--- a/core/src/main/scala/mill/main/ReplApplyHandler.scala
+++ b/core/src/main/scala/mill/main/ReplApplyHandler.scala
@@ -6,7 +6,7 @@ import mill.define.Task
 import mill.eval.Evaluator
 import mill.util.{OSet}
 
-class ReplApplyHandler(evaluator: Evaluator) extends ApplyHandler[Task] {
+class ReplApplyHandler(evaluator: Evaluator[_]) extends ApplyHandler[Task] {
   // Evaluate classLoaderSig only once in the REPL to avoid busting caches
   // as the user enters more REPL commands and changes the classpath
   val classLoaderSig = Evaluator.classLoaderSig
diff --git a/core/src/main/scala/mill/main/RunScript.scala b/core/src/main/scala/mill/main/RunScript.scala
index 14d521fe..decc18a0 100644
--- a/core/src/main/scala/mill/main/RunScript.scala
+++ b/core/src/main/scala/mill/main/RunScript.scala
@@ -25,8 +25,8 @@ object RunScript{
                 path: Path,
                 interp: ammonite.interp.Interpreter,
                 scriptArgs: Seq[String],
-                lastEvaluator: Option[(Seq[(Path, Long)], Discovered.Mapping[_], Evaluator)])
-  : Res[(Discovered.Mapping[_], Evaluator, Seq[(Path, Long)], Boolean)] = {
+                lastEvaluator: Option[(Seq[(Path, Long)], Discovered.Mapping[_], Evaluator[_])])
+  : Res[(Discovered.Mapping[_], Evaluator[_], Seq[(Path, Long)], Boolean)] = {
 
     val log = new PrintLogger(true)
     for{
@@ -38,13 +38,12 @@ object RunScript{
         case _ =>
           interp.watch(path)
           for(mapping <- evaluateMapping(wd, path, interp))
-            yield (mapping, new Evaluator(pwd / 'out, mapping.value, log))
+            yield (mapping, new Evaluator(pwd / 'out, mapping, log))
       }
     } yield {
       val evaluationWatches = mutable.Buffer.empty[(Path, Long)]
       val res = evaluateTarget(
         evaluator,
-        mapping,
         scriptArgs,
         p => evaluationWatches.append((p, Interpreter.pathSignature(p)))
       )
@@ -95,8 +94,7 @@ object RunScript{
       _ <- Res(consistencyCheck(mapping))
     } yield mapping
   }
-  def evaluateTarget[T](evaluator: Evaluator,
-                        mapping: Discovered.Mapping[T],
+  def evaluateTarget[T](evaluator: Evaluator[_],
                         scriptArgs: Seq[String],
                         watch: Path => Unit) = {
 
@@ -107,11 +105,11 @@ object RunScript{
         case Mirror.Segment.Cross(x) => x.toList.map(_.toString)
         case _ => Nil
       }
-      target <- mill.main.Resolve.resolve(sel, mapping.mirror, mapping.base, rest, crossSelectors, Nil)
+      target <- mill.main.Resolve.resolve(sel, evaluator.mapping.mirror, evaluator.mapping.base, rest, crossSelectors, Nil)
       _ <- evaluate(evaluator, target, watch).toLeft(())
     } yield ()
   }
-  def evaluate(evaluator: Evaluator,
+  def evaluate(evaluator: Evaluator[_],
                target: Task[Any],
                watch: Path => Unit): Option[String] = {
     val evaluated = evaluator.evaluate(OSet(target))
diff --git a/core/src/main/scala/mill/util/Ctx.scala b/core/src/main/scala/mill/util/Ctx.scala
index 6549531f..ad9b32db 100644
--- a/core/src/main/scala/mill/util/Ctx.scala
+++ b/core/src/main/scala/mill/util/Ctx.scala
@@ -2,7 +2,7 @@ package mill.util
 
 import ammonite.ops.Path
 import mill.define.Applicative.ImplicitStub
-import mill.util.Ctx.{ArgCtx, DestCtx, LoaderCtx, LogCtx}
+import mill.util.Ctx.{ArgCtx, DestCtx, LoaderCtx, LogCtx, MappingCtx}
 
 import scala.annotation.compileTimeOnly
 import scala.language.implicitConversions
@@ -31,11 +31,20 @@ object Ctx{
   trait Loader[T]{
     def make(): T
   }
+  trait MappingCtx{
+    def mapping: mill.discover.Discovered.Mapping[_]
+  }
 }
 class Ctx(val args: IndexedSeq[_],
           val dest: Path,
           val log: Logger,
-          workerCtx0: Ctx.LoaderCtx) extends DestCtx with LogCtx with ArgCtx with LoaderCtx{
+          workerCtx0: Ctx.LoaderCtx,
+          val mapping: mill.discover.Discovered.Mapping[_])
+  extends DestCtx
+  with LogCtx
+  with ArgCtx
+  with LoaderCtx
+  with MappingCtx{
 
   def load[T](x: Ctx.Loader[T]): T = workerCtx0.load(x)
   def length = args.length
diff --git a/core/src/test/scala/mill/define/CacherTests.scala b/core/src/test/scala/mill/define/CacherTests.scala
index fe8e1b89..d85e9e6b 100644
--- a/core/src/test/scala/mill/define/CacherTests.scala
+++ b/core/src/test/scala/mill/define/CacherTests.scala
@@ -29,7 +29,7 @@ object CacherTests extends TestSuite{
 
     def eval[V](mapping: Discovered.Mapping[_], v: Task[V])(implicit tp: TestPath) = {
       val workspace = ammonite.ops.pwd / 'target / 'workspace / tp.value
-      val evaluator = new Evaluator(workspace, mapping.value, DummyLogger)
+      val evaluator = new Evaluator(workspace, mapping, DummyLogger)
       evaluator.evaluate(OSet(v)).values(0)
     }
 
diff --git a/core/src/test/scala/mill/eval/EvaluationTests.scala b/core/src/test/scala/mill/eval/EvaluationTests.scala
index 31a330d1..8b13987b 100644
--- a/core/src/test/scala/mill/eval/EvaluationTests.scala
+++ b/core/src/test/scala/mill/eval/EvaluationTests.scala
@@ -15,7 +15,7 @@ object EvaluationTests extends TestSuite{
     val workspace = ammonite.ops.pwd / 'target / 'workspace / tp.value
     ammonite.ops.rm(ammonite.ops.Path(workspace, ammonite.ops.pwd))
     // Make sure data is persisted even if we re-create the evaluator each time
-    def evaluator = new Evaluator(workspace, mapping.value, DummyLogger)
+    def evaluator = new Evaluator(workspace, mapping, DummyLogger)
 
     def apply(target: Task[_], expValue: Any,
               expEvaled: OSet[Task[_]],
diff --git a/core/src/test/scala/mill/eval/FailureTests.scala b/core/src/test/scala/mill/eval/FailureTests.scala
index 84b13af5..42331a74 100644
--- a/core/src/test/scala/mill/eval/FailureTests.scala
+++ b/core/src/test/scala/mill/eval/FailureTests.scala
@@ -14,7 +14,7 @@ object FailureTests extends TestSuite{
   }
   class Checker(mapping: Discovered.Mapping[_])(implicit tp: TestPath){
 
-    val evaluator = new Evaluator(workspace, mapping.value, DummyLogger)
+    val evaluator = new Evaluator(workspace, mapping, DummyLogger)
 
     def apply(target: Target[_], expectedFailCount: Int, expectedRawValues: Seq[Result[_]]) = {
 
diff --git a/core/src/test/scala/mill/eval/JavaCompileJarTests.scala b/core/src/test/scala/mill/eval/JavaCompileJarTests.scala
index 356ffea1..7587b3d9 100644
--- a/core/src/test/scala/mill/eval/JavaCompileJarTests.scala
+++ b/core/src/test/scala/mill/eval/JavaCompileJarTests.scala
@@ -51,7 +51,7 @@ object JavaCompileJarTests extends TestSuite{
       val mapping = Discovered.mapping(Build)
 
       def eval[T](t: Task[T]): Either[Result.Failing, (T, Int)] = {
-        val evaluator = new Evaluator(workspacePath, mapping.value, DummyLogger)
+        val evaluator = new Evaluator(workspacePath, mapping, DummyLogger)
         val evaluated = evaluator.evaluate(OSet(t))
 
         if (evaluated.failing.keyCount == 0){
@@ -68,7 +68,7 @@ object JavaCompileJarTests extends TestSuite{
 
       }
       def check(targets: OSet[Task[_]], expected: OSet[Task[_]]) = {
-        val evaluator = new Evaluator(workspacePath, mapping.value, DummyLogger)
+        val evaluator = new Evaluator(workspacePath, mapping, DummyLogger)
 
         val evaluated = evaluator.evaluate(targets)
           .evaluated