DRY up test suite by making `Discover` generation implicit

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

6 files changed, 30 insertions, 35 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
           )
         }