Remove useless type parameters for {Test,}Evaluator (#416)

* Remove useless type parameters for {Test,}Evaluator

* Update Evaluator.scala

6 files changed, 39 insertions, 39 deletions

diff --git a/main/core/src/mill/eval/Evaluator.scala b/main/core/src/mill/eval/Evaluator.scala
index 34e1cf6f..ded4afdd 100644
--- a/main/core/src/mill/eval/Evaluator.scala
+++ b/main/core/src/mill/eval/Evaluator.scala
@@ -28,14 +28,15 @@ case class Labelled[T](task: NamedTask[T],
     case _ => None
   }
 }
-case class Evaluator[T](home: Path,
-                        outPath: Path,
-                        externalOutPath: Path,
-                        rootModule: mill.define.BaseModule,
-                        log: Logger,
-                        classLoaderSig: Seq[(Either[String, Path], Long)] = Evaluator.classLoaderSig,
-                        workerCache: mutable.Map[Segments, (Int, Any)] = mutable.Map.empty,
-                        env : Map[String, String] = Evaluator.defaultEnv){
+
+case class Evaluator(home: Path,
+                     outPath: Path,
+                     externalOutPath: Path,
+                     rootModule: mill.define.BaseModule,
+                     log: Logger,
+                     classLoaderSig: Seq[(Either[String, Path], Long)] = Evaluator.classLoaderSig,
+                     workerCache: mutable.Map[Segments, (Int, Any)] = mutable.Map.empty,
+                     env : Map[String, String] = Evaluator.defaultEnv){
   val classLoaderSignHash = classLoaderSig.hashCode()
   def evaluate(goals: Agg[Task[_]]): Evaluator.Results = {
     mkdir(outPath)
@@ -361,7 +362,7 @@ object Evaluator{
   // the TargetScopt#read call, which does not accept additional parameters.
   // Until we migrate our CLI parsing off of Scopt (so we can pass the BaseModule
   // in directly) we are forced to pass it in via a ThreadLocal
-  val currentEvaluator = new ThreadLocal[mill.eval.Evaluator[_]]
+  val currentEvaluator = new ThreadLocal[mill.eval.Evaluator]
 
   val defaultEnv: Map[String, String] = System.getenv().asScala.toMap
 
diff --git a/main/src/mill/main/MainModule.scala b/main/src/mill/main/MainModule.scala
index 67e8fa21..834d5609 100644
--- a/main/src/mill/main/MainModule.scala
+++ b/main/src/mill/main/MainModule.scala
@@ -10,14 +10,14 @@ import mill.util.{Ctx, PrintLogger, Watched}
 import pprint.{Renderer, Truncated}
 import upickle.Js
 object MainModule{
-  def resolveTasks[T](evaluator: Evaluator[Any], targets: Seq[String], multiSelect: Boolean)
+  def resolveTasks[T](evaluator: Evaluator, targets: Seq[String], multiSelect: Boolean)
                      (f: List[NamedTask[Any]] => T) = {
     RunScript.resolveTasks(mill.main.ResolveTasks, evaluator, targets, multiSelect) match{
       case Left(err) => Result.Failure(err)
       case Right(tasks) => Result.Success(f(tasks))
     }
   }
-  def evaluateTasks[T](evaluator: Evaluator[Any], targets: Seq[String], multiSelect: Boolean)
+  def evaluateTasks[T](evaluator: Evaluator, targets: Seq[String], multiSelect: Boolean)
                       (f: Seq[(Any, Option[Js.Value])] => T) = {
     RunScript.evaluateTasks(evaluator, targets, multiSelect) match{
       case Left(err) => Result.Failure(err)
@@ -45,7 +45,7 @@ trait MainModule extends mill.Module{
   /**
     * Resolves a mill query string and prints out the tasks it resolves to.
     */
-  def resolve(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+  def resolve(evaluator: Evaluator, targets: String*) = mill.T.command{
     val resolved = RunScript.resolveTasks(
       mill.main.ResolveMetadata, evaluator, targets, multiSelect = true
     )
@@ -64,7 +64,7 @@ trait MainModule extends mill.Module{
     * Given a set of tasks, prints out the execution plan of what tasks will be
     * executed in what order, without actually executing them.
     */
-  def plan(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+  def plan(evaluator: Evaluator, targets: String*) = mill.T.command{
     plan0(evaluator, targets) match{
       case Right(success) => {
         val renderedTasks = success.map{ _.segments.render}
@@ -75,7 +75,7 @@ trait MainModule extends mill.Module{
     }
   }
 
-  private def plan0(evaluator: Evaluator[Any], targets: Seq[String]) = {
+  private def plan0(evaluator: Evaluator, targets: Seq[String]) = {
     RunScript.resolveTasks(
       mill.main.ResolveTasks, evaluator, targets, multiSelect = true
     ) match {
@@ -92,7 +92,7 @@ trait MainModule extends mill.Module{
     * If there are multiple dependency paths between `src` and `dest`, the path
     * chosen is arbitrary.
     */
-  def path(evaluator: Evaluator[Any], src: String, dest: String) = mill.T.command{
+  def path(evaluator: Evaluator, src: String, dest: String) = mill.T.command{
     val resolved = RunScript.resolveTasks(
       mill.main.ResolveTasks, evaluator, List(src, dest), multiSelect = true
     )
@@ -133,7 +133,7 @@ trait MainModule extends mill.Module{
   /**
     * Displays metadata about the given task without actually running it.
     */
-  def inspect(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+  def inspect(evaluator: Evaluator, targets: String*) = mill.T.command{
     MainModule.resolveTasks(evaluator, targets, multiSelect = true){ tasks =>
       for{
         task <- tasks
@@ -159,7 +159,7 @@ trait MainModule extends mill.Module{
     *
     *
     */
-  def all(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+  def all(evaluator: Evaluator, targets: String*) = mill.T.command{
     MainModule.evaluateTasks(evaluator, targets, multiSelect = true) {res =>
       res.flatMap(_._2)
     }
@@ -169,7 +169,7 @@ trait MainModule extends mill.Module{
     * Runs a given task and prints the JSON result to stdout. This is useful
     * to integrate Mill into external scripts and tooling.
     */
-  def show(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+  def show(evaluator: Evaluator, targets: String*) = mill.T.command{
     MainModule.evaluateTasks(
       evaluator.copy(
         // When using `show`, redirect all stdout of the evaluated tasks so the
@@ -192,7 +192,7 @@ trait MainModule extends mill.Module{
     * Deletes the given targets from the out directory. Providing no targets
     * will clean everything.
     */
-  def clean(evaluator: Evaluator[Any], targets: String*) = mill.T.command {
+  def clean(evaluator: Evaluator, targets: String*) = mill.T.command {
     val rootDir = ammonite.ops.pwd / OutDir
 
     val KeepPattern = "(mill-.+)".r.anchored
@@ -222,11 +222,11 @@ trait MainModule extends mill.Module{
     }
   }
 
-  def visualize(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+  def visualize(evaluator: Evaluator, targets: String*) = mill.T.command{
     visualize0(evaluator, targets, T.ctx(), mill.main.VisualizeModule.worker())
   }
 
-  def visualizePlan(evaluator: Evaluator[Any], targets: String*) = mill.T.command{
+  def visualizePlan(evaluator: Evaluator, targets: String*) = mill.T.command{
     plan0(evaluator, targets) match {
       case Left(err) => Result.Failure(err)
       case Right(planResults) => visualize0(
@@ -238,7 +238,7 @@ trait MainModule extends mill.Module{
   private type VizWorker = (LinkedBlockingQueue[(scala.Seq[_], scala.Seq[_], Path)],
     LinkedBlockingQueue[Result[scala.Seq[PathRef]]])
 
-  private def visualize0(evaluator: Evaluator[Any], targets: Seq[String], ctx: Ctx, vizWorker: VizWorker,
+  private def visualize0(evaluator: Evaluator, targets: Seq[String], ctx: Ctx, vizWorker: VizWorker,
                          planTasks: Option[List[NamedTask[_]]] = None) = {
     def callVisualizeModule(rs: List[NamedTask[Any]], allRs: List[NamedTask[Any]]) = {
       val (in, out) = vizWorker
diff --git a/main/src/mill/main/MainScopts.scala b/main/src/mill/main/MainScopts.scala
index 3d627ef9..5cc4d7ba 100644
--- a/main/src/mill/main/MainScopts.scala
+++ b/main/src/mill/main/MainScopts.scala
@@ -23,9 +23,9 @@ object Tasks{
 }
 
 class EvaluatorScopt[T]()
-  extends scopt.Read[mill.eval.Evaluator[T]]{
+  extends scopt.Read[mill.eval.Evaluator]{
   def arity = 0
   def reads = s => try{
-    Evaluator.currentEvaluator.get.asInstanceOf[mill.eval.Evaluator[T]]
+    Evaluator.currentEvaluator.get.asInstanceOf[mill.eval.Evaluator]
   }
 }
diff --git a/main/src/mill/main/ReplApplyHandler.scala b/main/src/mill/main/ReplApplyHandler.scala
index 9070e614..c40b82c9 100644
--- a/main/src/mill/main/ReplApplyHandler.scala
+++ b/main/src/mill/main/ReplApplyHandler.scala
@@ -35,7 +35,7 @@ object ReplApplyHandler{
       )
     )
   }
-  def pprintCross(c: mill.define.Cross[_], evaluator: Evaluator[_]) = {
+  def pprintCross(c: mill.define.Cross[_], evaluator: Evaluator) = {
     pprint.Tree.Lazy( ctx =>
       Iterator(c.millOuterCtx.enclosing , ":", c.millOuterCtx.lineNum.toString, ctx.applyPrefixColor("\nChildren:").toString) ++
         c.items.iterator.map(x =>
@@ -43,7 +43,7 @@ object ReplApplyHandler{
         )
     )
   }
-  def pprintModule(m: mill.define.Module, evaluator: Evaluator[_]) = {
+  def pprintModule(m: mill.define.Module, evaluator: Evaluator) = {
     pprint.Tree.Lazy( ctx =>
       Iterator(m.millInternal.millModuleEnclosing, ":", m.millInternal.millModuleLine.toString) ++
         (if (m.millInternal.reflectAll[mill.Module].isEmpty) Nil
@@ -69,7 +69,7 @@ object ReplApplyHandler{
 
     )
   }
-  def pprintTask(t: NamedTask[_], evaluator: Evaluator[_]) = {
+  def pprintTask(t: NamedTask[_], evaluator: Evaluator) = {
     val seen = mutable.Set.empty[Task[_]]
     def rec(t: Task[_]): Seq[Segments] = {
       if (seen(t)) Nil // do nothing
@@ -91,7 +91,7 @@ object ReplApplyHandler{
 
 }
 class ReplApplyHandler(pprinter0: pprint.PPrinter,
-                       val evaluator: Evaluator[_]) extends ApplyHandler[Task] {
+                       val 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
diff --git a/main/src/mill/main/RunScript.scala b/main/src/mill/main/RunScript.scala
index 648f0447..1c8503fe 100644
--- a/main/src/mill/main/RunScript.scala
+++ b/main/src/mill/main/RunScript.scala
@@ -31,7 +31,7 @@ object RunScript{
                 stateCache: Option[Evaluator.State],
                 log: Logger,
                 env : Map[String, String])
-  : (Res[(Evaluator[Any], Seq[PathRef], Either[String, Seq[Js.Value]])], Seq[(Path, Long)]) = {
+  : (Res[(Evaluator, Seq[PathRef], Either[String, Seq[Js.Value]])], Seq[(Path, Long)]) = {
 
     val (evalState, interpWatched) = stateCache match{
       case Some(s) if watchedSigUnchanged(s.watched) => Res.Success(s) -> s.watched
@@ -54,7 +54,7 @@ object RunScript{
 
     val evalRes =
       for(s <- evalState)
-      yield new Evaluator[Any](home, wd / 'out, wd / 'out, s.rootModule, log,
+      yield new Evaluator(home, wd / 'out, wd / 'out, s.rootModule, log,
         s.classLoaderSig, s.workerCache, env)
 
     val evaluated = for{
@@ -120,7 +120,7 @@ object RunScript{
   }
 
   def resolveTasks[T, R: ClassTag](resolver: mill.main.Resolve[R],
-                                   evaluator: Evaluator[T],
+                                   evaluator: Evaluator,
                                    scriptArgs: Seq[String],
                                    multiSelect: Boolean) = {
     for {
@@ -155,7 +155,7 @@ object RunScript{
     } yield res.flatten
   }
 
-  def resolveRootModule[T](evaluator: Evaluator[T], scopedSel: Option[Segments]) = {
+  def resolveRootModule[T](evaluator: Evaluator, scopedSel: Option[Segments]) = {
     scopedSel match {
       case None => Right(evaluator.rootModule)
       case Some(scoping) =>
@@ -171,7 +171,7 @@ object RunScript{
     }
   }
 
-  def prepareResolve[T](evaluator: Evaluator[T], scopedSel: Option[Segments], sel: Segments) = {
+  def prepareResolve[T](evaluator: Evaluator, scopedSel: Option[Segments], sel: Segments) = {
     for (rootModule<- resolveRootModule(evaluator, scopedSel))
     yield {
       val crossSelectors = sel.value.map {
@@ -182,7 +182,7 @@ object RunScript{
     }
   }
 
-  def evaluateTasks[T](evaluator: Evaluator[T],
+  def evaluateTasks[T](evaluator: Evaluator,
                        scriptArgs: Seq[String],
                        multiSelect: Boolean) = {
     for (targets <- resolveTasks(mill.main.ResolveTasks, evaluator, scriptArgs, multiSelect)) yield {
@@ -198,7 +198,7 @@ object RunScript{
     }
   }
 
-  def evaluate(evaluator: Evaluator[_],
+  def evaluate(evaluator: Evaluator,
                targets: Agg[Task[Any]]): (Seq[PathRef], Either[String, Seq[(Any, Option[upickle.Js.Value])]]) = {
     val evaluated = evaluator.evaluate(targets)
     val watched = evaluated.results
diff --git a/main/test/src/mill/util/TestEvaluator.scala b/main/test/src/mill/util/TestEvaluator.scala
index d62e921c..1a114947 100644
--- a/main/test/src/mill/util/TestEvaluator.scala
+++ b/main/test/src/mill/util/TestEvaluator.scala
@@ -13,13 +13,12 @@ object TestEvaluator{
   val externalOutPath = pwd / 'target / 'external
 
 
-  def static[T <: TestUtil.BaseModule](module: T)
-                                     (implicit fullName: sourcecode.FullName) = {
-    new TestEvaluator[T](module)(fullName, TestPath(Nil))
+  def static(module: TestUtil.BaseModule)(implicit fullName: sourcecode.FullName) = {
+    new TestEvaluator(module)(fullName, TestPath(Nil))
   }
 }
 
-class TestEvaluator[T <: TestUtil.BaseModule](module: T)
+class TestEvaluator(module: TestUtil.BaseModule)
                                             (implicit fullName: sourcecode.FullName,
                                              tp: TestPath){
   val outPath =  TestUtil.getOutPath()