- Rename `basePath` -> `millSourcePath`

- Make `T.worker`s not flush out their directories between instantiations

6 files changed, 30 insertions, 24 deletions

diff --git a/core/src/mill/define/Cross.scala b/core/src/mill/define/Cross.scala
index b51064be..aa730e0d 100644
--- a/core/src/mill/define/Cross.scala
+++ b/core/src/mill/define/Cross.scala
@@ -61,7 +61,7 @@ class Cross[T](cases: Any*)
       c,
       ctx.copy(
         segments = ctx.segments ++ Seq(ctx.segment),
-        basePath = ctx.basePath / relPath,
+        millSourcePath = ctx.millSourcePath / relPath,
         segment = Segment.Cross(crossValues)
       )
     )
diff --git a/core/src/mill/define/Ctx.scala b/core/src/mill/define/Ctx.scala
index 6d685521..ddbdca96 100644
--- a/core/src/mill/define/Ctx.scala
+++ b/core/src/mill/define/Ctx.scala
@@ -45,7 +45,7 @@ case class Segments(value: Segment*){
 case class Ctx(enclosing: String,
                lineNum: Int,
                segment: Segment,
-               basePath: Path,
+               millSourcePath: Path,
                segments: Segments,
                overrides: Int){
 }
diff --git a/core/src/mill/define/Module.scala b/core/src/mill/define/Module.scala
index 11a98d95..039011d8 100644
--- a/core/src/mill/define/Module.scala
+++ b/core/src/mill/define/Module.scala
@@ -24,8 +24,8 @@ class Module(implicit outerCtx0: mill.define.Ctx) extends mill.moduledefs.Cacher
 
   lazy val millModuleDirectChildren = millInternal.reflectNestedObjects[Module]
   def millOuterCtx = outerCtx0
-  def basePath: Path = millOuterCtx.basePath / millOuterCtx.segment.pathSegments
-  implicit def millModuleBasePath: BasePath = BasePath(basePath)
+  def millSourcePath: Path = millOuterCtx.millSourcePath / millOuterCtx.segment.pathSegments
+  implicit def millModuleBasePath: BasePath = BasePath(millSourcePath)
   implicit def millModuleSegments: Segments = {
     millOuterCtx.segments ++ Seq(millOuterCtx.segment)
   }
@@ -92,19 +92,19 @@ trait TaskModule extends Module {
 object BaseModule{
   case class Implicit(value: BaseModule)
 }
-class BaseModule(basePath0: Path)
+class BaseModule(millSourcePath0: Path)
                 (implicit millModuleEnclosing0: sourcecode.Enclosing,
                  millModuleLine0: sourcecode.Line,
                  millName0: sourcecode.Name)
   extends Module()(
-    mill.define.Ctx.make(implicitly, implicitly, implicitly, BasePath(basePath0), Segments(), Overrides(0))
+    mill.define.Ctx.make(implicitly, implicitly, implicitly, BasePath(millSourcePath0), Segments(), Overrides(0))
   ){
   // A BaseModule should provide an empty Segments list to it's children, since
   // it is the root of the module tree, and thus must not include it's own
   // sourcecode.Name as part of the list,
   override implicit def millModuleSegments: Segments = Segments()
-  override def basePath = millOuterCtx.basePath
-  override implicit def millModuleBasePath: BasePath = BasePath(basePath)
+  override def millSourcePath = millOuterCtx.millSourcePath
+  override implicit def millModuleBasePath: BasePath = BasePath(millSourcePath)
   implicit def millImplicitBaseModule: BaseModule.Implicit = BaseModule.Implicit(this)
 }
 
diff --git a/core/src/mill/define/Task.scala b/core/src/mill/define/Task.scala
index f74171ec..a94d9703 100644
--- a/core/src/mill/define/Task.scala
+++ b/core/src/mill/define/Task.scala
@@ -289,7 +289,7 @@ class Command[+T](t: Task[T],
 }
 
 class Worker[+T](t: Task[T], ctx0: mill.define.Ctx) extends NamedTaskImpl[T](ctx0, t) {
-
+  override def flushDest = false
   override def asWorker = Some(this)
 }
 class Persistent[+T](t: Task[T],
diff --git a/core/src/mill/eval/Evaluator.scala b/core/src/mill/eval/Evaluator.scala
index 31b59865..21e3d3a9 100644
--- a/core/src/mill/eval/Evaluator.scala
+++ b/core/src/mill/eval/Evaluator.scala
@@ -12,21 +12,21 @@ import mill.util.Strict.Agg
 
 import scala.collection.mutable
 import scala.util.control.NonFatal
-case class Labelled[T](target: NamedTask[T],
+case class Labelled[T](task: NamedTask[T],
                        segments: Segments){
-  def format = target match{
+  def format = task match{
     case t: Target[T] => Some(t.readWrite.asInstanceOf[upickle.default.ReadWriter[T]])
     case _ => None
   }
-  def writer = target match{
+  def writer = task match{
     case t: mill.define.Command[T] => Some(t.writer.asInstanceOf[upickle.default.Writer[T]])
     case t: Target[T] => Some(t.readWrite.asInstanceOf[upickle.default.ReadWriter[T]])
     case _ => None
   }
 }
-class Evaluator[T](val workspacePath: Path,
-                   val basePath: Path,
-                   val externalBasePath: Path,
+class Evaluator[T](val outPath: Path,
+                   val millSourcePath: Path,
+                   val externalOutPath: Path,
                    val rootModule: mill.Module,
                    val discover: Discover[T],
                    log: Logger,
@@ -35,7 +35,7 @@ class Evaluator[T](val workspacePath: Path,
 
   val workerCache = mutable.Map.empty[Segments, (Int, Any)]
   def evaluate(goals: Agg[Task[_]]): Evaluator.Results = {
-    mkdir(workspacePath)
+    mkdir(outPath)
 
     val transitive = Graph.transitiveTargets(goals)
     val topoSorted = Graph.topoSorted(transitive)
@@ -125,8 +125,13 @@ class Evaluator[T](val workspacePath: Path,
           counterMsg = counterMsg
         )
       case Right(labelledNamedTask) =>
-        val paths = Evaluator.resolveDestPaths(workspacePath, labelledNamedTask.segments)
-        val groupBasePath = basePath / Evaluator.makeSegmentStrings(labelledNamedTask.segments)
+
+        val paths = if (labelledNamedTask.task.asTarget.exists(rootModule.millInternal.targets.contains)){
+          Evaluator.resolveDestPaths(outPath, labelledNamedTask.segments)
+        }else{
+          Evaluator.resolveDestPaths(externalOutPath, labelledNamedTask.segments)
+        }
+        val groupBasePath = millSourcePath / Evaluator.makeSegmentStrings(labelledNamedTask.segments)
         mkdir(paths.out)
         val cached = for{
           json <- scala.util.Try(upickle.json.read(read(paths.meta))).toOption
@@ -136,14 +141,14 @@ class Evaluator[T](val workspacePath: Path,
           parsed <- reader.read.lift(terminalResult)
         } yield parsed
 
-        val workerCached = labelledNamedTask.target.asWorker
+        val workerCached = labelledNamedTask.task.asWorker
           .flatMap{w => workerCache.get(w.ctx.segments)}
           .collect{case (`inputsHash`, v) => v}
 
         workerCached.map((_, inputsHash)) orElse cached.map(p => (p, p.hashCode())) match{
           case Some((v, hashCode)) =>
             val newResults = mutable.LinkedHashMap.empty[Task[_], Result[(Any, Int)]]
-            newResults(labelledNamedTask.target) = Result.Success((v, hashCode))
+            newResults(labelledNamedTask.task) = Result.Success((v, hashCode))
 
             (newResults, Nil)
 
@@ -155,7 +160,8 @@ class Evaluator[T](val workspacePath: Path,
               case Segment.Cross(s) => "[" + s.mkString(",") + "]"
             }
 
-            if (labelledNamedTask.target.flushDest) rm(paths.dest)
+            if (labelledNamedTask.task.flushDest) rm(paths.dest)
+
             val (newResults, newEvaluated) = evaluateGroup(
               group,
               results,
@@ -166,9 +172,9 @@ class Evaluator[T](val workspacePath: Path,
               counterMsg = counterMsg
             )
 
-            newResults(labelledNamedTask.target) match{
+            newResults(labelledNamedTask.task) match{
               case Result.Success((v, hashCode)) =>
-                labelledNamedTask.target.asWorker match{
+                labelledNamedTask.task.asWorker match{
                   case Some(w) =>
                     workerCache(w.ctx.segments) = (inputsHash, v)
                   case None =>
diff --git a/core/src/mill/main/RunScript.scala b/core/src/mill/main/RunScript.scala
index f09acf66..dfe49c57 100644
--- a/core/src/mill/main/RunScript.scala
+++ b/core/src/mill/main/RunScript.scala
@@ -185,7 +185,7 @@ object RunScript{
           t match {
             case t: mill.define.NamedTask[_] =>
               val jsonFile = Evaluator
-                .resolveDestPaths(evaluator.workspacePath, t.ctx.segments)
+                .resolveDestPaths(evaluator.outPath, t.ctx.segments)
                 .meta
               val metadata = upickle.json.read(jsonFile.toIO)
               Some(metadata(1))