DRY up test suite by making `Discover` generation implicit

Also avoid passing around `Discover` and `Evaluator` together, since the latter already contains the former

17 files changed, 83 insertions, 97 deletions

diff --git a/core/src/mill/define/Discover.scala b/core/src/mill/define/Discover.scala
index 5e0e9a05..ab2ba900 100644
--- a/core/src/mill/define/Discover.scala
+++ b/core/src/mill/define/Discover.scala
@@ -8,11 +8,11 @@ import scala.reflect.macros.blackbox
 
 
 
-case class Discover(value: Map[Class[_], Seq[(Int, EntryPoint[_])]])
+case class Discover[T](value: Map[Class[_], Seq[(Int, EntryPoint[_])]])
 object Discover {
-  def apply[T]: Discover = macro applyImpl[T]
+  def apply[T]: Discover[T] = macro applyImpl[T]
 
-  def applyImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[Discover] = {
+  def applyImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Expr[Discover[T]] = {
     import c.universe._
     import compat._
     val seen = mutable.Set.empty[Type]
@@ -61,6 +61,6 @@ object Discover {
       q"$lhs -> $rhs"
     }
 
-    c.Expr[Discover](q"mill.define.Discover(scala.collection.immutable.Map(..$mapping))")
+    c.Expr[Discover[T]](q"mill.define.Discover(scala.collection.immutable.Map(..$mapping))")
   }
 }
diff --git a/core/src/mill/eval/Evaluator.scala b/core/src/mill/eval/Evaluator.scala
index d5c273d2..d248ce73 100644
--- a/core/src/mill/eval/Evaluator.scala
+++ b/core/src/mill/eval/Evaluator.scala
@@ -27,7 +27,7 @@ case class Labelled[T](target: NamedTask[T],
 class Evaluator[T](val workspacePath: Path,
                    val basePath: Path,
                    val rootModule: mill.Module,
-                   val discover: Discover,
+                   val discover: Discover[T],
                    log: Logger,
                    val classLoaderSig: Seq[(Path, Long)] = Evaluator.classLoaderSig){
 
diff --git a/core/src/mill/main/MainRunner.scala b/core/src/mill/main/MainRunner.scala
index 81450ba9..e098144f 100644
--- a/core/src/mill/main/MainRunner.scala
+++ b/core/src/mill/main/MainRunner.scala
@@ -24,7 +24,7 @@ class MainRunner(config: ammonite.main.Cli.Config,
     config, outprintStream, errPrintStream,
     stdIn, outprintStream, errPrintStream
   ){
-  var lastEvaluator: Option[(Seq[(Path, Long)], Evaluator[_], Discover)] = None
+  var lastEvaluator: Option[(Seq[(Path, Long)], Evaluator[Any])] = None
 
   override def runScript(scriptPath: Path, scriptArgs: List[String]) =
     watchLoop(
@@ -48,9 +48,9 @@ class MainRunner(config: ammonite.main.Cli.Config,
 
         result match{
           case Res.Success(data) =>
-            val (eval, discover, evaluationWatches, res) = data
+            val (eval, evaluationWatches, res) = data
 
-            lastEvaluator = Some((interpWatched, eval, discover))
+            lastEvaluator = Some((interpWatched, eval))
 
             (Res(res), interpWatched ++ evaluationWatches)
           case _ => (result, interpWatched)
@@ -95,7 +95,7 @@ class MainRunner(config: ammonite.main.Cli.Config,
          |  // even if it does nothing...
          |  def $$main() = Iterator[String]()
          |
-         |  implicit def millDiscover: mill.define.Discover = mill.define.Discover[this.type]
+         |  implicit def millDiscover: mill.define.Discover[this.type] = mill.define.Discover[this.type]
          |  // Need to wrap the returned Module in Some(...) to make sure it
          |  // doesn't get picked up during reflective child-module discovery
          |  val millSelf = Some(this)
@@ -103,7 +103,7 @@ class MainRunner(config: ammonite.main.Cli.Config,
          |
          |sealed trait $wrapName extends mill.Module{this: mill.define.BaseModule =>
          |
-         |  implicit def millDiscover: mill.define.Discover
+         |  implicit def millDiscover: mill.define.Discover[_]
          |""".stripMargin
     }
 
diff --git a/core/src/mill/main/ReplApplyHandler.scala b/core/src/mill/main/ReplApplyHandler.scala
index 9b3a29bb..40363be1 100644
--- a/core/src/mill/main/ReplApplyHandler.scala
+++ b/core/src/mill/main/ReplApplyHandler.scala
@@ -12,7 +12,7 @@ object ReplApplyHandler{
   def apply[T](colors: ammonite.util.Colors,
                pprinter0: pprint.PPrinter,
                rootModule: mill.Module,
-               discover: Discover) = {
+               discover: Discover[_]) = {
     new ReplApplyHandler(
       pprinter0,
       new mill.eval.Evaluator(
@@ -27,14 +27,12 @@ object ReplApplyHandler{
           System.err,
           System.err
         )
-      ),
-      discover
+      )
     )
   }
 }
 class ReplApplyHandler(pprinter0: pprint.PPrinter,
-                       evaluator: Evaluator[_],
-                       discover: Discover) extends ApplyHandler[Task] {
+                       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
@@ -83,7 +81,7 @@ class ReplApplyHandler(pprinter0: pprint.PPrinter,
         else
           ctx.applyPrefixColor("\nChildren:").toString +:
           m.millInternal.reflect[mill.Module].map("\n    ." + _.millOuterCtx.segments.render)) ++
-        (discover.value.get(m.getClass) match{
+        (evaluator.discover.value.get(m.getClass) match{
           case None => Nil
           case Some(commands) =>
             ctx.applyPrefixColor("\nCommands:").toString +: commands.map{c =>
diff --git a/core/src/mill/main/Resolve.scala b/core/src/mill/main/Resolve.scala
index d8c0ede0..42b9eeb8 100644
--- a/core/src/mill/main/Resolve.scala
+++ b/core/src/mill/main/Resolve.scala
@@ -8,7 +8,7 @@ import ammonite.main.Router.EntryPoint
 object Resolve {
   def resolve[T, V](remainingSelector: List[Segment],
                     obj: mill.Module,
-                    discover: Discover,
+                    discover: Discover[_],
                     rest: Seq[String],
                     remainingCrossSelectors: List[List[String]],
                     revSelectorsSoFar: List[Segment]): Either[String, Seq[Task[Any]]] = {
diff --git a/core/src/mill/main/RunScript.scala b/core/src/mill/main/RunScript.scala
index 29ba09dd..ce4e6835 100644
--- a/core/src/mill/main/RunScript.scala
+++ b/core/src/mill/main/RunScript.scala
@@ -24,15 +24,15 @@ object RunScript{
                 path: Path,
                 instantiateInterpreter: => Either[(Res.Failing, Seq[(Path, Long)]), ammonite.interp.Interpreter],
                 scriptArgs: Seq[String],
-                lastEvaluator: Option[(Seq[(Path, Long)], Evaluator[_], Discover)],
+                lastEvaluator: Option[(Seq[(Path, Long)], Evaluator[Any])],
                 log: Logger)
-  : (Res[(Evaluator[_], Discover, Seq[(Path, Long)], Either[String, Seq[Js.Value]])], Seq[(Path, Long)]) = {
+  : (Res[(Evaluator[Any], Seq[(Path, Long)], Either[String, Seq[Js.Value]])], Seq[(Path, Long)]) = {
 
     val (evalRes, interpWatched) = lastEvaluator match{
-      case Some((prevInterpWatchedSig, prevEvaluator, prevDiscover))
+      case Some((prevInterpWatchedSig, prevEvaluator))
         if watchedSigUnchanged(prevInterpWatchedSig) =>
 
-        (Res.Success(prevEvaluator -> prevDiscover), prevInterpWatchedSig)
+        (Res.Success(prevEvaluator), prevInterpWatchedSig)
 
       case _ =>
         instantiateInterpreter match{
@@ -41,20 +41,18 @@ object RunScript{
             interp.watch(path)
             val eval =
               for((mapping, discover) <- evaluateMapping(wd, path, interp))
-              yield (
-                new Evaluator(
-                  wd / 'out, wd, mapping, discover, log,
-                  mapping.getClass.getClassLoader.asInstanceOf[SpecialClassLoader].classpathSignature
-                ),
-                discover
+              yield new Evaluator[Any](
+                wd / 'out, wd, mapping, discover, log,
+                mapping.getClass.getClassLoader.asInstanceOf[SpecialClassLoader].classpathSignature
               )
+
             (eval, interp.watchedFiles)
         }
     }
 
     val evaluated = for{
-      (evaluator, discover) <- evalRes
-      (evalWatches, res) <- Res(evaluateTarget(evaluator, discover, scriptArgs))
+      evaluator <- evalRes
+      (evalWatches, res) <- Res(evaluateTarget(evaluator, scriptArgs))
     } yield {
       val alreadyStale = evalWatches.exists(p => p.sig != new PathRef(p.path, p.quick).sig)
       // If the file changed between the creation of the original
@@ -67,7 +65,7 @@ object RunScript{
         if (alreadyStale) evalWatches.map(_.path -> util.Random.nextLong())
         else evalWatches.map(p => p.path -> Interpreter.pathSignature(p.path))
 
-      (evaluator, discover, evaluationWatches, res.map(_.flatMap(_._2)))
+      (evaluator, evaluationWatches, res.map(_.flatMap(_._2)))
     }
     (evaluated, interpWatched)
   }
@@ -78,7 +76,7 @@ object RunScript{
 
   def evaluateMapping(wd: Path,
                       path: Path,
-                      interp: ammonite.interp.Interpreter): Res[(mill.Module, Discover)] = {
+                      interp: ammonite.interp.Interpreter): Res[(mill.Module, Discover[Any])] = {
 
     val (pkg, wrapper) = Util.pathToPackageWrapper(Seq(), path relativeTo wd)
 
@@ -121,7 +119,7 @@ object RunScript{
           Res.Success(
             buildCls.getMethod("millDiscover")
                     .invoke(module)
-                    .asInstanceOf[Discover]
+                    .asInstanceOf[Discover[Any]]
           )
         }
       } catch {
@@ -131,8 +129,7 @@ object RunScript{
     } yield (module, discover)
   }
 
-  def evaluateTarget[T](evaluator: Evaluator[_],
-                        discover: Discover,
+  def evaluateTarget[T](evaluator: Evaluator[T],
                         scriptArgs: Seq[String]) = {
     for {
       parsed <- ParseArgs(scriptArgs)
@@ -145,7 +142,7 @@ object RunScript{
           }
           mill.main.Resolve.resolve(
             sel, evaluator.rootModule,
-            discover,
+            evaluator.discover,
             args, crossSelectors, Nil
           )
         }
diff --git a/core/test/src/mill/define/CacherTests.scala b/core/test/src/mill/define/CacherTests.scala
index 20e2be2c..60216c2e 100644
--- a/core/test/src/mill/define/CacherTests.scala
+++ b/core/test/src/mill/define/CacherTests.scala
@@ -7,6 +7,7 @@ import mill.T
 import mill.eval.Result.Success
 import utest._
 import utest.framework.TestPath
+import mill.util.TestEvaluator.implicitDisover
 
 object CacherTests extends TestSuite{
   object Base extends Base
@@ -25,9 +26,8 @@ object CacherTests extends TestSuite{
   }
 
   val tests = Tests{
-
-
-    def eval[V](mapping: mill.Module, discover: Discover, v: Task[V])(implicit tp: TestPath) = {
+    def eval[T <: mill.Module, V](mapping: T, v: Task[V])
+                                 (implicit discover: Discover[T], tp: TestPath) = {
       val workspace = ammonite.ops.pwd / 'target / 'workspace / tp.value
       val evaluator = new Evaluator(workspace, ammonite.ops.pwd, mapping, discover, DummyLogger)
       evaluator.evaluate(Agg(v)).values(0)
@@ -35,28 +35,28 @@ object CacherTests extends TestSuite{
 
     'simpleDefIsCached - assert(
       Base.value eq Base.value,
-      eval(Base, Discover[Base.type], Base.value) == 1
+      eval(Base, Base.value) == 1
     )
 
     'resultDefIsCached - assert(
       Base.result eq Base.result,
-      eval(Base, Discover[Base.type], Base.result) == 1
+      eval(Base, Base.result) == 1
     )
 
 
     'overridingDefIsAlsoCached - assert(
-      eval(Middle, Discover[Middle.type], Middle.value) == 3,
+      eval(Middle, Middle.value) == 3,
       Middle.value eq Middle.value
     )
 
     'overridenDefRemainsAvailable - assert(
-      eval(Middle, Discover[Middle.type], Middle.overriden) == 1
+      eval(Middle, Middle.overriden) == 1
     )
 
 
     'multipleOverridesWork- assert(
-      eval(Terminal, Discover[Terminal.type], Terminal.value) == 7,
-      eval(Terminal, Discover[Terminal.type], 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/test/src/mill/eval/CrossTests.scala b/core/test/src/mill/eval/CrossTests.scala
index 6ee48790..6c369cc0 100644
--- a/core/test/src/mill/eval/CrossTests.scala
+++ b/core/test/src/mill/eval/CrossTests.scala
@@ -1,9 +1,10 @@
 package mill.eval
 
 import ammonite.ops._
-import mill.T
+
 import mill.define.Discover
 import mill.util.TestEvaluator
+import mill.util.TestEvaluator.implicitDisover
 import mill.util.TestGraphs.{crossResolved, doubleCross, nestedCrosses, singleCross}
 import utest._
 
@@ -12,7 +13,6 @@ object CrossTests extends TestSuite{
     'singleCross - {
       val check = new TestEvaluator(
         singleCross,
-        Discover[singleCross.type],
         pwd / 'target / 'workspace / "cross-tests" / "inputs",
         pwd
       )
@@ -25,7 +25,6 @@ object CrossTests extends TestSuite{
     'crossResolved - {
       val check = new TestEvaluator(
         crossResolved,
-        Discover[crossResolved.type],
         pwd / 'target / 'workspace / "cross-tests" / "crossResolved",
         pwd
       )
@@ -43,7 +42,6 @@ object CrossTests extends TestSuite{
     'doubleCross - {
       val check = new TestEvaluator(
         doubleCross,
-        Discover[doubleCross.type],
         pwd / 'target / 'workspace / "cross-tests" / "doubleCross",
         pwd
       )
@@ -60,7 +58,6 @@ object CrossTests extends TestSuite{
     'nestedCrosses - {
       val check = new TestEvaluator(
         nestedCrosses,
-        Discover[nestedCrosses.type],
         pwd / 'target / 'workspace / "cross-tests" / "nestedCrosses",
         pwd
       )
diff --git a/core/test/src/mill/eval/EvaluationTests.scala b/core/test/src/mill/eval/EvaluationTests.scala
index 563a2428..eb0c30c6 100644
--- a/core/test/src/mill/eval/EvaluationTests.scala
+++ b/core/test/src/mill/eval/EvaluationTests.scala
@@ -8,9 +8,10 @@ import mill.util.{DummyLogger, TestGraphs, TestUtil}
 import mill.util.Strict.Agg
 import utest._
 import utest.framework.TestPath
+import mill.util.TestEvaluator.implicitDisover
 
 object EvaluationTests extends TestSuite{
-  class Checker(module: mill.Module, discover: Discover)(implicit tp: TestPath) {
+  class Checker[T <: mill.Module](module: T)(implicit tp: TestPath, discover: Discover[T]) {
     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
@@ -58,7 +59,7 @@ object EvaluationTests extends TestSuite{
 
       'singleton - {
         import singleton._
-        val check = new Checker(singleton, Discover[singleton.type])
+        val check = new Checker(singleton)
         // First time the target is evaluated
         check(single, expValue = 0, expEvaled = Agg(single))
 
@@ -68,7 +69,7 @@ object EvaluationTests extends TestSuite{
       }
       'pair - {
         import pair._
-        val check = new Checker(pair, Discover[pair.type])
+        val check = new Checker(pair)
         check(down, expValue = 0, expEvaled = Agg(up, down))
 
         down.counter += 1
@@ -79,7 +80,7 @@ object EvaluationTests extends TestSuite{
       }
       'anonTriple - {
         import anonTriple._
-        val check = new Checker(anonTriple, Discover[anonTriple.type])
+        val check = new Checker(anonTriple)
         val middle = down.inputs(0)
         check(down, expValue = 0, expEvaled = Agg(up, middle, down))
 
@@ -95,7 +96,7 @@ object EvaluationTests extends TestSuite{
       }
       'diamond - {
         import diamond._
-        val check = new Checker(diamond, Discover[diamond.type])
+        val check = new Checker(diamond)
         check(down, expValue = 0, expEvaled = Agg(up, left, right, down))
 
         down.counter += 1
@@ -113,7 +114,7 @@ object EvaluationTests extends TestSuite{
       }
       'anonDiamond - {
         import anonDiamond._
-        val check = new Checker(anonDiamond, Discover[anonDiamond.type])
+        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))
@@ -134,7 +135,7 @@ object EvaluationTests extends TestSuite{
 
       'bigSingleTerminal - {
         import bigSingleTerminal._
-        val check = new Checker(bigSingleTerminal, Discover[bigSingleTerminal.type])
+        val check = new Checker(bigSingleTerminal)
 
         check(j, expValue = 0, expEvaled = Agg(a, b, e, f, i, j), extraEvaled = 22)
 
@@ -157,7 +158,7 @@ object EvaluationTests extends TestSuite{
         // even though one depends on the other
 
         import separateGroups._
-        val checker = new Checker(separateGroups, Discover[separateGroups.type])
+        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))
@@ -174,7 +175,7 @@ object EvaluationTests extends TestSuite{
       'triangleTask - {
 
         import triangleTask._
-        val checker = new Checker(triangleTask, Discover[triangleTask.type])
+        val checker = new Checker(triangleTask)
         checker(right, 3, Agg(left, right), extraEvaled = -1)
         checker(left, 1, Agg(), extraEvaled = -1)
 
@@ -182,7 +183,7 @@ object EvaluationTests extends TestSuite{
       'multiTerminalGroup - {
         import multiTerminalGroup._
 
-        val checker = new Checker(multiTerminalGroup, Discover[multiTerminalGroup.type])
+        val checker = new Checker(multiTerminalGroup)
         checker(right, 1, Agg(right), extraEvaled = -1)
         checker(left, 1, Agg(left), extraEvaled = -1)
       }
@@ -191,7 +192,7 @@ object EvaluationTests extends TestSuite{
 
         import multiTerminalBoundary._
 
-        val checker = new Checker(multiTerminalBoundary, Discover[multiTerminalBoundary.type])
+        val checker = new Checker(multiTerminalBoundary)
         checker(task2, 4, Agg(right, left), extraEvaled = -1, secondRunNoOp = false)
         checker(task2, 4, Agg(), extraEvaled = -1, secondRunNoOp = false)
       }
@@ -202,7 +203,7 @@ object EvaluationTests extends TestSuite{
         // the main publically-available target
         import canOverrideSuper._
 
-        val checker = new Checker(canOverrideSuper, Discover[canOverrideSuper.type])
+        val checker = new Checker(canOverrideSuper)
         checker(foo, Seq("base", "object"), Agg(foo), extraEvaled = -1)
 
 
@@ -224,7 +225,7 @@ object EvaluationTests extends TestSuite{
         // the main publically-available command
         import canOverrideSuper._
 
-        val checker = new Checker(canOverrideSuper, Discover[canOverrideSuper.type])
+        val checker = new Checker(canOverrideSuper)
         val runCmd = cmd(1)
         checker(
           runCmd,
@@ -280,7 +281,7 @@ object EvaluationTests extends TestSuite{
 
         // During the first evaluation, they get computed normally like any
         // cached target
-        val check = new Checker(build, Discover[build.type])
+        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/test/src/mill/eval/FailureTests.scala b/core/test/src/mill/eval/FailureTests.scala
index 7d0d6421..6a9b684f 100644
--- a/core/test/src/mill/eval/FailureTests.scala
+++ b/core/test/src/mill/eval/FailureTests.scala
@@ -5,13 +5,13 @@ import mill.util.DummyLogger
 import mill.util.Strict.Agg
 import utest._
 import utest.framework.TestPath
-
+import mill.util.TestEvaluator.implicitDisover
 object FailureTests extends TestSuite{
 
   def workspace(implicit tp: TestPath) = {
     ammonite.ops.pwd / 'target / 'workspace / 'failure / implicitly[TestPath].value
   }
-  class Checker(module: mill.Module, discover: Discover)(implicit tp: TestPath){
+  class Checker[T <: mill.Module](module: T)(implicit tp: TestPath, discover: Discover[T]){
 
     val evaluator = new Evaluator(workspace, ammonite.ops.pwd, module, discover, DummyLogger)
 
@@ -37,7 +37,7 @@ object FailureTests extends TestSuite{
 
     'evaluateSingle - {
       ammonite.ops.rm(ammonite.ops.Path(workspace, ammonite.ops.pwd))
-      val check = new Checker(singleton, Discover[singleton.type])
+      val check = new Checker(singleton)
       check(
         target = singleton.single,
         expectedFailCount = 0,
@@ -73,7 +73,7 @@ object FailureTests extends TestSuite{
     }
     'evaluatePair - {
       ammonite.ops.rm(ammonite.ops.Path(workspace, ammonite.ops.pwd))
-      val check = new Checker(pair, Discover[pair.type])
+      val check = new Checker(pair)
       check(
         pair.down,
         expectedFailCount = 0,
diff --git a/core/test/src/mill/eval/TaskTests.scala b/core/test/src/mill/eval/TaskTests.scala
index 538b0c12..9d868006 100644
--- a/core/test/src/mill/eval/TaskTests.scala
+++ b/core/test/src/mill/eval/TaskTests.scala
@@ -3,7 +3,7 @@ package mill.eval
 import utest._
 import ammonite.ops._
 import mill.T
-import mill.define.Discover
+import mill.util.TestEvaluator.implicitDisover
 import mill.util.TestEvaluator
 object TaskTests extends TestSuite{
   val tests = Tests{
@@ -58,7 +58,6 @@ object TaskTests extends TestSuite{
       // to re-evaluate, but normal Tasks behind a Target run once then are cached
       val check = new TestEvaluator(
         build,
-        Discover[build.type],
         pwd / 'target / 'workspace / "task-tests" / "inputs",
         pwd
       )
@@ -76,7 +75,6 @@ object TaskTests extends TestSuite{
       // Persistent tasks keep the working dir around between runs
       val check = new TestEvaluator(
         build,
-        Discover[build.type],
         pwd / 'target / 'workspace / "task-tests" / "persistent",
         pwd
       )
@@ -93,7 +91,6 @@ object TaskTests extends TestSuite{
       // Persistent task
       def check = new TestEvaluator(
         build,
-        Discover[build.type],
         pwd / 'target / 'workspace / "task-tests" / "worker",
         pwd
       )
diff --git a/core/test/src/mill/main/MainTests.scala b/core/test/src/mill/main/MainTests.scala
index 96fd4448..3d8e4d5c 100644
--- a/core/test/src/mill/main/MainTests.scala
+++ b/core/test/src/mill/main/MainTests.scala
@@ -1,16 +1,15 @@
 package mill.main
 
-import mill.Module
 import mill.define.{Discover, Segment, Task}
 import mill.util.TestGraphs._
-import mill.util.TestUtil.test
+import mill.util.TestEvaluator.implicitDisover
 import utest._
 object MainTests extends TestSuite{
 
-  def check[T <: mill.Module](module: T,
-                              discover: Discover)(
+  def check[T <: mill.Module](module: T)(
                               selectorString: String,
-                              expected0: Either[String, Seq[T => Task[_]]]) = {
+                              expected0: Either[String, Seq[T => Task[_]]])
+                             (implicit discover: Discover[T])= {
 
     val expected = expected0.map(_.map(_(module)))
     val resolved = for{
@@ -24,14 +23,14 @@ object MainTests extends TestSuite{
     val graphs = new mill.util.TestGraphs()
     import graphs._
     'single - {
-      val check = MainTests.check(singleton, Discover[singleton.type]) _
+      val check = MainTests.check(singleton) _
       'pos - check("single", Right(Seq(_.single)))
       'neg1 - check("doesntExist", Left("Cannot resolve task doesntExist"))
       'neg2 - check("single.doesntExist", Left("Cannot resolve module single"))
       'neg3 - check("", Left("Selector cannot be empty"))
     }
     'nested - {
-      val check = MainTests.check(nestedModule, Discover[nestedModule.type]) _
+      val check = MainTests.check(nestedModule) _
       'pos1 - check("single", Right(Seq(_.single)))
       'pos2 - check("nested.single", Right(Seq(_.nested.single)))
       'pos3 - check("classInstance.single", Right(Seq(_.classInstance.single)))
@@ -74,7 +73,7 @@ object MainTests extends TestSuite{
     }
     'cross - {
       'single - {
-        val check = MainTests.check(singleCross, Discover[singleCross.type]) _
+        val check = MainTests.check(singleCross) _
         'pos1 - check("cross[210].suffix", Right(Seq(_.cross("210").suffix)))
         'pos2 - check("cross[211].suffix", Right(Seq(_.cross("211").suffix)))
         'neg1 - check("cross[210].doesntExist", Left("Cannot resolve task cross[210].doesntExist"))
@@ -98,7 +97,7 @@ object MainTests extends TestSuite{
         )
       }
       'double - {
-        val check = MainTests.check(doubleCross, Discover[doubleCross.type]) _
+        val check = MainTests.check(doubleCross) _
         'pos1 - check(
           "cross[210,jvm].suffix",
           Right(Seq(_.cross("210", "jvm").suffix))
@@ -172,7 +171,7 @@ object MainTests extends TestSuite{
         }
       }
       'nested - {
-        val check = MainTests.check(nestedCrosses, Discover[nestedCrosses.type]) _
+        val check = MainTests.check(nestedCrosses) _
         'pos1 - check(
           "cross[210].cross2[js].suffix",
           Right(Seq(_.cross("210").cross2("js").suffix))
diff --git a/core/test/src/mill/util/TestEvaluator.scala b/core/test/src/mill/util/TestEvaluator.scala
index 10483aae..465a891d 100644
--- a/core/test/src/mill/util/TestEvaluator.scala
+++ b/core/test/src/mill/util/TestEvaluator.scala
@@ -1,13 +1,18 @@
 package mill.util
 
 import ammonite.ops.Path
+import mill.define.Discover.applyImpl
 import mill.define.{Discover, Input, Target, Task}
 import mill.eval.{Evaluator, Result}
 import mill.util.Strict.Agg
-class TestEvaluator(module: mill.Module,
-                    discover: Discover,
-                    workspacePath: Path,
-                    basePath: Path){
+import language.experimental.macros
+object TestEvaluator{
+  implicit def implicitDisover[T]: Discover[T] = macro applyImpl[T]
+}
+class TestEvaluator[T <: TestUtil.BaseModule](module: T,
+                                              workspacePath: Path,
+                                              basePath: Path)
+                                             (implicit discover: Discover[T]){
   val evaluator = new Evaluator(workspacePath, basePath, module, discover, DummyLogger)
   //val evaluator = new Evaluator(workspacePath, basePath, module, new PrintLogger(true, ammonite.util.Colors.Default, System.out, System.out, System.err))
   def apply[T](t: Task[T]): Either[Result.Failing, (T, Int)] = {
diff --git a/scalajslib/test/src/mill/scalajslib/HelloJSWorldTests.scala b/scalajslib/test/src/mill/scalajslib/HelloJSWorldTests.scala
index d954619f..4cfe464d 100644
--- a/scalajslib/test/src/mill/scalajslib/HelloJSWorldTests.scala
+++ b/scalajslib/test/src/mill/scalajslib/HelloJSWorldTests.scala
@@ -11,7 +11,7 @@ import mill.scalalib.{DepSyntax, PublishModule, TestRunner}
 import mill.scalalib.publish.{Developer, License, PomSettings, SCM}
 import mill.util.{TestEvaluator, TestUtil}
 import utest._
-
+import mill.util.TestEvaluator.implicitDisover
 import scala.collection.JavaConverters._
 
 
@@ -58,7 +58,6 @@ object HelloJSWorldTests extends TestSuite {
 
   val helloWorldEvaluator = new TestEvaluator(
     HelloJSWorld,
-    Discover[HelloJSWorld.type],
     workspacePath,
     srcPath
   )
diff --git a/scalalib/src/mill/scalalib/GenIdea.scala b/scalalib/src/mill/scalalib/GenIdea.scala
index c48e3bc8..ea401b04 100644
--- a/scalalib/src/mill/scalalib/GenIdea.scala
+++ b/scalalib/src/mill/scalalib/GenIdea.scala
@@ -14,7 +14,7 @@ object GenIdea {
 
   def apply()(implicit ctx: LogCtx,
               rootModule0: BaseModule.Implicit,
-              discover: Discover): Unit = {
+              discover: Discover[_]): Unit = {
     val rootModule = rootModule0.value
     val pp = new scala.xml.PrettyPrinter(999, 4)
     rm! pwd/".idea"
diff --git a/scalalib/test/src/mill/scalalib/GenIdeaTests.scala b/scalalib/test/src/mill/scalalib/GenIdeaTests.scala
index ae5810df..58992e4f 100644
--- a/scalalib/test/src/mill/scalalib/GenIdeaTests.scala
+++ b/scalalib/test/src/mill/scalalib/GenIdeaTests.scala
@@ -5,7 +5,7 @@ import mill._
 import mill.define.Discover
 import mill.util.{TestEvaluator, TestUtil}
 import utest._
-
+import mill.util.TestEvaluator.implicitDisover
 object GenIdeaTests extends TestSuite {
 
   val basePath = pwd / 'target / 'workspace / "gen-idea"
@@ -21,7 +21,6 @@ object GenIdeaTests extends TestSuite {
 
   val helloWorldEvaluator = new TestEvaluator(
     HelloWorld,
-    Discover[HelloWorld.type],
     outPath,
     workingSrcPath
   )
diff --git a/scalalib/test/src/mill/scalalib/HelloWorldTests.scala b/scalalib/test/src/mill/scalalib/HelloWorldTests.scala
index 85e53703..06d650c1 100644
--- a/scalalib/test/src/mill/scalalib/HelloWorldTests.scala
+++ b/scalalib/test/src/mill/scalalib/HelloWorldTests.scala
@@ -10,7 +10,7 @@ import mill.eval.{Evaluator, Result}
 import mill.scalalib.publish._
 import mill.util.{TestEvaluator, TestUtil}
 import utest._
-
+import mill.util.TestEvaluator.implicitDisover
 import scala.collection.JavaConverters._
 
 
@@ -84,37 +84,31 @@ object HelloWorldTests extends TestSuite {
 
   val helloWorldEvaluator = new TestEvaluator(
     HelloWorld,
-    Discover[HelloWorld.type],
     outPath,
     workingSrcPath
   )
   val helloWorldWithMainEvaluator = new TestEvaluator(
     HelloWorldWithMain,
-    Discover[HelloWorldWithMain.type],
     outPath,
     workingSrcPath
   )
   val helloWorldWithMainAssemblyEvaluator = new TestEvaluator(
     HelloWorldWithMainAssembly,
-    Discover[HelloWorldWithMainAssembly.type],
     outPath,
     workingSrcPath
   )
   val helloWorldFatalEvaluator = new TestEvaluator(
     HelloWorldFatalWarnings,
-    Discover[HelloWorldFatalWarnings.type],
     outPath,
     workingSrcPath
   )
   val helloWorldOverrideEvaluator = new TestEvaluator(
     HelloWorldScalaOverride,
-    Discover[HelloWorldScalaOverride.type],
     outPath,
     workingSrcPath
   )
   val helloWorldCrossEvaluator = new TestEvaluator(
     CrossHelloWorld,
-    Discover[CrossHelloWorld.type],
     outPath,
     workingSrcPath
   )