WIP getting rid of `discover/` phase: `core/test:compile` works, but some things still stubbed out with `???`

27 files changed, 261 insertions, 773 deletions

diff --git a/build.sc b/build.sc
index eaca879d..e780aad6 100755
--- a/build.sc
+++ b/build.sc
@@ -30,7 +30,7 @@ trait MillModule extends SbtModule{ outer =>
   def testArgs = T{ Seq.empty[String] }
 
   val test = new Tests(implicitly)
-  class Tests(ctx0: mill.Module.Ctx) extends mill.Module()(ctx0) with super.Tests{
+  class Tests(ctx0: mill.mill.define.Ctx) extends mill.Module()(ctx0) with super.Tests{
     def defaultCommandName() = "forkTest"
     def forkArgs = T{ testArgs() }
     def projectDeps =
@@ -65,7 +65,7 @@ object core extends MillModule {
   }
 
   val test = new Tests(implicitly)
-  class Tests(ctx0: mill.Module.Ctx) extends super.Tests(ctx0){
+  class Tests(ctx0: mill.mill.define.Ctx) extends super.Tests(ctx0){
     def generatedSources = T {
       mkdir(T.ctx().dest)
       shared.generateCoreTestSources(T.ctx().dest)
diff --git a/core/src/main/scala/mill/define/Cross.scala b/core/src/main/scala/mill/define/Cross.scala
index 8e27c714..b40dc844 100644
--- a/core/src/main/scala/mill/define/Cross.scala
+++ b/core/src/main/scala/mill/define/Cross.scala
@@ -4,7 +4,7 @@ import scala.reflect.macros.blackbox
 
 
 object Cross{
-  case class Factory[T](make: (Product, Module.Ctx) => T)
+  case class Factory[T](make: (Product, mill.define.Ctx) => T)
 
   object Factory{
     implicit def make[T]: Factory[T] = macro makeImpl[T]
@@ -19,7 +19,7 @@ object Cross{
         for((a, n) <- primaryConstructorArgs.zipWithIndex)
         yield q"v.productElement($n).asInstanceOf[${a.info}]"
 
-      val instance = c.Expr[(Product, Module.Ctx) => T](
+      val instance = c.Expr[(Product, mill.define.Ctx) => T](
         q"{ (v, ctx0) => new $tpe(..$argTupleValues){  override def ctx = ctx0 } }"
       )
 
@@ -44,7 +44,14 @@ object Cross{
   */
 class Cross[T](cases: Any*)
               (implicit ci: Cross.Factory[T],
-               ctx: Module.Ctx) extends mill.define.Module()(ctx) {
+               ctx: mill.define.Ctx) extends mill.define.Module()(ctx) {
+
+  override def traverse[T](f: (Module, Segments) => Seq[T]): Seq[T] = {
+    ???
+//    f(this) ++
+//    this.reflect[mill.Module].flatMap(f) ++
+//    items.map(_._2).flatMap{case t: mill.Module => f(t)}
+  }
 
   val items = for(c0 <- cases.toList) yield{
     val c = c0 match{
diff --git a/core/src/main/scala/mill/define/Ctx.scala b/core/src/main/scala/mill/define/Ctx.scala
new file mode 100644
index 00000000..fc8bf85a
--- /dev/null
+++ b/core/src/main/scala/mill/define/Ctx.scala
@@ -0,0 +1,62 @@
+package mill.define
+
+import ammonite.main.Router.Overrides
+import ammonite.ops.Path
+
+import scala.annotation.implicitNotFound
+
+sealed trait Segment
+object Segment{
+  case class Label(value: String) extends Segment
+  case class Cross(value: Seq[Any]) extends Segment
+}
+
+case class BasePath(value: Path)
+
+
+/**
+  * Models a path with the Mill build hierarchy, e.g.
+  *
+  * amm.util[2.11].test.compile
+  *
+  * .-separated segments are [[Segment.Label]]s, while []-delimited
+  * segments are [[Segment.Cross]]s
+  */
+case class Segments(value: Segment*){
+  def ++(other: Seq[Segment]): Segments = Segments(value ++ other:_*)
+  def ++(other: Segments): Segments = Segments(value ++ other.value:_*)
+  def render = value match {
+    case Nil => ""
+    case Segment.Label(head) :: rest =>
+      val stringSegments = rest.map{
+        case Segment.Label(s) => "." + s
+        case Segment.Cross(vs) => "[" + vs.mkString(",") + "]"
+      }
+      head + stringSegments.mkString
+  }
+}
+
+@implicitNotFound("Modules, Targets and Commands can only be defined within a mill Module")
+case class Ctx(enclosing: String,
+               lineNum: Int,
+               segment: Segment,
+               basePath: Path,
+               segments0: Segments,
+               overrides: Int){
+  def segments = Segments(segments0.value.drop(1):_*)
+}
+object Ctx{
+  implicit def make(implicit millModuleEnclosing0: sourcecode.Enclosing,
+                    millModuleLine0: sourcecode.Line,
+                    millName0: sourcecode.Name,
+                    millModuleBasePath0: BasePath,
+                    segments0: Segments,
+                    overrides0: Overrides): Ctx = Ctx(
+    millModuleEnclosing0.value,
+    millModuleLine0.value,
+    Segment.Label(millName0.value),
+    millModuleBasePath0.value,
+    segments0,
+    overrides0.value
+  )
+}
\ No newline at end of file
diff --git a/core/src/main/scala/mill/define/Module.scala b/core/src/main/scala/mill/define/Module.scala
index 5eee6ddf..f4a332a2 100644
--- a/core/src/main/scala/mill/define/Module.scala
+++ b/core/src/main/scala/mill/define/Module.scala
@@ -2,48 +2,38 @@ package mill.define
 
 import java.lang.reflect.Modifier
 
-import ammonite.main.Router.Overrides
+import ammonite.main.Router.{EntryPoint, Overrides}
 import ammonite.ops.Path
 
 import scala.annotation.implicitNotFound
 import scala.reflect.ClassTag
 
-sealed trait Segment
-object Segment{
-  case class Label(value: String) extends Segment
-  case class Cross(value: Seq[Any]) extends Segment
-}
-
-case class BasePath(value: Path)
-
-/**
-  * Models a path with the Mill build hierarchy, e.g.
-  *
-  * amm.util[2.11].test.compile
-  *
-  * .-separated segments are [[Segment.Label]]s, while []-delimited
-  * segments are [[Segment.Cross]]s
-  */
-case class Segments(value: Segment*){
-  def ++(other: Seq[Segment]): Segments = Segments(value ++ other:_*)
-  def ++(other: Segments): Segments = Segments(value ++ other.value:_*)
-  def render = value match {
-    case Nil => ""
-    case Segment.Label(head) :: rest =>
-      val stringSegments = rest.map{
-        case Segment.Label(s) => "." + s
-        case Segment.Cross(vs) => "[" + vs.mkString(",") + "]"
-      }
-      head + stringSegments.mkString
-  }
-}
 /**
   * `Module` is a class meant to be extended by `trait`s *only*, in order to
   * propagate the implicit parameters forward to the final concrete
   * instantiation site so they can capture the enclosing/line information of
   * the concrete instance.
   */
-class Module(implicit ctx0: Module.Ctx) extends mill.moduledefs.Cacher{
+class Module(implicit ctx0: mill.define.Ctx) extends mill.moduledefs.Cacher{
+  def commands: Seq[EntryPoint[Module]] = ???
+
+  def traverse[T](f: (Module, Segments) => Seq[T]): Seq[T] = {
+    ???
+  }
+
+  lazy val segmentsToModules = traverse{(m, s) => Seq(s -> m)}
+    .toMap
+
+  lazy val modules = segmentsToModules.valuesIterator.toSet
+  lazy val segmentsToTargets = traverse{(m, s) => m.reflect[Target[_]]}
+    .map(t => (t.ctx.segments, t))
+    .toMap
+
+  lazy val targets = segmentsToTargets.valuesIterator.toSet
+  lazy val segmentsToCommands = traverse{
+    (m, s) => m.commands.map(e => s ++ Seq(Segment.Label(e.name)) -> e)
+  }.toMap
+
   def ctx = ctx0
   // Ensure we do not propagate the implicit parameters as implicits within
   // the body of any inheriting class/trait/objects, as it would screw up any
@@ -68,37 +58,15 @@ class Module(implicit ctx0: Module.Ctx) extends mill.moduledefs.Cacher{
       .map(_.invoke(this).asInstanceOf[T])
   }
 }
-object Module{
-  @implicitNotFound("Modules, Targets and Commands can only be defined within a mill Module")
-  case class Ctx(enclosing: String,
-                 lineNum: Int,
-                 segment: Segment,
-                 basePath: Path,
-                 segments0: Segments,
-                 overrides: Int){
-    def segments = Segments(segments0.value.drop(1):_*)
-  }
-  object Ctx{
-    implicit def make(implicit millModuleEnclosing0: sourcecode.Enclosing,
-                      millModuleLine0: sourcecode.Line,
-                      millName0: sourcecode.Name,
-                      millModuleBasePath0: BasePath,
-                      segments0: Segments,
-                      overrides0: Overrides): Ctx = Ctx(
-      millModuleEnclosing0.value,
-      millModuleLine0.value,
-      Segment.Label(millName0.value),
-      millModuleBasePath0.value,
-      segments0,
-      overrides0.value
-    )
-  }
+trait TaskModule extends Module {
+  def defaultCommandName(): String
 }
+
 class BaseModule(basePath: Path)
                 (implicit millModuleEnclosing0: sourcecode.Enclosing,
                  millModuleLine0: sourcecode.Line,
                  millName0: sourcecode.Name,
                  overrides0: Overrides)
   extends Module()(
-    Module.Ctx.make(implicitly, implicitly, implicitly, BasePath(basePath), Segments(), implicitly)
+    mill.define.Ctx.make(implicitly, implicitly, implicitly, BasePath(basePath), Segments(), implicitly)
   )
\ No newline at end of file
diff --git a/core/src/main/scala/mill/define/Task.scala b/core/src/main/scala/mill/define/Task.scala
index 2a670d21..c0892743 100644
--- a/core/src/main/scala/mill/define/Task.scala
+++ b/core/src/main/scala/mill/define/Task.scala
@@ -2,7 +2,7 @@ package mill.define
 
 import mill.define.Applicative.Applyable
 import mill.eval.{PathRef, Result}
-import mill.util.Ctx
+
 import upickle.default.{ReadWriter => RW, Reader => R, Writer => W}
 
 import scala.language.experimental.macros
@@ -24,7 +24,7 @@ abstract class Task[+T] extends Task.Ops[T] with Applyable[Task, T]{
   /**
     * Evaluate this target
     */
-  def evaluate(args: Ctx): Result[T]
+  def evaluate(args: mill.util.Ctx): Result[T]
 
   /**
     * Even if this target's inputs did not change, does it need to re-evaluate
@@ -41,7 +41,7 @@ abstract class Task[+T] extends Task.Ops[T] with Applyable[Task, T]{
 }
 
 trait NamedTask[+T] extends Task[T]{
-  def ctx: Module.Ctx
+  def ctx: mill.define.Ctx
   def label = ctx.segment match{case Segment.Label(v) => v}
 }
 trait Target[+T] extends NamedTask[T]{
@@ -49,20 +49,20 @@ trait Target[+T] extends NamedTask[T]{
   def readWrite: RW[_]
 }
 
-object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Result, Ctx] {
+object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Result, mill.util.Ctx] {
 
   implicit def apply[T](t: T)
                        (implicit r: R[T],
                         w: W[T],
-                        ctx: Module.Ctx): Target[T] = macro targetImpl[T]
+                        ctx: mill.define.Ctx): Target[T] = macro targetImpl[T]
 
   def targetImpl[T: c.WeakTypeTag](c: Context)
                                   (t: c.Expr[T])
                                   (r: c.Expr[R[T]],
                                    w: c.Expr[W[T]],
-                                   ctx: c.Expr[Module.Ctx]): c.Expr[Target[T]] = {
+                                   ctx: c.Expr[mill.define.Ctx]): c.Expr[Target[T]] = {
     import c.universe._
-    val lhs = Applicative.impl0[Task, T, Ctx](c)(reify(Result.Success(t.splice)).tree)
+    val lhs = Applicative.impl0[Task, T, mill.util.Ctx](c)(reify(Result.Success(t.splice)).tree)
 
     mill.moduledefs.Cacher.impl0[TargetImpl[T]](c)(
       reify(
@@ -74,18 +74,18 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
   implicit def apply[T](t: Result[T])
                        (implicit r: R[T],
                         w: W[T],
-                        ctx: Module.Ctx): Target[T] = macro targetResultImpl[T]
+                        ctx: mill.define.Ctx): Target[T] = macro targetResultImpl[T]
 
   def targetResultImpl[T: c.WeakTypeTag](c: Context)
                                         (t: c.Expr[Result[T]])
                                         (r: c.Expr[R[T]],
                                          w: c.Expr[W[T]],
-                                         ctx: c.Expr[Module.Ctx]): c.Expr[Target[T]] = {
+                                         ctx: c.Expr[mill.define.Ctx]): c.Expr[Target[T]] = {
     import c.universe._
     mill.moduledefs.Cacher.impl0[Target[T]](c)(
       reify(
         new TargetImpl[T](
-          Applicative.impl0[Task, T, Ctx](c)(t.tree).splice,
+          Applicative.impl0[Task, T, mill.util.Ctx](c)(t.tree).splice,
           ctx.splice,
           RW(w.splice.write, r.splice.read)
         )
@@ -96,13 +96,13 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
   def apply[T](t: Task[T])
               (implicit r: R[T],
                w: W[T],
-               ctx: Module.Ctx): Target[T] = macro targetTaskImpl[T]
+               ctx: mill.define.Ctx): Target[T] = macro targetTaskImpl[T]
 
   def targetTaskImpl[T: c.WeakTypeTag](c: Context)
                                       (t: c.Expr[Task[T]])
                                       (r: c.Expr[R[T]],
                                        w: c.Expr[W[T]],
-                                       ctx: c.Expr[Module.Ctx]): c.Expr[Target[T]] = {
+                                       ctx: c.Expr[mill.define.Ctx]): c.Expr[Target[T]] = {
     import c.universe._
     mill.moduledefs.Cacher.impl0[Target[T]](c)(
       reify(
@@ -114,13 +114,13 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
   def source(value: Result[ammonite.ops.Path])
             (implicit r: R[PathRef],
              w: W[PathRef],
-             ctx: Module.Ctx): Input[PathRef] = macro sourceImpl
+             ctx: mill.define.Ctx): Input[PathRef] = macro sourceImpl
 
   def sourceImpl(c: Context)
                 (value: c.Expr[Result[ammonite.ops.Path]])
                 (r: c.Expr[R[PathRef]],
                  w: c.Expr[W[PathRef]],
-                 ctx: c.Expr[Module.Ctx]): c.Expr[Input[PathRef]] = {
+                 ctx: c.Expr[mill.define.Ctx]): c.Expr[Input[PathRef]] = {
     import c.universe._
     val wrapped: c.Expr[Result[PathRef]] = reify(value.splice match{
       case Result.Success(p) => Result.Success(PathRef(p))
@@ -129,7 +129,7 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
     mill.moduledefs.Cacher.impl0[Input[PathRef]](c)(
       reify(
         new Input[PathRef](
-          Applicative.impl0[Task, PathRef, Ctx](c)(wrapped.tree).splice,
+          Applicative.impl0[Task, PathRef, mill.util.Ctx](c)(wrapped.tree).splice,
           ctx.splice,
           RW(w.splice.write, r.splice.read),
         )
@@ -140,19 +140,19 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
   def input[T](value: Result[T])
               (implicit r: R[T],
                 w: W[T],
-                ctx: Module.Ctx): Input[T] = macro inputImpl[T]
+                ctx: mill.define.Ctx): Input[T] = macro inputImpl[T]
 
   def inputImpl[T: c.WeakTypeTag](c: Context)
                                   (value: c.Expr[T])
                                   (r: c.Expr[R[T]],
                                    w: c.Expr[W[T]],
-                                   ctx: c.Expr[Module.Ctx]): c.Expr[Input[T]] = {
+                                   ctx: c.Expr[mill.define.Ctx]): c.Expr[Input[T]] = {
     import c.universe._
 
     mill.moduledefs.Cacher.impl0[Input[T]](c)(
       reify(
         new Input[T](
-          Applicative.impl[Task, T, Ctx](c)(value).splice,
+          Applicative.impl[Task, T, mill.util.Ctx](c)(value).splice,
           ctx.splice,
           RW(w.splice.write, r.splice.read)
         )
@@ -161,41 +161,41 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
   }
 
   def command[T](t: Task[T])
-                (implicit ctx: Module.Ctx,
+                (implicit ctx: mill.define.Ctx,
                  w: W[T]): Command[T] = new Command(t, ctx, w)
 
   def command[T](t: Result[T])
                 (implicit w: W[T],
-                 ctx: Module.Ctx): Command[T] = macro commandImpl[T]
+                 ctx: mill.define.Ctx): Command[T] = macro commandImpl[T]
 
   def commandImpl[T: c.WeakTypeTag](c: Context)
                                    (t: c.Expr[T])
                                    (w: c.Expr[W[T]],
-                                    ctx: c.Expr[Module.Ctx]): c.Expr[Command[T]] = {
+                                    ctx: c.Expr[mill.define.Ctx]): c.Expr[Command[T]] = {
     import c.universe._
     reify(
-      new Command[T](Applicative.impl[Task, T, Ctx](c)(t).splice, ctx.splice, w.splice)
+      new Command[T](Applicative.impl[Task, T, mill.util.Ctx](c)(t).splice, ctx.splice, w.splice)
     )
   }
 
-  def task[T](t: Result[T]): Task[T] = macro Applicative.impl[Task, T, Ctx]
+  def task[T](t: Result[T]): Task[T] = macro Applicative.impl[Task, T, mill.util.Ctx]
 
   def persistent[T](t: Result[T])(implicit r: R[T],
                                   w: W[T],
-                                  ctx: Module.Ctx): Target[T] = macro persistentImpl[T]
+                                  ctx: mill.define.Ctx): Target[T] = macro persistentImpl[T]
 
   def persistentImpl[T: c.WeakTypeTag](c: Context)
                                       (t: c.Expr[T])
                                       (r: c.Expr[R[T]],
                                        w: c.Expr[W[T]],
-                                       ctx: c.Expr[Module.Ctx]): c.Expr[Persistent[T]] = {
+                                       ctx: c.Expr[mill.define.Ctx]): c.Expr[Persistent[T]] = {
     import c.universe._
 
 
     mill.moduledefs.Cacher.impl0[Persistent[T]](c)(
       reify(
         new Persistent[T](
-          Applicative.impl[Task, T, Ctx](c)(t).splice,
+          Applicative.impl[Task, T, mill.util.Ctx](c)(t).splice,
           ctx.splice,
           RW(w.splice.write, r.splice.read)
         )
@@ -204,13 +204,13 @@ object Target extends TargetGenerated with Applicative.Applyer[Task, Task, Resul
   }
 
   type TT[+X] = Task[X]
-  def makeT[X](inputs0: Seq[TT[_]], evaluate0: Ctx => Result[X]) = new Task[X] {
+  def makeT[X](inputs0: Seq[TT[_]], evaluate0: mill.util.Ctx => Result[X]) = new Task[X] {
     val inputs = inputs0
-    def evaluate(x: Ctx) = evaluate0(x)
+    def evaluate(x: mill.util.Ctx) = evaluate0(x)
   }
 
   def underlying[A](v: Task[A]) = v
-  def mapCtx[A, B](t: Task[A])(f: (A, Ctx) => Result[B]) = t.mapDest(f)
+  def mapCtx[A, B](t: Task[A])(f: (A, mill.util.Ctx) => Result[B]) = t.mapDest(f)
   def zip() =  new Task.Task0(())
   def zip[A](a: Task[A]) = a.map(Tuple1(_))
   def zip[A, B](a: Task[A], b: Task[B]) = a.zip(b)
@@ -227,23 +227,23 @@ object Caller {
 }
 
 class TargetImpl[+T](t: Task[T],
-                     ctx0: Module.Ctx,
+                     ctx0: mill.define.Ctx,
                      val readWrite: RW[_]) extends Target[T] {
   val ctx = ctx0.copy(segments0 = ctx0.segments0 ++ Seq(ctx0.segment))
   val inputs = Seq(t)
-  def evaluate(args: Ctx) = args[T](0)
+  def evaluate(args: mill.util.Ctx) = args[T](0)
   override def toString = ctx.enclosing + "@" + Integer.toHexString(System.identityHashCode(this))
 }
 class Command[+T](t: Task[T],
-                  ctx0: Module.Ctx,
+                  ctx0: mill.define.Ctx,
                   val writer: W[_]) extends NamedTask[T] {
   val ctx = ctx0.copy(segments0 = ctx0.segments0 ++ Seq(ctx0.segment))
   val inputs = Seq(t)
-  def evaluate(args: Ctx) = args[T](0)
+  def evaluate(args: mill.util.Ctx) = args[T](0)
   override def asCommand = Some(this)
 }
 class Persistent[+T](t: Task[T],
-                     ctx0: Module.Ctx,
+                     ctx0: mill.define.Ctx,
                      readWrite: RW[_])
   extends TargetImpl[T](t, ctx0, readWrite) {
 
@@ -251,30 +251,28 @@ class Persistent[+T](t: Task[T],
   override def asPersistent = Some(this)
 }
 class Input[T](t: Task[T],
-               ctx0: Module.Ctx,
+               ctx0: mill.define.Ctx,
                val readWrite: RW[_]) extends Target[T]{
   val ctx = ctx0.copy(segments0 = ctx0.segments0 ++ Seq(ctx0.segment))
   val inputs = Seq(t)
-  def evaluate(args: Ctx) = args[T](0)
+  def evaluate(args: mill.util.Ctx) = args[T](0)
   override def sideHash = util.Random.nextInt()
 }
 
 object Task {
 
-  trait TaskModule extends Module {
-    def defaultCommandName(): String
-  }
+
 
 
   class Task0[T](t: T) extends Task[T]{
     lazy val t0 = t
     val inputs = Nil
-    def evaluate(args: Ctx)  = t0
+    def evaluate(args: mill.util.Ctx)  = t0
   }
 
   abstract class Ops[+T]{ this: Task[T] =>
     def map[V](f: T => V) = new Task.Mapped(this, f)
-    def mapDest[V](f: (T, Ctx) => Result[V]) = new Task.MappedDest(this, f)
+    def mapDest[V](f: (T, mill.util.Ctx) => Result[V]) = new Task.MappedDest(this, f)
 
     def filter(f: T => Boolean) = this
     def withFilter(f: T => Boolean) = this
@@ -289,22 +287,22 @@ object Task {
 
   class Sequence[+T](inputs0: Seq[Task[T]]) extends Task[Seq[T]]{
     val inputs = inputs0
-    def evaluate(args: Ctx) = {
+    def evaluate(args: mill.util.Ctx) = {
       for (i <- 0 until args.length)
       yield args(i).asInstanceOf[T]
     }
 
   }
   class Mapped[+T, +V](source: Task[T], f: T => V) extends Task[V]{
-    def evaluate(args: Ctx) = f(args(0))
+    def evaluate(args: mill.util.Ctx) = f(args(0))
     val inputs = List(source)
   }
-  class MappedDest[+T, +V](source: Task[T], f: (T, Ctx) => Result[V]) extends Task[V]{
-    def evaluate(args: Ctx) = f(args(0), args)
+  class MappedDest[+T, +V](source: Task[T], f: (T, mill.util.Ctx) => Result[V]) extends Task[V]{
+    def evaluate(args: mill.util.Ctx) = f(args(0), args)
     val inputs = List(source)
   }
   class Zipped[+T, +V](source1: Task[T], source2: Task[V]) extends Task[(T, V)]{
-    def evaluate(args: Ctx) = (args(0), args(1))
+    def evaluate(args: mill.util.Ctx) = (args(0), args(1))
     val inputs = List(source1, source2)
   }
 }
diff --git a/core/src/main/scala/mill/define/Worker.scala b/core/src/main/scala/mill/define/Worker.scala
index 0a6d31d2..3d35d2e0 100644
--- a/core/src/main/scala/mill/define/Worker.scala
+++ b/core/src/main/scala/mill/define/Worker.scala
@@ -1,6 +1,5 @@
 package mill.define
 
-import mill.util.Ctx
 
 /**
   * Worker serves three purposes:
@@ -25,9 +24,9 @@ import mill.util.Ctx
   * evaluating the task graph. The Worker defines how it is evaluated, but it's
   * evaluation/caching/lifecycle are controlled by the `Evaluator`
   */
-trait Worker[V] extends Task[V] with Ctx.Loader[V]{
+trait Worker[V] extends Task[V] with mill.util.Ctx.Loader[V]{
   val inputs = Nil
   def make(): V
-  def evaluate(args: Ctx) = args.load(this)
+  def evaluate(args: mill.util.Ctx) = args.load(this)
   def path = this.getClass.getCanonicalName.filter(_ != '$').split('.')
-}
\ No newline at end of file
+}
diff --git a/core/src/main/scala/mill/discover/Discovered.scala b/core/src/main/scala/mill/discover/Discovered.scala
deleted file mode 100644
index 6296645a..00000000
--- a/core/src/main/scala/mill/discover/Discovered.scala
+++ /dev/null
@@ -1,120 +0,0 @@
-package mill.discover
-
-import mill.define._
-import ammonite.main.Router
-import ammonite.main.Router.EntryPoint
-import mill.util.Ctx.Loader
-import mill.util.Strict.Agg
-
-import scala.language.experimental.macros
-import scala.reflect.macros.blackbox.Context
-
-/**
-  * Allows you to implicitly summon up a build [[Mirror]] for arbitrary types
-  */
-class Discovered[T](val mirror: Mirror[T, T]){
-  def mapping(t: T) = Discovered.Mapping(mirror, t)
-}
-
-object Discovered {
-  object Mapping extends Loader[Mapping[_]] {
-    // Magically injected by the `Evaluator`, rather than being constructed here
-    def make() = ???
-  }
-  case class Mapping[T](mirror: Mirror[T, T],
-                        base: T){
-    val modulesToMirrors = Mirror.traverseNode[T, T, (Any, Mirror[_, _])](base, mirror){
-      (mirror, segments, resolvedNode) => Seq(resolvedNode -> mirror)
-    }.toMap
-
-    val targets = Agg.from(
-      Mirror.traverseNode(base, mirror){ (mirror, segmentsRev, resolvedNode) =>
-        resolvedNode.asInstanceOf[mill.Module].reflect[Target[_]]
-      }
-    )
-
-    val segmentsToCommands = Mirror.traverse[T, T, (Segments, EntryPoint[_])](base, mirror){ (mirror, segments) =>
-      for(command <- mirror.commands)
-      yield segments ++ Seq(Segment.Label(command.name)) -> command
-    }.toMap
-
-    val segmentsToTargets = targets.map(t => (t.ctx.segments, t)).toMap
-    val targetsToSegments = segmentsToTargets.map(_.swap)
-  }
-
-  def consistencyCheck[T](mapping: Discovered.Mapping[T]): Agg[Segments] = {
-    val mapping2 = Discovered.Mapping(mapping.mirror, mapping.base)
-    for{
-      (t1, t2) <- mapping2.targets.zip(mapping.targets)
-      if t1 ne t2
-    } yield t1.ctx.segments
-  }
-
-
-  def make[T]: Discovered[T] = macro applyImpl[T]
-  def mapping[T](t: T): Discovered.Mapping[T] = macro mappingImpl[T]
-  def tupleLeft[T, V](items: List[(T, V)]) = items.map(_._1)
-  def mappingImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Discovered.Mapping[T]] = {
-    import c.universe._
-    c.Expr[Discovered.Mapping[T]](q"${applyImpl[T](c)}.mapping($t)")
-  }
-  def applyImpl[T: c.WeakTypeTag](c: Context): c.Expr[Discovered[T]] = {
-
-    import c.universe._
-    val baseType = c.weakTypeTag[T].tpe
-    def rec(segments: List[Option[String]],
-            t: c.Type): Tree = {
-
-      val r = new Router(c)
-
-      val crossChildren =
-        if (!(t <:< c.weakTypeOf[Cross[_]])) q"None"
-        else {
-
-          val TypeRef(_, _, Seq(arg)) = t.baseType(weakTypeOf[Cross[_]].typeSymbol)
-          val innerMirror = rec(None :: segments, arg)
-          q"Some(((c: mill.define.Cross[_]) => mill.discover.Discovered.tupleLeft(c.items), $innerMirror))"
-        }
-      val childHierarchies = for{
-        m <- t.members.toList
-        if m.typeSignature.paramLists.isEmpty && m.isPublic
-        if (m.typeSignature.finalResultType <:< c.weakTypeOf[Module]) ||
-          (m.typeSignature.finalResultType <:< c.weakTypeOf[Cross[_]])
-
-      } yield {
-        val name = m.name.toString.trim
-        q"($name, ${rec(Some(name) :: segments, m.typeSignature.finalResultType)})"
-      }
-
-
-      val crossName = q"${TermName(c.freshName())}"
-      val hierarchySelector = {
-        val base = q"${TermName(c.freshName())}"
-        val ident = segments.reverse.zipWithIndex.foldLeft[Tree](base) {
-          case (prefix, (Some(name), i)) => q"$prefix.${TermName(name)}"
-          case (prefix, (None, i)) => q"$prefix.get($crossName($i))"
-        }
-        q"($base: $baseType, $crossName: List[List[Any]]) => $ident.asInstanceOf[$t]"
-      }
-
-      val commands =
-        r.getAllRoutesForClass(
-            t.asInstanceOf[r.c.Type],
-            _.returnType <:< weakTypeOf[mill.define.Command[_]].asInstanceOf[r.c.Type]
-          )
-          .asInstanceOf[Seq[c.Tree]]
-          .toList
-
-      q"""mill.discover.Mirror[$baseType, $t](
-        $hierarchySelector,
-        $commands,
-        $childHierarchies,
-        $crossChildren
-      )"""
-    }
-
-    val res = q"new _root_.mill.discover.Discovered(${rec(Nil, baseType)})"
-//    println(res)
-    c.Expr[Discovered[T]](res)
-  }
-}
diff --git a/core/src/main/scala/mill/discover/Mirror.scala b/core/src/main/scala/mill/discover/Mirror.scala
deleted file mode 100644
index ffa86225..00000000
--- a/core/src/main/scala/mill/discover/Mirror.scala
+++ /dev/null
@@ -1,49 +0,0 @@
-package mill.discover
-
-import mill.define.{Segment, Segments, Target, Task}
-import ammonite.main.Router.EntryPoint
-
-import scala.language.experimental.macros
-
-/**
-  * Metadata about a build that is extracted & materialized at compile-time,
-  * letting us use it at run-time without needing to use the heavy weight
-  * scala-reflect library.
-  *
-  * Note that [[Mirror]] allows you to store and inspect metadata of a type
-  * [[T]] even without a concrete instance of [[T]] itself.
-  */
-case class Mirror[-T, V](node: (T, List[List[Any]]) => V,
-                         commands: Seq[EntryPoint[V]],
-                         children: List[(String, Mirror[T, _])],
-                         crossChildren: Option[(V => List[List[Any]], Mirror[T, _])])
-
-object Mirror{
-
-  def traverseNode[T, V, R](t: T, hierarchy: Mirror[T, V])
-                           (f: (Mirror[T, _], => Segments, => Any) => Seq[R]): Seq[R] = {
-    traverse(t, hierarchy){ (mirror, segmentsRev) =>
-      lazy val resolvedNode = mirror.node(
-        t,
-        segmentsRev.value.map{case Segment.Cross(vs) => vs.toList case _ => Nil}.toList
-      )
-      f(mirror, segmentsRev, resolvedNode)
-    }
-  }
-  def traverse[T, V, R](t: T, hierarchy: Mirror[T, V])
-                       (f: (Mirror[T, _], => Segments) => Seq[R]): Seq[R] = {
-    def rec[C](segmentsRev: List[Segment], h: Mirror[T, C]): Seq[R]= {
-      val crossValues = segmentsRev.map{case Segment.Cross(vs) => vs case _ => Nil}
-      val self = f(h, Segments(segmentsRev.reverse:_*))
-      self ++
-      h.children.flatMap{case (label, c) => rec(Segment.Label(label) :: segmentsRev, c)} ++
-      h.crossChildren.toSeq.flatMap{
-        case (crossGen, c) =>
-          crossGen(h.node(t, crossValues.reverse.map(_.toList))).flatMap(cross =>
-            rec(Segment.Cross(cross) :: segmentsRev, c)
-          )
-      }
-    }
-    rec(Nil, hierarchy)
-  }
-}
diff --git a/core/src/main/scala/mill/eval/Evaluator.scala b/core/src/main/scala/mill/eval/Evaluator.scala
index 28d90fcf..ee4ec27b 100644
--- a/core/src/main/scala/mill/eval/Evaluator.scala
+++ b/core/src/main/scala/mill/eval/Evaluator.scala
@@ -4,9 +4,7 @@ import java.net.URLClassLoader
 
 import ammonite.ops._
 import ammonite.runtime.SpecialClassLoader
-import mill.define._
-import mill.discover.{Discovered, Mirror}
-import mill.define.Segment
+import mill.define.{Segment, Segments, NamedTask, Graph, Target, Task}
 import mill.util
 import mill.util._
 import mill.util.Strict.Agg
@@ -27,14 +25,14 @@ case class Labelled[T](target: NamedTask[T],
 }
 class Evaluator[T](val workspacePath: Path,
                    val basePath: Path,
-                   val mapping: Discovered.Mapping[T],
+                   val rootModule: mill.Module,
                    log: Logger,
                    val classLoaderSig: Seq[(Path, Long)] = Evaluator.classLoaderSig){
 
 
 
   val workerCache = mutable.Map.empty[Ctx.Loader[_], Any]
-  workerCache(Discovered.Mapping) = mapping
+//  workerCache(Discovered.Mapping) = rootModule
   def evaluate(goals: Agg[Task[_]]): Evaluator.Results = {
     mkdir(workspacePath)
 
@@ -44,8 +42,8 @@ class Evaluator[T](val workspacePath: Path,
       case t: NamedTask[Any]   =>
         val segments = t.ctx.segments
         val (finalTaskOverrides, enclosing) = t match{
-          case t: Target[_] => mapping.segmentsToTargets(segments).ctx.overrides -> t.ctx.enclosing
-          case c: mill.define.Command[_] => mapping.segmentsToCommands(segments).overrides -> c.ctx.enclosing
+          case t: Target[_] => rootModule.segmentsToTargets(segments).ctx.overrides -> t.ctx.enclosing
+          case c: mill.define.Command[_] => rootModule.segmentsToCommands(segments).overrides -> c.ctx.enclosing
         }
         val additional =
           if (finalTaskOverrides == t.ctx.overrides) Nil
diff --git a/core/src/main/scala/mill/main/MainRunner.scala b/core/src/main/scala/mill/main/MainRunner.scala
index 2305c11e..49fcfe2a 100644
--- a/core/src/main/scala/mill/main/MainRunner.scala
+++ b/core/src/main/scala/mill/main/MainRunner.scala
@@ -5,7 +5,6 @@ import ammonite.Main
 import ammonite.interp.{Interpreter, Preprocessor}
 import ammonite.ops.Path
 import ammonite.util._
-import mill.discover.Discovered
 import mill.eval.{Evaluator, PathRef}
 import mill.util.PrintLogger
 import upickle.Js
@@ -97,7 +96,6 @@ class MainRunner(config: ammonite.main.Cli.Config,
          |  // Stub to make sure Ammonite has something to call after it evaluates a script,
          |  // even if it does nothing...
          |  def $$main() = Iterator[String]()
-         |  lazy val mapping = mill.discover.Discovered.make[$wrapName].mapping(this)
          |}
          |
          |sealed trait $wrapName extends mill.Module{
diff --git a/core/src/main/scala/mill/main/ReplApplyHandler.scala b/core/src/main/scala/mill/main/ReplApplyHandler.scala
index 718ca358..f7f44270 100644
--- a/core/src/main/scala/mill/main/ReplApplyHandler.scala
+++ b/core/src/main/scala/mill/main/ReplApplyHandler.scala
@@ -3,7 +3,6 @@ package mill.main
 
 import mill.define.Applicative.ApplyHandler
 import mill.define._
-import mill.discover.{Discovered, Mirror}
 import mill.eval.{Evaluator, Result}
 import mill.util.Strict.Agg
 
@@ -11,13 +10,13 @@ import scala.collection.mutable
 object ReplApplyHandler{
   def apply[T](colors: ammonite.util.Colors,
                pprinter0: pprint.PPrinter,
-               mapping: Discovered.Mapping[T]) = {
+               rootModule: mill.Module) = {
     new ReplApplyHandler(
       pprinter0,
       new mill.eval.Evaluator(
         ammonite.ops.pwd / 'out,
         ammonite.ops.pwd,
-        mapping,
+        rootModule,
         new mill.util.PrintLogger(
           colors != ammonite.util.Colors.BlackWhite,
           colors,
@@ -71,14 +70,13 @@ class ReplApplyHandler(pprinter0: pprint.PPrinter, evaluator: Evaluator[_]) exte
           "\n    (" + x._1.map(pprint.PPrinter.BlackWhite.apply(_)).mkString(", ") + ")"
         )
       )
-    case m: mill.Module if evaluator.mapping.modulesToMirrors.contains(m) =>
-      val mirror = evaluator.mapping.modulesToMirrors(m)
+    case m: mill.Module if evaluator.rootModule.modules.contains(m) =>
       pprint.Tree.Lazy( ctx =>
         Iterator(m.millModuleEnclosing, ":", m.millModuleLine.toString) ++
-        (if (mirror.children.isEmpty) Nil
-        else ctx.applyPrefixColor("\nChildren:").toString +: mirror.children.map("\n    ." + _._1)) ++
-        (if (mirror.commands.isEmpty) Nil
-        else ctx.applyPrefixColor("\nCommands:").toString +: mirror.commands.sortBy(_.name).map{c =>
+        (if (m.reflect[mill.Module].isEmpty) Nil
+        else ctx.applyPrefixColor("\nChildren:").toString +: m.reflect[mill.Module].map("\n    ." + _.ctx.segments.render)) ++
+        (if (m.commands.isEmpty) Nil
+        else ctx.applyPrefixColor("\nCommands:").toString +: m.commands.sortBy(_.name).map{c =>
           "\n    ." + c.name + "(" +
             c.argSignatures.map(s => s.name + ": " + s.typeString).mkString(", ") +
             ")()"
@@ -92,12 +90,12 @@ class ReplApplyHandler(pprinter0: pprint.PPrinter, evaluator: Evaluator[_]) exte
         })
 
       )
-    case t: mill.define.Target[_] if evaluator.mapping.targets.contains(t) =>
+    case t: mill.define.Target[_] if evaluator.rootModule.targets.contains(t) =>
       val seen = mutable.Set.empty[Task[_]]
       def rec(t: Task[_]): Seq[Segments] = {
         if (seen(t)) Nil // do nothing
         else t match {
-          case t: Target[_] if evaluator.mapping.targets.contains(t) =>
+          case t: Target[_] if evaluator.rootModule.targets.contains(t) =>
             Seq(t.ctx.segments)
           case _ =>
             seen.add(t)
diff --git a/core/src/main/scala/mill/main/Resolve.scala b/core/src/main/scala/mill/main/Resolve.scala
index 1567f26a..e50e0ca9 100644
--- a/core/src/main/scala/mill/main/Resolve.scala
+++ b/core/src/main/scala/mill/main/Resolve.scala
@@ -1,14 +1,12 @@
 package mill.main
 
-import mill.define.{Segment, Segments, Target, Task}
-import mill.define.Task.TaskModule
-import mill.discover.Mirror
+import mill.define._
+import mill.define.TaskModule
 import ammonite.main.Router
 
 object Resolve {
   def resolve[T, V](remainingSelector: List[Segment],
-                    hierarchy: Mirror[T, V],
-                    obj: T,
+                    obj: mill.Module,
                     rest: Seq[String],
                     remainingCrossSelectors: List[List[String]],
                     revSelectorsSoFar: List[Segment]): Either[String, Task[Any]] = {
@@ -17,31 +15,28 @@ object Resolve {
       case Segment.Cross(_) :: Nil => Left("Selector cannot start with a [cross] segment")
       case Segment.Label(last) :: Nil =>
         def target =
-          hierarchy.node(obj, remainingCrossSelectors).asInstanceOf[mill.Module]
+          obj
             .reflect[Target[_]]
             .find(_.label == last)
             .map(Right(_))
 
-        def invokeCommand[V](mirror: Mirror[T, V], name: String) = for{
-          cmd <- mirror.commands.find(_.name == name)
-        } yield cmd.invoke(
-          mirror.node(obj, remainingCrossSelectors),
-          ammonite.main.Scripts.groupArgs(rest.toList)
-        ) match {
+        def invokeCommand[V](target: mill.Module, name: String) = for{
+          cmd <- target.commands.find(_.name == name)
+        } yield cmd.invoke(target, ammonite.main.Scripts.groupArgs(rest.toList)) match {
           case Router.Result.Success(v) => Right(v)
           case _ => Left(s"Command failed $last")
         }
 
         def runDefault = for{
-          (label, child) <- hierarchy.children
-          if label == last
-          res <- child.node(obj, remainingCrossSelectors) match{
+          child <- obj.reflect[mill.Module]
+          if child.ctx.segment == Segment.Label(last)
+          res <- child match{
             case taskMod: TaskModule => Some(invokeCommand(child, taskMod.defaultCommandName()))
             case _ => None
           }
         } yield res
 
-        def command = invokeCommand(hierarchy, last)
+        def command = invokeCommand(obj, last)
 
         command orElse target orElse runDefault.headOption.flatten match{
           case None =>  Left("Cannot resolve task " +
@@ -57,23 +52,23 @@ object Resolve {
         val newRevSelectorsSoFar = head :: revSelectorsSoFar
         head match{
           case Segment.Label(singleLabel) =>
-            hierarchy.children.collectFirst{
-              case (label, child) if label == singleLabel => child
+            obj.reflect[mill.Module].find{
+              _.ctx.segment == Segment.Label(singleLabel)
             } match{
-              case Some(child) => resolve(tail, child, obj, rest, remainingCrossSelectors, newRevSelectorsSoFar)
+              case Some(child: mill.Module) => resolve(tail, child, rest, remainingCrossSelectors, newRevSelectorsSoFar)
               case None => Left("Cannot resolve module " + Segments(newRevSelectorsSoFar.reverse:_*).render)
             }
 
           case Segment.Cross(cross) =>
-            val Some((crossGen, childMirror)) = hierarchy.crossChildren
-            val crossOptions = crossGen(hierarchy.node(obj, remainingCrossSelectors))
-            if (crossOptions.contains(cross)){
-              resolve(tail, childMirror, obj, rest, remainingCrossSelectors, newRevSelectorsSoFar)
-            }else{
-              Left("Cannot resolve cross " + Segments(newRevSelectorsSoFar.reverse:_*).render)
-            }
-
+            obj match{
+              case c: Cross[_] =>
+                c.itemMap.get(cross.toList) match{
+                  case Some(m: mill.Module) => resolve(tail, m, rest, remainingCrossSelectors, newRevSelectorsSoFar)
+                  case None => Left("Cannot resolve cross " + Segments(newRevSelectorsSoFar.reverse:_*).render)
 
+                }
+              case _ => Left("Cannot resolve cross " + Segments(newRevSelectorsSoFar.reverse:_*).render)
+            }
         }
 
       case Nil => Left("Selector cannot be empty")
diff --git a/core/src/main/scala/mill/main/RunScript.scala b/core/src/main/scala/mill/main/RunScript.scala
index 785db80e..acabcf0a 100644
--- a/core/src/main/scala/mill/main/RunScript.scala
+++ b/core/src/main/scala/mill/main/RunScript.scala
@@ -9,7 +9,6 @@ import ammonite.util.{Name, Res, Util}
 import mill.{PathRef, define}
 import mill.define.Task
 import mill.define.Segment
-import mill.discover.Discovered
 import mill.eval.{Evaluator, Result}
 import mill.util.{EitherOps, Logger}
 import mill.util.Strict.Agg
@@ -73,7 +72,7 @@ object RunScript{
 
   def evaluateMapping(wd: Path,
                       path: Path,
-                      interp: ammonite.interp.Interpreter): Res[Discovered.Mapping[_]] = {
+                      interp: ammonite.interp.Interpreter): Res[mill.Module] = {
 
     val (pkg, wrapper) = Util.pathToPackageWrapper(Seq(), path relativeTo wd)
 
@@ -102,15 +101,15 @@ object RunScript{
       mapping <- try {
         Util.withContextClassloader(interp.evalClassloader) {
           Res.Success(
-            buildCls.getDeclaredMethod("mapping")
-              .invoke(null)
-              .asInstanceOf[Discovered.Mapping[_]]
+            buildCls.getField("MODULE$")
+              .get(buildCls)
+              .asInstanceOf[mill.Module]
           )
         }
       } catch {
         case e: Throwable => Res.Exception(e, "")
       }
-      _ <- Res(consistencyCheck(mapping))
+//      _ <- Res(consistencyCheck(mapping))
     } yield mapping
   }
 
@@ -126,7 +125,7 @@ object RunScript{
             case _ => Nil
           }
           mill.main.Resolve.resolve(
-            sel, evaluator.mapping.mirror, evaluator.mapping.base,
+            sel, evaluator.rootModule,
             args, crossSelectors, Nil
           )
         }
@@ -180,12 +179,12 @@ object RunScript{
     }
   }
 
-  def consistencyCheck[T](mapping: Discovered.Mapping[T]): Either[String, Unit] = {
-    val consistencyErrors = Discovered.consistencyCheck(mapping)
-    if (consistencyErrors.nonEmpty) {
-      Left(s"Failed Discovered.consistencyCheck: ${consistencyErrors.map(_.render)}")
-    } else {
-      Right(())
-    }
-  }
+//  def consistencyCheck[T](mapping: Discovered.Mapping[T]): Either[String, Unit] = {
+//    val consistencyErrors = Discovered.consistencyCheck(mapping)
+//    if (consistencyErrors.nonEmpty) {
+//      Left(s"Failed Discovered.consistencyCheck: ${consistencyErrors.map(_.render)}")
+//    } else {
+//      Right(())
+//    }
+//  }
 }
diff --git a/core/src/main/scala/mill/package.scala b/core/src/main/scala/mill/package.scala
index 78233cad..93916c8b 100644
--- a/core/src/main/scala/mill/package.scala
+++ b/core/src/main/scala/mill/package.scala
@@ -6,7 +6,6 @@ package object mill extends JsonFormatters{
   val PathRef = mill.eval.PathRef
   type PathRef = mill.eval.PathRef
   type Module = define.Module
-  val Module = define.Module
   type Cross[T] = define.Cross[T]
   type Agg[T] = util.Loose.Agg[T]
   val Agg = util.Loose.Agg
diff --git a/core/src/test/scala/mill/define/CacherTests.scala b/core/src/test/scala/mill/define/CacherTests.scala
index 5fca1ff0..eb981d46 100644
--- a/core/src/test/scala/mill/define/CacherTests.scala
+++ b/core/src/test/scala/mill/define/CacherTests.scala
@@ -1,6 +1,5 @@
 package mill.define
 
-import mill.discover.Discovered
 import mill.eval.Evaluator
 import mill.util.{DummyLogger, TestUtil}
 import mill.util.Strict.Agg
@@ -28,7 +27,7 @@ object CacherTests extends TestSuite{
   val tests = Tests{
 
 
-    def eval[V](mapping: Discovered.Mapping[_], v: Task[V])(implicit tp: TestPath) = {
+    def eval[V](mapping: mill.Module, v: Task[V])(implicit tp: TestPath) = {
       val workspace = ammonite.ops.pwd / 'target / 'workspace / tp.value
       val evaluator = new Evaluator(workspace, ammonite.ops.pwd, mapping, DummyLogger)
       evaluator.evaluate(Agg(v)).values(0)
@@ -36,30 +35,28 @@ object CacherTests extends TestSuite{
 
     'simpleDefIsCached - assert(
       Base.value eq Base.value,
-      eval(Discovered.mapping(Base), Base.value) == 1
+      eval(Base, Base.value) == 1
     )
 
     'resultDefIsCached - assert(
       Base.result eq Base.result,
-      eval(Discovered.mapping(Base), Base.result) == 1
+      eval(Base, Base.result) == 1
     )
 
-    val middleMapping = Discovered.mapping(Middle)
 
     'overridingDefIsAlsoCached - assert(
-      eval(middleMapping, Middle.value) == 3,
+      eval(Middle, Middle.value) == 3,
       Middle.value eq Middle.value
     )
 
     'overridenDefRemainsAvailable - assert(
-      eval(middleMapping, Middle.overriden) == 1
+      eval(Middle, Middle.overriden) == 1
     )
 
-    val terminalMapping = Discovered.mapping(Terminal)
 
     'multipleOverridesWork- assert(
-      eval(terminalMapping, Terminal.value) == 7,
-      eval(terminalMapping, Terminal.overriden) == 1
+      eval(Terminal, Terminal.value) == 7,
+      eval(Terminal, Terminal.overriden) == 1
     )
     //    Doesn't fail, presumably compileError doesn't go far enough in the
     //    compilation pipeline to hit the override checks
diff --git a/core/src/test/scala/mill/define/GraphTests.scala b/core/src/test/scala/mill/define/GraphTests.scala
index 3988328b..7e6680be 100644
--- a/core/src/test/scala/mill/define/GraphTests.scala
+++ b/core/src/test/scala/mill/define/GraphTests.scala
@@ -1,8 +1,6 @@
 package mill.define
 
 
-import mill.discover.Discovered
-import Discovered.mapping
 import mill.eval.Evaluator
 import mill.util.{TestGraphs, TestUtil}
 import utest._
@@ -151,7 +149,7 @@ object GraphTests extends TestSuite{
       )
     }
     'multiTerminalGroupCounts - {
-      def countGroups(mapping: Discovered.Mapping[_], goals: Task[_]*) = {
+      def countGroups(goals: Task[_]*) = {
 
         val topoSorted = Graph.topoSorted(
           Graph.transitiveTargets(Agg.from(goals))
@@ -165,7 +163,7 @@ object GraphTests extends TestSuite{
 
       'separateGroups - {
         import separateGroups._
-        val groupCount = countGroups(mapping(separateGroups), right, left)
+        val groupCount = countGroups(right, left)
         assert(groupCount == 3)
       }
 
@@ -174,7 +172,7 @@ object GraphTests extends TestSuite{
         // `right` depends on `left`, both of them depend on the un-cached `task`
         // which would force them both to re-compute every time `task` changes
         import triangleTask._
-        val groupCount = countGroups(mapping(triangleTask), right, left)
+        val groupCount = countGroups(right, left)
         assert(groupCount == 2)
       }
 
@@ -182,7 +180,7 @@ object GraphTests extends TestSuite{
       'multiTerminalGroup - {
         // Make sure the following graph ends up as two groups
         import multiTerminalGroup._
-        val groupCount = countGroups(mapping(multiTerminalGroup), right, left)
+        val groupCount = countGroups(right, left)
         assert(groupCount == 2)
       }
 
@@ -191,7 +189,7 @@ object GraphTests extends TestSuite{
         // Make sure the following graph ends up as a three groups: one for
         // each cached target, and one for the downstream task we are running
         import multiTerminalBoundary._
-        val groupCount = countGroups(mapping(multiTerminalBoundary), task2)
+        val groupCount = countGroups(task2)
         assert(groupCount == 3)
       }
     }
diff --git a/core/src/test/scala/mill/discover/ConsistencyTests.scala b/core/src/test/scala/mill/discover/ConsistencyTests.scala
deleted file mode 100644
index dab60a01..00000000
--- a/core/src/test/scala/mill/discover/ConsistencyTests.scala
+++ /dev/null
@@ -1,59 +0,0 @@
-package mill.discover
-
-
-import mill.define.Segment.Label
-import mill.define.Segments
-import mill.util.{TestGraphs}
-import mill.util.Strict.Agg
-import utest._
-
-object ConsistencyTests extends TestSuite{
-
-  val tests = Tests{
-    val graphs = new TestGraphs()
-    import graphs._
-    'failConsistencyChecks - {
-      // Make sure these fail because `def`s without `Cacher` will re-evaluate
-      // each time, returning different sets of targets.
-      //
-      // Maybe later we can convert them into compile errors somehow
-
-      val expected = Agg(
-        Segments(Label("down")),
-        Segments(Label("right")),
-        Segments(Label("left")),
-        Segments(Label("up"))
-      )
-
-      'diamond - {
-        val inconsistent = Discovered.consistencyCheck(
-          Discovered.mapping(diamond)
-        )
-
-        assert(inconsistent == Agg())
-      }
-
-      'anonDiamond - {
-        val inconsistent = Discovered.consistencyCheck(
-          Discovered.mapping(anonDiamond)
-        )
-
-        assert(inconsistent == Agg())
-      }
-
-      'borkedCachedDiamond2 - {
-        val inconsistent = Discovered.consistencyCheck(
-          Discovered.mapping(borkedCachedDiamond2)
-        )
-        assert(inconsistent.toSet == expected.toSet)
-      }
-      'borkedCachedDiamond3 - {
-        val inconsistent = Discovered.consistencyCheck(
-          Discovered.mapping(borkedCachedDiamond3)
-        )
-        assert(inconsistent.toSet == expected.toSet)
-      }
-    }
-
-  }
-}
diff --git a/core/src/test/scala/mill/discover/CrossTests.scala b/core/src/test/scala/mill/discover/CrossTests.scala
deleted file mode 100644
index fe9f8812..00000000
--- a/core/src/test/scala/mill/discover/CrossTests.scala
+++ /dev/null
@@ -1,116 +0,0 @@
-package mill.discover
-
-import mill.define.Segment
-import mill.define.Segment.Label
-import utest._
-import mill.util.TestGraphs._
-import mill.util.TestUtil
-object CrossTests extends TestSuite{
-
-  val tests = Tests{
-
-    'cross - {
-      object outer extends TestUtil.BaseModule {
-        object crossed extends mill.Cross[CrossedModule]("2.10.6", "2.11.8", "2.12.4")
-        class CrossedModule(n: String) extends mill.Module{
-          def scalaVersion = n
-        }
-      }
-
-      val discovered = Discovered.make[outer.type]
-
-      val Some((gen, innerMirror)) = discovered
-        .mirror
-        .children
-        .head._2
-        .asInstanceOf[Mirror[outer.type, outer.crossed.type]]
-        .crossChildren
-
-      val keys = gen(outer.crossed)
-      assert(keys == List(List("2.10.6"), List("2.11.8"), List("2.12.4")))
-      for(k <- keys){
-        assert(outer.crossed.get(k).scalaVersion == k.head)
-      }
-    }
-    'doubleCross - {
-      object outer extends TestUtil.BaseModule {
-        val crossMatrix = for{
-          platform <- Seq("", "sjs0.6", "native0.3")
-          scalaVersion <- Seq("2.10.6", "2.11.8", "2.12.4")
-          if !(platform == "native0.3" && scalaVersion == "2.10.6")
-        } yield (platform, scalaVersion)
-        object crossed extends mill.Cross[Cross](crossMatrix:_*)
-        case class Cross(platform: String, scalaVersion: String) extends mill.Module{
-          def suffix = Seq(scalaVersion, platform).filter(_.nonEmpty).map("_"+_).mkString
-        }
-      }
-
-      val Some((gen, innerMirror)) = Discovered.make[outer.type]
-        .mirror
-        .children
-        .head._2
-        .asInstanceOf[Mirror[outer.type, outer.crossed.type]]
-        .crossChildren
-
-      val keys = gen(outer.crossed)
-      val expectedKeys = List(
-        List("2.10.6", ""),
-        List("2.11.8", ""),
-        List("2.12.4", ""),
-        List("2.10.6", "sjs0.6"),
-        List("2.11.8", "sjs0.6"),
-        List("2.12.4", "sjs0.6"),
-        List("2.11.8", "native0.3"),
-        List("2.12.4", "native0.3")
-      )
-
-      assert(keys == expectedKeys)
-      for(k <- keys){
-        val suffix = outer.crossed.get(k).suffix
-        val expected = k.map(_.toString).filter(_.nonEmpty).map("_"+_).mkString
-        assert(suffix == expected)
-      }
-    }
-    'crossTargetDiscovery - {
-
-      val discovered = Discovered.mapping(singleCross)
-
-      val segments = discovered.targets.map(_.ctx.segments.value).toSet
-      val expectedSegments = Set(
-        List(Label("cross"), Segment.Cross(List("210")), Label("suffix")),
-        List(Label("cross"), Segment.Cross(List("211")), Label("suffix")),
-        List(Label("cross"), Segment.Cross(List("212")), Label("suffix"))
-      )
-      assert(segments == expectedSegments)
-      val targets = discovered.targets.toSet
-      val expected = Set(
-        singleCross.cross("210").suffix,
-        singleCross.cross("211").suffix,
-        singleCross.cross("212").suffix
-      )
-      assert(targets == expected)
-    }
-
-    'doubleCrossTargetDiscovery - {
-      val discovered = Discovered.mapping(doubleCross)
-      val targets = discovered.targets.toSet
-
-      val expected = Set(
-        doubleCross.cross("jvm", "210").suffix,
-        doubleCross.cross("js", "210").suffix,
-        doubleCross.cross("jvm", "211").suffix,
-        doubleCross.cross("js", "211").suffix,
-        doubleCross.cross("jvm", "212").suffix,
-        doubleCross.cross("js", "212").suffix,
-        doubleCross.cross("native", "212").suffix
-      )
-      assert(targets == expected)
-    }
-
-    'nestedCrosses - {
-      val discovered = Discovered.mapping(nestedCrosses).targets
-      assert(discovered.size == 9)
-    }
-  }
-}
-
diff --git a/core/src/test/scala/mill/discover/DiscoveredTests.scala b/core/src/test/scala/mill/discover/DiscoveredTests.scala
deleted file mode 100644
index dfa39050..00000000
--- a/core/src/test/scala/mill/discover/DiscoveredTests.scala
+++ /dev/null
@@ -1,121 +0,0 @@
-package mill.discover
-
-import java.io.InputStreamReader
-
-import ammonite.main.Router.{ArgSig, EntryPoint}
-import utest._
-import mill.{Module, T}
-import mill.define.Segment.Label
-import mill.define.Segments
-import mill.util.TestGraphs.{TraitWithModuleObject, nestedModule}
-import mill.util.TestUtil
-object DiscoveredTests extends TestSuite{
-
-  val tests = Tests{
-
-    'targets - {
-      val discovered = Discovered.mapping(nestedModule)
-
-      def flatten(h: Mirror[nestedModule.type, _]): Seq[Any] = {
-        h.node(nestedModule, Nil) :: h.children.flatMap{case (label, c) => flatten(c)}
-      }
-      val flattenedHierarchy = flatten(discovered.mirror)
-
-      val expectedHierarchy = Set(
-        nestedModule,
-        nestedModule.classInstance,
-        nestedModule.nested
-      )
-      assert(flattenedHierarchy.toSet == expectedHierarchy)
-
-      val mapped = discovered.segmentsToTargets
-
-      val expected = Map(
-        (Segments(Label("classInstance"), Label("single")), nestedModule.classInstance.single),
-        (Segments(Label("nested"), Label("single")), nestedModule.nested.single),
-        (Segments(Label("single")), nestedModule.single)
-      )
-      assert(mapped == expected)
-    }
-
-    'traitWithModule - {
-      val discovered = Discovered.mapping(TraitWithModuleObject)
-      val mapped = discovered.segmentsToTargets
-      val expected = Map(
-        (
-          Segments(Label("TraitModule"), Label("testFramework")),
-          TraitWithModuleObject.TraitModule.testFramework
-        )
-      )
-      assert(mapped == expected)
-    }
-
-    'commands - {
-      object outer extends TestUtil.BaseModule{
-        def hello() = T.command{
-          println("Hello")
-        }
-        def echoPair(prefix: String, suffix: String) = T.command{
-          println(prefix + " " + suffix)
-        }
-        object nested extends Module{
-          def inner(x: Int) = T.command{
-            println(x)
-          }
-        }
-
-      }
-
-      val discovered = Discovered.make[outer.type]
-      val outerCommands = discovered.mirror.commands
-
-      assertMatch(outerCommands){case Seq(
-        EntryPoint("hello", Nil, None, false, _, _),
-        EntryPoint("echoPair",
-          List(ArgSig("prefix", "String", None, None), ArgSig("suffix", "String", None, None)),
-          None,
-          false,
-          _,
-          _
-        )
-      ) =>}
-
-      val innerCommands = discovered.mirror
-        .children
-        .flatMap(_._2.commands.asInstanceOf[Seq[EntryPoint[_]]])
-
-      assertMatch(innerCommands){case Seq(
-        EntryPoint("inner", _, None, false, _, _),
-      ) =>}
-    }
-
-    'compileError - {
-      'unserializableTarget - {
-
-
-        object outer extends TestUtil.BaseModule {
-          val error = compileError("def single = mill.T{ new InputStreamReader(System.in) }")
-        }
-
-
-        assert(
-          outer.error.msg.contains("uPickle does not know how to read"),
-          outer.error.pos.contains("def single = mill.T{ new InputStreamReader(System.in) }")
-        )
-      }
-
-      'unreadableCommand - {
-        object outer extends TestUtil.BaseModule {
-          def single(in: InputStreamReader) = mill.T.command{ println(123) }
-        }
-
-        val error = compileError("Discovered.make[outer.type]")
-
-        assert(
-          error.msg.contains("could not find implicit value"),
-          error.pos.contains("def single(in: InputStreamReader) = mill.T.command{ println(123) }")
-        )
-      }
-    }
-  }
-}
diff --git a/core/src/test/scala/mill/discover/LabelingTests.scala b/core/src/test/scala/mill/discover/LabelingTests.scala
deleted file mode 100644
index 5881d50c..00000000
--- a/core/src/test/scala/mill/discover/LabelingTests.scala
+++ /dev/null
@@ -1,54 +0,0 @@
-package mill.discover
-
-import mill.define.{Segment, Segments, Task}
-import mill.util.TestGraphs
-import utest._
-import Discovered.mapping
-import mill.define.Segment.Label
-object LabelingTests extends TestSuite{
-
-  val tests = Tests{
-    val graphs = new TestGraphs()
-    import graphs._
-
-    'labeling - {
-
-      def check(mapping: Discovered.Mapping[_], t: Task[_], relPath: Option[String]) = {
-
-
-        val names: Seq[(Task[_], Segments)] = mapping.targetsToSegments.toSeq
-        val nameMap = names.toMap
-
-        val targetLabel = nameMap.get(t).map(_.render)
-        assert(targetLabel == relPath)
-      }
-      'singleton - check(mapping(singleton), singleton.single, Some("single"))
-      'pair - {
-        check(mapping(pair), pair.up, Some("up"))
-        check(mapping(pair), pair.down, Some("down"))
-      }
-
-      'anonTriple - {
-        check(mapping(anonTriple), anonTriple.up, Some("up"))
-        check(mapping(anonTriple), anonTriple.down.inputs(0), None)
-        check(mapping(anonTriple), anonTriple.down, Some("down"))
-      }
-
-      'diamond - {
-        check(mapping(diamond), diamond.up, Some("up"))
-        check(mapping(diamond), diamond.left, Some("left"))
-        check(mapping(diamond), diamond.right, Some("right"))
-        check(mapping(diamond), diamond.down, Some("down"))
-      }
-
-      'anonDiamond - {
-        check(mapping(anonDiamond), anonDiamond.up, Some("up"))
-        check(mapping(anonDiamond), anonDiamond.down.inputs(0), None)
-        check(mapping(anonDiamond), anonDiamond.down.inputs(1), None)
-        check(mapping(anonDiamond), anonDiamond.down, Some("down"))
-      }
-
-    }
-
-  }
-}
diff --git a/core/src/test/scala/mill/eval/EvaluationTests.scala b/core/src/test/scala/mill/eval/EvaluationTests.scala
index 31ae5ab9..0d14988a 100644
--- a/core/src/test/scala/mill/eval/EvaluationTests.scala
+++ b/core/src/test/scala/mill/eval/EvaluationTests.scala
@@ -4,19 +4,17 @@ package mill.eval
 import mill.util.TestUtil.{Test, test}
 import mill.define.{Graph, Target, Task}
 import mill.{Module, T}
-import mill.discover.Discovered
-import mill.discover.Discovered.mapping
 import mill.util.{DummyLogger, TestGraphs, TestUtil}
 import mill.util.Strict.Agg
 import utest._
 import utest.framework.TestPath
 
 object EvaluationTests extends TestSuite{
-  class Checker(mapping: Discovered.Mapping[_])(implicit tp: TestPath) {
+  class Checker(module: mill.Module)(implicit tp: TestPath) {
     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, ammonite.ops.pwd, mapping, DummyLogger)
+    def evaluator = new Evaluator(workspace, ammonite.ops.pwd, module, DummyLogger)
 
     def apply(target: Task[_], expValue: Any,
               expEvaled: Agg[Task[_]],
@@ -59,7 +57,7 @@ object EvaluationTests extends TestSuite{
 
       'singleton - {
         import singleton._
-        val check = new Checker(mapping(singleton))
+        val check = new Checker(singleton)
         // First time the target is evaluated
         check(single, expValue = 0, expEvaled = Agg(single))
 
@@ -69,7 +67,7 @@ object EvaluationTests extends TestSuite{
       }
       'pair - {
         import pair._
-        val check = new Checker(mapping(pair))
+        val check = new Checker(pair)
         check(down, expValue = 0, expEvaled = Agg(up, down))
 
         down.counter += 1
@@ -80,7 +78,7 @@ object EvaluationTests extends TestSuite{
       }
       'anonTriple - {
         import anonTriple._
-        val check = new Checker(mapping(anonTriple))
+        val check = new Checker(anonTriple)
         val middle = down.inputs(0)
         check(down, expValue = 0, expEvaled = Agg(up, middle, down))
 
@@ -96,7 +94,7 @@ object EvaluationTests extends TestSuite{
       }
       'diamond - {
         import diamond._
-        val check = new Checker(mapping(diamond))
+        val check = new Checker(diamond)
         check(down, expValue = 0, expEvaled = Agg(up, left, right, down))
 
         down.counter += 1
@@ -114,7 +112,7 @@ object EvaluationTests extends TestSuite{
       }
       'anonDiamond - {
         import anonDiamond._
-        val check = new Checker(mapping(anonDiamond))
+        val check = new Checker(anonDiamond)
         val left = down.inputs(0).asInstanceOf[TestUtil.Test]
         val right = down.inputs(1).asInstanceOf[TestUtil.Test]
         check(down, expValue = 0, expEvaled = Agg(up, left, right, down))
@@ -135,7 +133,7 @@ object EvaluationTests extends TestSuite{
 
       'bigSingleTerminal - {
         import bigSingleTerminal._
-        val check = new Checker(mapping(bigSingleTerminal))
+        val check = new Checker(bigSingleTerminal)
 
         check(j, expValue = 0, expEvaled = Agg(a, b, e, f, i, j), extraEvaled = 22)
 
@@ -158,7 +156,7 @@ object EvaluationTests extends TestSuite{
         // even though one depends on the other
 
         import separateGroups._
-        val checker = new Checker(mapping(separateGroups))
+        val checker = new Checker(separateGroups)
         val evaled1 = checker.evaluator.evaluate(Agg(right, left))
         val filtered1 = evaled1.evaluated.filter(_.isInstanceOf[Target[_]])
         assert(filtered1 == Agg(change, left, right))
@@ -175,7 +173,7 @@ object EvaluationTests extends TestSuite{
       'triangleTask - {
 
         import triangleTask._
-        val checker = new Checker(mapping(triangleTask))
+        val checker = new Checker(triangleTask)
         checker(right, 3, Agg(left, right), extraEvaled = -1)
         checker(left, 1, Agg(), extraEvaled = -1)
 
@@ -183,7 +181,7 @@ object EvaluationTests extends TestSuite{
       'multiTerminalGroup - {
         import multiTerminalGroup._
 
-        val checker = new Checker(mapping(multiTerminalGroup))
+        val checker = new Checker(multiTerminalGroup)
         checker(right, 1, Agg(right), extraEvaled = -1)
         checker(left, 1, Agg(left), extraEvaled = -1)
       }
@@ -192,7 +190,7 @@ object EvaluationTests extends TestSuite{
 
         import multiTerminalBoundary._
 
-        val checker = new Checker(mapping(multiTerminalBoundary))
+        val checker = new Checker(multiTerminalBoundary)
         checker(task2, 4, Agg(right, left), extraEvaled = -1, secondRunNoOp = false)
         checker(task2, 4, Agg(), extraEvaled = -1, secondRunNoOp = false)
       }
@@ -200,7 +198,7 @@ object EvaluationTests extends TestSuite{
       'overrideSuperTask - {
         import canOverrideSuper._
 
-        val checker = new Checker(mapping(canOverrideSuper))
+        val checker = new Checker(canOverrideSuper)
         checker(foo, Seq("base", "object"), Agg(foo), extraEvaled = -1)
       }
 
@@ -237,7 +235,7 @@ object EvaluationTests extends TestSuite{
 
         // During the first evaluation, they get computed normally like any
         // cached target
-        val check = new Checker(mapping(build))
+        val check = new Checker(build)
         assert(leftCount == 0, rightCount == 0)
         check(down, expValue = 10101, expEvaled = Agg(up, right, down), extraEvaled = 8)
         assert(leftCount == 1, middleCount == 1, rightCount == 1)
diff --git a/core/src/test/scala/mill/eval/FailureTests.scala b/core/src/test/scala/mill/eval/FailureTests.scala
index c1ca1533..12ed345d 100644
--- a/core/src/test/scala/mill/eval/FailureTests.scala
+++ b/core/src/test/scala/mill/eval/FailureTests.scala
@@ -1,8 +1,6 @@
 package mill.eval
 
 import mill.define.Target
-import mill.discover.Discovered
-import mill.discover.Discovered.mapping
 import mill.util.DummyLogger
 import mill.util.Strict.Agg
 import utest._
@@ -13,9 +11,9 @@ object FailureTests extends TestSuite{
   def workspace(implicit tp: TestPath) = {
     ammonite.ops.pwd / 'target / 'workspace / 'failure / implicitly[TestPath].value
   }
-  class Checker(mapping: Discovered.Mapping[_])(implicit tp: TestPath){
+  class Checker(module: mill.Module)(implicit tp: TestPath){
 
-    val evaluator = new Evaluator(workspace, ammonite.ops.pwd, mapping, DummyLogger)
+    val evaluator = new Evaluator(workspace, ammonite.ops.pwd, module, DummyLogger)
 
     def apply(target: Target[_], expectedFailCount: Int, expectedRawValues: Seq[Result[_]]) = {
 
@@ -39,7 +37,7 @@ object FailureTests extends TestSuite{
 
     'evaluateSingle - {
       ammonite.ops.rm(ammonite.ops.Path(workspace, ammonite.ops.pwd))
-      val check = new Checker(mapping(singleton))
+      val check = new Checker(singleton)
       check(
         target = singleton.single,
         expectedFailCount = 0,
@@ -75,7 +73,7 @@ object FailureTests extends TestSuite{
     }
     'evaluatePair - {
       ammonite.ops.rm(ammonite.ops.Path(workspace, ammonite.ops.pwd))
-      val check = new Checker(mapping(pair))
+      val check = new Checker(pair)
       check(
         pair.down,
         expectedFailCount = 0,
diff --git a/core/src/test/scala/mill/eval/JavaCompileJarTests.scala b/core/src/test/scala/mill/eval/JavaCompileJarTests.scala
index f40fb798..e2656913 100644
--- a/core/src/test/scala/mill/eval/JavaCompileJarTests.scala
+++ b/core/src/test/scala/mill/eval/JavaCompileJarTests.scala
@@ -3,7 +3,6 @@ package mill.eval
 import ammonite.ops.ImplicitWd._
 import ammonite.ops._
 import mill.define.{Input, Target, Task}
-import mill.discover.Discovered
 import mill.modules.Jvm
 import mill.util.Ctx.DestCtx
 import mill.{Module, T}
@@ -49,17 +48,16 @@ object JavaCompileJarTests extends TestSuite{
       }
 
       import Build._
-      val mapping = Discovered.mapping(Build)
 
       def eval[T](t: Task[T]) = {
-        val evaluator = new Evaluator(workspacePath, pwd, mapping, DummyLogger)
+        val evaluator = new Evaluator(workspacePath, pwd, Build, DummyLogger)
         val evaluated = evaluator.evaluate(Agg(t))
 
         if (evaluated.failing.keyCount == 0){
           Right(Tuple2(
             evaluated.rawValues(0).asInstanceOf[Result.Success[T]].value,
             evaluated.evaluated.collect{
-              case t: Target[_] if mapping.targets.contains(t) => t
+              case t: Target[_] if Build.targets.contains(t) => t
               case t: mill.define.Command[_] => t
             }.size
           ))
@@ -69,12 +67,12 @@ object JavaCompileJarTests extends TestSuite{
 
       }
       def check(targets: Agg[Task[_]], expected: Agg[Task[_]]) = {
-        val evaluator = new Evaluator(workspacePath, pwd, mapping, DummyLogger)
+        val evaluator = new Evaluator(workspacePath, pwd, Build, DummyLogger)
 
         val evaluated = evaluator.evaluate(targets)
           .evaluated
           .flatMap(_.asTarget)
-          .filter(mapping.targets.contains)
+          .filter(Build.targets.contains)
           .filter(!_.isInstanceOf[Input[_]])
         assert(evaluated == expected)
       }
diff --git a/core/src/test/scala/mill/main/MainTests.scala b/core/src/test/scala/mill/main/MainTests.scala
index b4568267..a22cb5a6 100644
--- a/core/src/test/scala/mill/main/MainTests.scala
+++ b/core/src/test/scala/mill/main/MainTests.scala
@@ -2,20 +2,18 @@ package mill.main
 
 import mill.Module
 import mill.define.{Segment, Task}
-import mill.discover.{Discovered, Mirror}
 import mill.util.TestGraphs._
 import mill.util.TestUtil.test
 import utest._
-import Discovered.mapping
 object MainTests extends TestSuite{
-  def check[T](mapping: Discovered.Mapping[T],
+  def check[T](module: mill.Module,
                selectorString: String,
                expected: Either[String, Task[_]]) = {
 
     val resolved = for{
       selectors <- mill.main.ParseArgs(Seq(selectorString)).map(_._1.head)
       val crossSelectors = selectors.map{case Segment.Cross(x) => x.toList.map(_.toString) case _ => Nil}
-      task <- mill.main.Resolve.resolve(selectors, mapping.mirror, mapping.base, Nil, crossSelectors, Nil)
+      task <- mill.main.Resolve.resolve(selectors, module, Nil, crossSelectors, Nil)
     } yield task
     assert(resolved == expected)
   }
@@ -23,39 +21,39 @@ object MainTests extends TestSuite{
     val graphs = new mill.util.TestGraphs()
     import graphs._
     'single - {
-      'pos - check(mapping(singleton), "single", Right(singleton.single))
-      'neg1 - check(mapping(singleton), "doesntExist", Left("Cannot resolve task doesntExist"))
-      'neg2 - check(mapping(singleton), "single.doesntExist", Left("Cannot resolve module single"))
-      'neg3 - check(mapping(singleton), "", Left("Selector cannot be empty"))
+      'pos - check(singleton, "single", Right(singleton.single))
+      'neg1 - check(singleton, "doesntExist", Left("Cannot resolve task doesntExist"))
+      'neg2 - check(singleton, "single.doesntExist", Left("Cannot resolve module single"))
+      'neg3 - check(singleton, "", Left("Selector cannot be empty"))
     }
     'nested - {
 
-      'pos1 - check(mapping(nestedModule), "single", Right(nestedModule.single))
-      'pos2 - check(mapping(nestedModule), "nested.single", Right(nestedModule.nested.single))
-      'pos3 - check(mapping(nestedModule), "classInstance.single", Right(nestedModule.classInstance.single))
-      'neg1 - check(mapping(nestedModule), "doesntExist", Left("Cannot resolve task doesntExist"))
-      'neg2 - check(mapping(nestedModule), "single.doesntExist", Left("Cannot resolve module single"))
-      'neg3 - check(mapping(nestedModule), "nested.doesntExist", Left("Cannot resolve task nested.doesntExist"))
-      'neg4 - check(mapping(nestedModule), "classInstance.doesntExist", Left("Cannot resolve task classInstance.doesntExist"))
+      'pos1 - check(nestedModule, "single", Right(nestedModule.single))
+      'pos2 - check(nestedModule, "nested.single", Right(nestedModule.nested.single))
+      'pos3 - check(nestedModule, "classInstance.single", Right(nestedModule.classInstance.single))
+      'neg1 - check(nestedModule, "doesntExist", Left("Cannot resolve task doesntExist"))
+      'neg2 - check(nestedModule, "single.doesntExist", Left("Cannot resolve module single"))
+      'neg3 - check(nestedModule, "nested.doesntExist", Left("Cannot resolve task nested.doesntExist"))
+      'neg4 - check(nestedModule, "classInstance.doesntExist", Left("Cannot resolve task classInstance.doesntExist"))
     }
     'cross - {
       'single - {
 
-        'pos1 - check(mapping(singleCross), "cross[210].suffix", Right(singleCross.cross("210").suffix))
-        'pos2 - check(mapping(singleCross), "cross[211].suffix", Right(singleCross.cross("211").suffix))
-        'neg1 - check(mapping(singleCross), "cross[210].doesntExist", Left("Cannot resolve task cross[210].doesntExist"))
-        'neg2 - check(mapping(singleCross), "cross[doesntExist].doesntExist", Left("Cannot resolve cross cross[doesntExist]"))
-        'neg2 - check(mapping(singleCross), "cross[doesntExist].suffix", Left("Cannot resolve cross cross[doesntExist]"))
+        'pos1 - check(singleCross, "cross[210].suffix", Right(singleCross.cross("210").suffix))
+        'pos2 - check(singleCross, "cross[211].suffix", Right(singleCross.cross("211").suffix))
+        'neg1 - check(singleCross, "cross[210].doesntExist", Left("Cannot resolve task cross[210].doesntExist"))
+        'neg2 - check(singleCross, "cross[doesntExist].doesntExist", Left("Cannot resolve cross cross[doesntExist]"))
+        'neg2 - check(singleCross, "cross[doesntExist].suffix", Left("Cannot resolve cross cross[doesntExist]"))
       }
 //      'double - {
 //
 //        'pos1 - check(
-//          mapping(doubleCross),
+//          doubleCross,
 //          "cross[jvm,210].suffix",
 //          Right(doubleCross.cross("jvm", "210").suffix)
 //        )
 //        'pos2 - check(
-//          mapping(doubleCross),
+//          doubleCross,
 //          "cross[jvm,211].suffix",
 //          Right(doubleCross.cross("jvm", "211").suffix)
 //        )
@@ -63,24 +61,24 @@ object MainTests extends TestSuite{
       'nested - {
         'indirect - {
           'pos1 - check(
-            mapping(indirectNestedCrosses),
+            indirectNestedCrosses,
             "cross[210].cross2[js].suffix",
             Right(indirectNestedCrosses.cross("210").cross2("js").suffix)
           )
           'pos2 - check(
-            mapping(indirectNestedCrosses),
+            indirectNestedCrosses,
             "cross[211].cross2[jvm].suffix",
             Right(indirectNestedCrosses.cross("211").cross2("jvm").suffix)
           )
         }
         'direct - {
           'pos1 - check(
-            mapping(nestedCrosses),
+            nestedCrosses,
             "cross[210].cross2[js].suffix",
             Right(nestedCrosses.cross("210").cross2("js").suffix)
           )
           'pos2 - check(
-            mapping(nestedCrosses),
+            nestedCrosses,
             "cross[211].cross2[jvm].suffix",
             Right(nestedCrosses.cross("211").cross2("jvm").suffix)
           )
diff --git a/core/src/test/scala/mill/util/TestEvaluator.scala b/core/src/test/scala/mill/util/TestEvaluator.scala
index be486d4d..2f6182d3 100644
--- a/core/src/test/scala/mill/util/TestEvaluator.scala
+++ b/core/src/test/scala/mill/util/TestEvaluator.scala
@@ -2,13 +2,12 @@ package mill.util
 
 import ammonite.ops.Path
 import mill.define.{Input, Target, Task}
-import mill.discover.{Discovered, Mirror}
 import mill.eval.{Evaluator, Result}
 import mill.util.Strict.Agg
-class TestEvaluator(mapping: Discovered.Mapping[_],
+class TestEvaluator(module: mill.Module,
                     workspacePath: Path,
                     basePath: Path){
-  val evaluator = new Evaluator(workspacePath, basePath, mapping, DummyLogger)
+  val evaluator = new Evaluator(workspacePath, basePath, module, DummyLogger)
 
   def apply[T](t: Task[T]): Either[Result.Failing, (T, Int)] = {
     val evaluated = evaluator.evaluate(Agg(t))
@@ -18,7 +17,7 @@ class TestEvaluator(mapping: Discovered.Mapping[_],
         Tuple2(
           evaluated.rawValues.head.asInstanceOf[Result.Success[T]].value,
           evaluated.evaluated.collect {
-            case t: Target[_] if mapping.targets.contains(t) && !t.isInstanceOf[Input[_]] => t
+            case t: Target[_] if module.targets.contains(t) && !t.isInstanceOf[Input[_]] => t
             case t: mill.define.Command[_]           => t
           }.size
         ))
diff --git a/core/src/test/scala/mill/util/TestUtil.scala b/core/src/test/scala/mill/util/TestUtil.scala
index ca6097a1..c0985c97 100644
--- a/core/src/test/scala/mill/util/TestUtil.scala
+++ b/core/src/test/scala/mill/util/TestUtil.scala
@@ -13,7 +13,7 @@ object TestUtil {
                    millName0: sourcecode.Name,
                    overrides: Overrides)
     extends Module()(
-      Module.Ctx.make(
+      mill.define.Ctx.make(
         implicitly,
         implicitly,
         implicitly,
@@ -26,7 +26,7 @@ object TestUtil {
 
     def anon(inputs: Task[Int]*) = new Test(inputs)
     def apply(inputs: Task[Int]*)
-            (implicit ctx: Module.Ctx)= {
+            (implicit ctx: mill.define.Ctx)= {
       new TestTarget(inputs, pure = inputs.nonEmpty)
     }
   }
@@ -49,7 +49,7 @@ object TestUtil {
     */
   class TestTarget(inputs: Seq[Task[Int]],
                    val pure: Boolean)
-                  (implicit ctx0: Module.Ctx)
+                  (implicit ctx0: mill.define.Ctx)
     extends Test(inputs) with Target[Int]{
     val ctx = ctx0.copy(segments0 = ctx0.segments0 ++ Seq(ctx0.segment))
     val readWrite = upickle.default.IntRW
diff --git a/integration/src/test/resources/jawn/build.sc b/integration/src/test/resources/jawn/build.sc
index e76437b7..b57227e7 100644
--- a/integration/src/test/resources/jawn/build.sc
+++ b/integration/src/test/resources/jawn/build.sc
@@ -33,7 +33,7 @@ class JawnModule(crossVersion: String) extends mill.Module{
     def projectDeps = Seq(parser, util)
     def testProjectDeps = Seq(parser.test, util.test)
   }
-  class Support(ivyDeps0: Dep*)(implicit ctx: mill.Module.Ctx) extends JawnModule{
+  class Support(ivyDeps0: Dep*)(implicit ctx: mill.mill.define.Ctx) extends JawnModule{
     def projectDeps = Seq[Module](parser)
     def ivyDeps = Agg.from(ivyDeps0)
   }