DRY up test suite by making `Discover` generation implicit

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

7 files changed, 49 insertions, 50 deletions

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)] = {