Remove Ammonite as a dependency, handle script running and bootstrapping ourselves

.github/workflows/actions.yml

@@ -33,9 +33,19 @@ jobs:
           # unit and module tests
           - ./mill -i -k "{main,scalalib,scalajslib,scalanativelib,testrunner,bsp}.__.test"
           # additional integration tests
-          - ./mill -i -k "integration.{local,forked,forked-server}"
+          - ./mill -i -k "example.__.local.test"
+          - ./mill -i -k "example.__.fork.test"
+          - ./mill -i -k "example.__.server.test"
+          - ./mill -i -k "integration.feature.__.local.test"
+          - ./mill -i -k "integration.feature.__.fork.test"
+          - ./mill -i -k "integration.feature.__.server.test"
+          - ./mill -i -k "integration.failure.__.local.test"
+          - ./mill -i -k "integration.failure.__.fork.test"
+          - ./mill -i -k "integration.failure.__.server.test"
           # integration tests of thirdparty repos
-          - ./mill -i -k "integration.thirdparty.{local,forked}"
+          - ./mill -i -k "integration.thirdparty.__.local.test"
+          - ./mill -i -k "integration.thirdparty.__.fork.test"
+          - ./mill -i -k "integration.thirdparty.__.server.test"
           # contrib tests
           - ./mill -i -k "contrib._.test"
           - ./mill -i docs.antora.githubPages
@@ -108,8 +118,18 @@ jobs:
         buildcmd:
           - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "{__.publishLocal,assembly,__.compile}"
           - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "{main,scalalib,scalajslib,bsp}.__.test"
-          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.{local,forked,forked-server}"
-          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.thirdparty.{local,forked}"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "example.__.local.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "example.__.fork.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "example.__.server.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.feature.__.local.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.feature.__.fork.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.feature.__.server.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.failure.__.local.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.failure.__.fork.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.failure.__.server.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.thirdparty.__.local.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.thirdparty.__.fork.test"
+          - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "integration.thirdparty.__.server.test"
           - cmd /C %GITHUB_WORKSPACE%\ci\mill.bat -i -d -k "contrib.__.test"
 
 

bsp/src/mill/bsp/BSP.scala

@@ -9,11 +9,11 @@ import mill.define.{Command, Discover, ExternalModule, Task}
 import mill.eval.Evaluator
 import mill.main.{BspServerHandle, BspServerResult, BspServerStarter}
 import mill.scalalib.{CoursierModule, Dep}
-import mill.util.PrintLogger
+import mill.util.{PrintLogger, SystemStreams}
 import os.Path
 
 object BSP extends ExternalModule with CoursierModule with BspServerStarter {
-  implicit def millScoptEvaluatorReads[T] = new mill.main.EvaluatorScopt[T]()
+  import mill.main.TokenReaders._
 
   lazy val millDiscover: Discover[this.type] = Discover[this.type]
 
@@ -24,9 +24,11 @@ object BSP extends ExternalModule with CoursierModule with BspServerStarter {
   }
 
   private def bspWorkerLibs: T[Agg[PathRef]] = T {
-    resolveDeps(T.task {
-      bspWorkerIvyDeps().map(bindDependency())
-    })()
+    mill.modules.Util.millProjectModule(
+      "MILL_BSP_WORKER",
+      "mill-bsp-worker",
+      repositoriesTask()
+    )
   }
 
   /**
@@ -70,9 +72,7 @@ object BSP extends ExternalModule with CoursierModule with BspServerStarter {
 
   override def startBspServer(
       initialEvaluator: Option[Evaluator],
-      outStream: PrintStream,
-      errStream: PrintStream,
-      inStream: InputStream,
+      streams: SystemStreams,
       workspaceDir: os.Path,
       ammoniteHomeDir: os.Path,
       canReload: Boolean,
@@ -85,13 +85,13 @@ object BSP extends ExternalModule with CoursierModule with BspServerStarter {
       // This all goes to the BSP log file mill-bsp.stderr
       override def log: Logger = new Logger {
         override def colored: Boolean = false
-        override def errorStream: PrintStream = errStream
-        override def outputStream: PrintStream = errStream
+        override def errorStream: PrintStream = streams.err
+        override def outputStream: PrintStream = streams.err
         override def inStream: InputStream = DummyInputStream
-        override def info(s: String): Unit = errStream.println(s)
-        override def error(s: String): Unit = errStream.println(s)
-        override def ticker(s: String): Unit = errStream.println(s)
-        override def debug(s: String): Unit = errStream.println(s)
+        override def info(s: String): Unit = streams.err.println(s)
+        override def error(s: String): Unit = streams.err.println(s)
+        override def ticker(s: String): Unit = streams.err.println(s)
+        override def debug(s: String): Unit = streams.err.println(s)
         override def debugEnabled: Boolean = true
       }
     }
@@ -102,9 +102,7 @@ object BSP extends ExternalModule with CoursierModule with BspServerStarter {
       case Result.Success(worker) =>
         worker.startBspServer(
           initialEvaluator,
-          outStream,
-          errStream,
-          inStream,
+          streams,
           workspaceDir / Constants.bspDir,
           canReload,
           Seq(millServerHandle) ++ serverHandle.toSeq

bsp/src/mill/bsp/BspWorker.scala

@@ -5,6 +5,7 @@ import mill.api.{Ctx, PathRef, Result, internal}
 import mill.define.Task
 import mill.eval.Evaluator
 import mill.main.{BspServerHandle, BspServerResult}
+import mill.util.SystemStreams
 
 import java.io.{InputStream, PrintStream}
 import java.net.URL
@@ -21,9 +22,7 @@ trait BspWorker {
 
   def startBspServer(
       initialEvaluator: Option[Evaluator],
-      outStream: PrintStream,
-      errStream: PrintStream,
-      inStream: InputStream,
+      streams: SystemStreams,
       logDir: os.Path,
       canReload: Boolean,
       serverHandles: Seq[Promise[BspServerHandle]]

bsp/worker/src/mill/bsp/worker/BspWorkerImpl.scala

@@ -7,6 +7,7 @@ import mill.bsp.{BSP, BspWorker, Constants}
 import mill.define.Task
 import mill.eval.Evaluator
 import mill.main.{BspServerHandle, BspServerResult}
+import mill.util.SystemStreams
 import org.eclipse.lsp4j.jsonrpc.Launcher
 
 import java.io.{InputStream, PrintStream, PrintWriter}
@@ -62,9 +63,7 @@ class BspWorkerImpl() extends BspWorker {
 
   override def startBspServer(
       initialEvaluator: Option[Evaluator],
-      outStream: PrintStream,
-      errStream: PrintStream,
-      inStream: InputStream,
+      streams: SystemStreams,
       logDir: os.Path,
       canReload: Boolean,
       serverHandles: Seq[Promise[BspServerHandle]]
@@ -77,7 +76,7 @@ class BspWorkerImpl() extends BspWorker {
         bspVersion = Constants.bspProtocolVersion,
         serverVersion = MillBuildInfo.millVersion,
         serverName = Constants.serverName,
-        logStream = errStream,
+        logStream = streams.err,
         canReload = canReload
       ) with MillJvmBuildServer with MillJavaBuildServer with MillScalaBuildServer
 
@@ -87,8 +86,8 @@ class BspWorkerImpl() extends BspWorker {
 
     try {
       val launcher = new Launcher.Builder[BuildClient]()
-        .setOutput(outStream)
-        .setInput(inStream)
+        .setOutput(streams.out)
+        .setInput(streams.in)
         .setLocalService(millServer)
         .setRemoteInterface(classOf[BuildClient])
         .traceMessages(new PrintWriter(
@@ -112,22 +111,22 @@ class BspWorkerImpl() extends BspWorker {
           val onReload = Promise[BspServerResult]()
           millServer.onSessionEnd = Some { serverResult =>
             if (!onReload.isCompleted) {
-              errStream.println("Unsetting evaluator on session end")
+              streams.err.println("Unsetting evaluator on session end")
               millServer.updateEvaluator(None)
               _lastResult = Some(serverResult)
               onReload.success(serverResult)
             }
           }
           Await.result(onReload.future, Duration.Inf).tap { r =>
-            errStream.println(s"Reload finished, result: ${r}")
+            streams.err.println(s"Reload finished, result: ${r}")
             _lastResult = Some(r)
           }
         }
 
         override def lastResult: Option[BspServerResult] = _lastResult
 
         override def stop(): Unit = {
-          errStream.println("Stopping server via handle...")
+          streams.err.println("Stopping server via handle...")
           listening.cancel(true)
         }
       }
@@ -137,17 +136,17 @@ class BspWorkerImpl() extends BspWorker {
       ()
     } catch {
       case _: CancellationException =>
-        errStream.println("The mill server was shut down.")
+        streams.err.println("The mill server was shut down.")
       case e: Exception =>
-        errStream.println(
+        streams.err.println(
           s"""An exception occurred while connecting to the client.
              |Cause: ${e.getCause}
              |Message: ${e.getMessage}
              |Exception class: ${e.getClass}
              |Stack Trace: ${e.getStackTrace}""".stripMargin
         )
     } finally {
-      errStream.println("Shutting down executor")
+      streams.err.println("Shutting down executor")
       executor.shutdown()
 
     }

bsp/worker/src/mill/bsp/worker/MillBuildServer.scala

@@ -60,7 +60,8 @@ import mill.api.{DummyTestReporter, PathRef, Result, Strict, internal}
 import mill.define.Segment.Label
 import mill.define.{BaseModule, Discover, ExternalModule, Module, Segments, Task}
 import mill.eval.Evaluator
-import mill.main.{BspServerResult, EvaluatorScopt, MainModule}
+import mill.main.{BspServerResult, MainModule}
+import mill.main.TokenReaders._
 import mill.scalalib.{JavaModule, SemanticDbJavaModule, TestModule}
 import mill.scalalib.bsp.{BspModule, JvmBuildTarget, MillBuildModule, ScalaBuildTarget}
 import mill.scalalib.internal.ModuleUtils
@@ -85,8 +86,6 @@ class MillBuildServer(
 ) extends ExternalModule
     with BuildServer {
 
-  implicit def millScoptEvaluatorReads[T]: EvaluatorScopt[T] = new mill.main.EvaluatorScopt[T]()
-
   lazy val millDiscover: Discover[MillBuildServer.this.type] = Discover[this.type]
 
   var cancellator: Boolean => Unit = shutdownBefore => ()

ci/mill-bootstrap.patch

@@ -1,5 +1,5 @@
 diff --git a/build.sc b/build.sc
-index 3930b72ff..5cf3ee459 100644
+index 2ced447bf..af0244fd3 100644
 --- a/build.sc
 +++ b/build.sc
 @@ -2,22 +2,10 @@
@@ -9,7 +9,7 @@ index 3930b72ff..5cf3ee459 100644
 -import $ivy.`de.tototec::de.tobiasroeser.mill.vcs.version_mill0.10:0.3.0`
 -import $ivy.`com.github.lolgab::mill-mima_mill0.10:0.0.13`
  import $ivy.`net.sourceforge.htmlcleaner:htmlcleaner:2.25`
- 
+
  // imports
 -import com.github.lolgab.mill.mima
 -import com.github.lolgab.mill.mima.{
@@ -25,10 +25,10 @@ index 3930b72ff..5cf3ee459 100644
  import mill._
  import mill.define.{Command, Source, Sources, Target, Task}
  import mill.eval.Evaluator
-@@ -184,12 +172,8 @@ object Deps {
+@@ -178,12 +166,8 @@ object Deps {
    val requests = ivy"com.lihaoyi::requests:0.8.0"
  }
- 
+
 -def millVersion: T[String] = T { VcsVersion.vcsState().format() }
 -def millLastTag: T[String] = T {
 -  VcsVersion.vcsState().lastTag.getOrElse(
@@ -40,10 +40,10 @@ index 3930b72ff..5cf3ee459 100644
  def millBinPlatform: T[String] = T {
    val tag = millLastTag()
    if (tag.contains("-M")) tag
-@@ -248,20 +232,7 @@ trait MillCoursierModule extends CoursierModule {
+@@ -243,20 +227,7 @@ trait MillCoursierModule extends CoursierModule {
    )
  }
- 
+
 -trait MillMimaConfig extends mima.Mima {
 -  override def mimaPreviousVersions: T[Seq[String]] = Settings.mimaBaseVersions
 -  override def mimaPreviousArtifacts =
@@ -60,35 +60,44 @@ index 3930b72ff..5cf3ee459 100644
 -  lazy val issueFilterByModule: Map[MillMimaConfig, Seq[ProblemFilter]] = Map()
 +trait MillMimaConfig extends Module {
  }
- 
+
  /** A Module compiled with applied Mill-specific compiler plugins: mill-moduledefs. */
-@@ -661,6 +632,7 @@ object scalajslib extends MillModule {
+@@ -650,6 +621,7 @@ object scalajslib extends MillModule {
    }
    object worker extends Cross[WorkerModule]("1")
    class WorkerModule(scalajsWorkerVersion: String) extends MillInternalModule {
 +    override def millSourcePath: os.Path = super.millSourcePath / scalajsWorkerVersion
      override def moduleDeps = Seq(scalajslib.`worker-api`)
      override def ivyDeps = Agg(
        Deps.Scalajs_1.scalajsLinker,
-@@ -723,6 +695,7 @@ object contrib extends MillModule {
- 
+@@ -712,6 +684,7 @@ object contrib extends MillModule {
+
      object worker extends Cross[WorkerModule](Deps.play.keys.toSeq: _*)
      class WorkerModule(playBinary: String) extends MillInternalModule {
 +      override def millSourcePath: os.Path = super.millSourcePath / playBinary
        override def sources = T.sources {
          // We want to avoid duplicating code as long as the Play APIs allow.
          // But if newer Play versions introduce incompatibilities,
-@@ -925,6 +898,7 @@ object scalanativelib extends MillModule {
+@@ -914,6 +887,7 @@ object scalanativelib extends MillModule {
    object worker extends Cross[WorkerModule]("0.4")
    class WorkerModule(scalaNativeWorkerVersion: String)
        extends MillInternalModule {
 +    override def millSourcePath: os.Path = super.millSourcePath / scalaNativeWorkerVersion
      override def moduleDeps = Seq(scalanativelib.`worker-api`)
      override def ivyDeps = scalaNativeWorkerVersion match {
        case "0.4" =>
-@@ -1576,53 +1550,7 @@ def launcher = T {
+@@ -1033,7 +1007,7 @@ def installLocalTask(binFile: Task[String], ivyRepo: String = null): Task[os.Pat
+ // test it in the `test` CrossModule. We pass `test`'s sources to `lib` to
+ // and pass `lib`'s compile output back to `test`
+ trait IntegrationTestCrossModule extends IntegrationTestModule {
+-
++  override def millSourcePath = super.millSourcePath / repoSlug
+ }
+ trait IntegrationTestModule extends MillScalaModule {
+   def repoSlug: String
+@@ -1645,53 +1619,7 @@ def launcher = T {
  }
- 
+
  def uploadToGithub(authKey: String) = T.command {
 -  val vcsState = VcsVersion.vcsState()
 -  val label = vcsState.format()
@@ -139,5 +148,5 @@ index 3930b72ff..5cf3ee459 100644
 -  }
 +  // never upload a bootstrapped version
  }
- 
- def validate(ev: Evaluator): Command[Unit] = T.command {
+
+ def validate(ev: Evaluator): Command[Unit] = T.command {

ci/test-mill-bootstrap-0.sh

@@ -40,3 +40,4 @@ ci/patch-mill-bootstrap.sh
 
 # Use second build to run tests using Mill
 target/mill-2 -i "{main,scalalib,scalajslib,scalanativelib,bsp}.__.test"
+target/mill-2 -i "example[1-hello-world].server.test"

ci/test-mill-bootstrap-1.sh

@@ -39,4 +39,5 @@ rm -rf ~/.mill/ammonite
 ci/patch-mill-bootstrap.sh
 
 # Use second build to run tests using Mill
+target/mill-2 -i "example[1-hello-world].server.test"
 target/mill-2 -i "contrib.__.test"

ci/test-mill-dev.sh

@@ -18,3 +18,4 @@ ci/patch-mill-bootstrap.sh
 out/dev/assembly.dest/mill -i -j 0 main.test.compile
 
 out/dev/assembly.dest/mill -i "{main,scalalib,scalajslib,scalanativelib,bsp,contrib.twirllib,contrib.scalapblib}.test"
+out/dev/assembly.dest/mill -i "example[1-hello-world].server.test"

ci/test-mill-release.sh

@@ -23,4 +23,5 @@ ci/patch-mill-bootstrap.sh
 export MILL_TEST_RELEASE="$(pwd)/target/mill-release"
 
 # Run tests
-"$MILL_TEST_RELEASE" -i integration.thirdparty.forked
+"$MILL_TEST_RELEASE" -i "example[1-hello-world].server.test"
+"$MILL_TEST_RELEASE" -i integration.thirdparty.__.fork.test

contrib/artifactory/src/mill/contrib/artifactory/ArtifactoryPublishModule.scala

@@ -94,7 +94,7 @@ object ArtifactoryPublishModule extends ExternalModule {
     }
   }
 
-  implicit def millScoptTargetReads[T] = new mill.main.Tasks.Scopt[T]()
+  import mill.main.TokenReaders._
 
   lazy val millDiscover: mill.define.Discover[this.type] = mill.define.Discover[this.type]
 }

contrib/bintray/src/mill/contrib/bintray/BintrayPublishModule.scala

@@ -100,7 +100,7 @@ object BintrayPublishModule extends ExternalModule {
     }
   }
 
-  implicit def millScoptTargetReads[T] = new mill.main.Tasks.Scopt[T]()
+  import mill.main.TokenReaders._
 
   lazy val millDiscover: mill.define.Discover[this.type] = mill.define.Discover[this.type]
 }

contrib/codeartifact/src/mill/contrib/codeartifact/CodeartifactPublishModule.scala

@@ -58,7 +58,7 @@ object CodeartifactPublishModule extends ExternalModule {
       )
     }
 
-  implicit def millScoptTargetReads[T] = new mill.main.Tasks.Scopt[T]()
+  import mill.main.TokenReaders._
 
   lazy val millDiscover: mill.define.Discover[this.type] =
     mill.define.Discover[this.type]

contrib/gitlab/src/mill/contrib/gitlab/GitlabPublishModule.scala

@@ -79,7 +79,7 @@ object GitlabPublishModule extends ExternalModule {
     )
   }
 
-  implicit def millScoptTargetReads[T] = new mill.main.Tasks.Scopt[T]()
+  import mill.main.TokenReaders._
 
   lazy val millDiscover: mill.define.Discover[this.type] = mill.define.Discover[this.type]
 }

contrib/scoverage/test/src/mill/contrib/scoverage/HelloWorldTests.scala

@@ -141,7 +141,7 @@ trait HelloWorldTests extends utest.TestSuite {
 
             val resultPath = result.path.toIO.getPath.replace("""\""", "/")
             val expectedEnd =
-              "mill/target/workspace/mill/contrib/scoverage/HelloWorldTests/eval/HelloWorld/core/scoverage/data/core/scoverage/data.dest"
+              "/target/workspace/mill/contrib/scoverage/HelloWorldTests/eval/HelloWorld/core/scoverage/data/core/scoverage/data.dest"
 
             assert(
               resultPath.endsWith(expectedEnd),
@@ -186,7 +186,7 @@ trait HelloWorldTests extends utest.TestSuite {
             assert(evalCount > 0)
           }
         }
-        "test" - {
+        test("test") - {
           "upstreamAssemblyClasspath" - workspaceTest(HelloWorld) { eval =>
             val Right((result, evalCount)) =
               eval.apply(HelloWorld.core.scoverage.upstreamAssemblyClasspath)

contrib/versionfile/src/mill/contrib/versionfile/VersionFileModule.scala

@@ -90,7 +90,7 @@ object VersionFileModule extends define.ExternalModule {
     } yield proc.call()
   }
 
-  implicit val millScoptTargetReads = new mill.main.Tasks.Scopt[Seq[os.proc]]()
+  import mill.main.TokenReaders._
 
   lazy val millDiscover: mill.define.Discover[this.type] = mill.define.Discover[this.type]
 }

example/basic/1-hello-world/build.sc

@@ -0,0 +1,31 @@
+import mill._, scalalib._
+
+object foo extends BuildModule with ScalaModule {
+  def scalaVersion = "2.13.2"
+  def ivyDeps = Agg(ivy"com.lihaoyi::scalatags:0.8.2")
+}
+
+// This is a basic Mill build for a single `ScalaModule`, with a single
+// third-party dependency. As a single-module project, it `extends BuildModule`
+// to mark `object foo` as the top-level module in the build. This lets us
+// directly perform operations `./mill compile` or `./mill run` without needing
+// to prefix it as `foo.compile` or `foo.run`.
+//
+// You can run `assembly` to generate a standalone executable jar, which then
+// can be run from the command line or deployed to be run elsewhere.
+
+/* Example Usage
+
+> ./mill compile
+compiling 1 Scala source
+
+> ./mill run
+Foo.value: <h1>hello</h1>
+
+> ./mill show assembly
+out/assembly.dest/out.jar
+
+> ./out/assembly.dest/out.jar
+Foo.value: <h1>hello</h1>
+
+*/

example/basic/1-hello-world/src/Foo.scala

@@ -0,0 +1,8 @@
+package foo
+import scalatags.Text.all._
+object Foo {
+  val value = h1("hello")
+  def main(args: Array[String]): Unit = {
+    println("Foo.value: " + Foo.value)
+  }
+}

example/basic/2-multi-module/bar/src/Bar.scala

@@ -0,0 +1,9 @@
+package bar
+import scalatags.Text.all._
+object Bar {
+  val value = p("world")
+
+  def main(args: Array[String]): Unit = {
+    println("Bar.value: " + bar.Bar.value)
+  }
+}

example/basic/2-multi-module/build.sc

@@ -0,0 +1,37 @@
+import mill._, scalalib._
+
+trait MyModule extends ScalaModule{
+  def scalaVersion = "2.13.2"
+  def ivyDeps = Agg(ivy"com.lihaoyi::scalatags:0.8.2")
+}
+
+object foo extends MyModule {
+  def moduleDeps = Seq(bar)
+}
+
+object bar extends MyModule
+
+// A simple Mill build with two modules, `foo` and `bar`. We don't mark either
+// module as top-level using `extends BuildModule`, so running tasks needs to
+// use the module name as the prefix e.g. `foo.run` or `bar.run`
+//
+// Note that we split out the configuration common to both modules into a
+// separate `trait MyModule`. This lets us avoid the need to copy-paste common
+// settings, while still letting us define any per-module configuration
+// specific to a particular module e.g. overriding `moduleDeps` to make `foo`
+// depend on `bar`
+
+/* Example Usage
+
+> ./mill resolve __.run
+foo.run
+bar.run
+
+> ./mill foo.run
+Foo.value: <h1>hello</h1>
+Bar.value: <p>world</p>
+
+> ./mill bar.run
+Bar.value: <p>world</p>
+
+*/

example/basic/2-multi-module/foo/src/Foo.scala

@@ -0,0 +1,10 @@
+package foo
+import scalatags.Text.all._
+object Foo {
+  val value = h1("hello")
+
+  def main(args: Array[String]): Unit = {
+    println("Foo.value: " + Foo.value)
+    println("Bar.value: " + bar.Bar.value)
+  }
+}

example/basic/3-nested-modules/build.sc

@@ -0,0 +1,44 @@
+import mill._, scalalib._
+
+trait MyModule extends ScalaModule{
+  def scalaVersion = "2.13.2"
+  def ivyDeps = Agg(ivy"com.lihaoyi::scalatags:0.8.2")
+}
+
+object wrapper extends Module{
+  object foo extends MyModule {
+    def moduleDeps = Seq(bar)
+  }
+
+  object bar extends MyModule
+}
+
+object qux extends MyModule {
+  def moduleDeps = Seq(wrapper.bar, wrapper.foo)
+}
+
+// Modules can be nested arbitrarily deeply within each other. The outer module
+// can be the same kind of module as the ones within, or it can be a plain
+// `Module` if we just need a wrapper to put the modules in without any tasks
+// defined on the wrapper.
+//
+// Running tasks on the nested modules requires the full module path
+// `wrapper.foo.run`
+
+/* Example Usage
+
+> ./mill resolve __.run
+wrapper.foo.run
+wrapper.bar.run
+qux.run
+
+> ./mill qux.run
+Foo.value: <h1>hello</h1>
+Bar.value: <p>world</p>
+Qux.value: <p>today</p>
+
+> ./mill wrapper.foo.run
+Foo.value: <h1>hello</h1>
+Bar.value: <p>world</p>
+
+*/

example/basic/3-nested-modules/qux/src/Qux.scala

@@ -0,0 +1,11 @@
+package qux
+import scalatags.Text.all._
+object Qux {
+  val value = p("today")
+
+  def main(args: Array[String]): Unit = {
+    println("Foo.value: " + foo.Foo.value)
+    println("Bar.value: " + bar.Bar.value)
+    println("Qux.value: " + qux.Qux.value)
+  }
+}

example/basic/3-nested-modules/wrapper/bar/src/Bar.scala

@@ -0,0 +1,5 @@
+package bar
+import scalatags.Text.all._
+object Bar {
+  val value = p("world")
+}

example/basic/3-nested-modules/wrapper/foo/src/Foo.scala

@@ -0,0 +1,10 @@
+package foo
+import scalatags.Text.all._
+object Foo {
+  val value = h1("hello")
+
+  def main(args: Array[String]): Unit = {
+    println("Foo.value: " + Foo.value)
+    println("Bar.value: " + bar.Bar.value)
+  }
+}

example/basic/4-test-suite/build.sc

@@ -0,0 +1,32 @@
+import mill._, scalalib._
+
+object foo extends ScalaModule {
+  def scalaVersion = "2.13.2"
+  object test extends Tests {
+    def ivyDeps = Agg(ivy"com.lihaoyi::utest:0.7.11")
+    def testFramework = "utest.runner.Framework"
+  }
+}
+
+// This build defines a single module with a test suite, configured to use
+// "uTest" as the testing framework. Test suites are themselves `ScalaModule`s,
+// and have all the normal tasks like `foo.test.compile` available to run, but
+// with an additional `.test` task that runs the tests. You can also run the
+// test suite directly, in which case it will run the `.test` task as the
+// default task for that module
+
+/* Example Usage
+
+> ./mill foo.compile
+compiling 1 Scala source
+
+> ./mill foo.test.compile
+compiling 1 Scala source
+
+> ./mill foo.test.test
++ foo.FooTests.hello
+
+> ./mill foo.test
++ foo.FooTests.hello
+
+*/

example/example-3/foo/src/Example.scala → example/basic/4-test-suite/foo/src/Foo.scala

@@ -1,5 +1,5 @@
 package foo
-object Example {
+object Foo {
   def main(args: Array[String]): Unit = {
     println(hello())
   }

example/example-3/foo/test/src/ExampleTests.scala → example/basic/4-test-suite/foo/test/src/FooTests.scala

@@ -1,9 +1,9 @@
 package foo
 import utest._
-object ExampleTests extends TestSuite {
+object FooTests extends TestSuite {
   def tests = Tests {
     test("hello") {
-      val result = Example.hello()
+      val result = Foo.hello()
       assert(result == "Hello World")
       result
     }

example/basic/5-publish-module/build.sc

@@ -0,0 +1,30 @@
+import mill._, scalalib._, publish._
+
+object foo extends ScalaModule with PublishModule {
+  def scalaVersion = "2.13.10"
+  def publishVersion = "0.0.1"
+
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("lihaoyi", "example"),
+    developers = Seq(
+      Developer("lihaoyi", "Li Haoyi", "https://github.com/lihaoyi")
+    )
+  )
+}
+
+// This is an example `ScalaModule` with added publishing capabilities via
+// `PublishModule`. This requires that you define an additional
+// `publishVersion` and `pomSettings` with the relevant metadata, and provides
+// the `.publishLocal` and `publishSigned` tasks for publishing locally to the
+// machine or to the central maven repository
+
+/* Example Usage
+
+> ./mill foo.publishLocal
+Publishing Artifact(com.lihaoyi,foo_2.13,0.0.1)
+
+*/

example/example-2/foo/src/Example.scala → example/basic/5-publish-module/foo/src/Foo.scala

@@ -1,5 +1,5 @@
 package foo
-object Example {
+object Foo {
   def main(args: Array[String]): Unit = {
     println("Hello World")
   }

example/basic/6-cross-scala-version/bar/src/Bar.scala

@@ -0,0 +1,8 @@
+package bar
+object Bar {
+  val value = "bar-value"
+
+  def main(args: Array[String]): Unit = {
+    println("Bar.value: " + bar.Bar.value)
+  }
+}

example/basic/6-cross-scala-version/build.sc

@@ -0,0 +1,50 @@
+import mill._, scalalib._
+
+val scalaVersions = Seq("2.12.17", "2.13.10", "3.2.2")
+
+object foo extends Cross[FooModule](scalaVersions:_*)
+class FooModule(val crossScalaVersion: String) extends CrossScalaModule{
+  def moduleDeps = Seq(bar())
+}
+
+object bar extends Cross[BarModule](scalaVersions:_*)
+class BarModule(val crossScalaVersion: String) extends CrossScalaModule
+
+// This is an example of cross-building a module across multiple Scala
+// versions. Each module is replaced by a `Cross` module, which is given a list
+// of strings you want the cross-module to be replicated for. You can then
+// specify the cross-modules with square brackets when you want to run tasks on
+// them.
+//
+// `CrossScalaModule`s support both shared sources within `src/` as well as
+// version specific sources in `src-x/`, `src-x.y/`, or `src-x.y.z/` that
+// apply to the cross-module with that version prefix.
+//
+// `CrossScalaModule` can depend on each other using `moduleDeps`, but require
+// the `()` suffix in `moduleDeps` to select the appropriate instance of the
+// cross-module to depend on.
+
+/* Example Usage
+
+> ./mill resolve __.run
+foo[2.12.17].run
+foo[2.13.10].run
+bar[2.12.17].run
+bar[2.13.10].run
+
+> ./mill foo[2.12.17].run
+Foo.value: Hello World Scala library version 2.12.17
+Bar.value: bar-value
+Specific code for Scala 2.x
+Specific code for Scala 2.12.x
+
+> ./mill foo[2.13.10].run
+Foo.value: Hello World Scala library version 2.13.10
+Bar.value: bar-value
+Specific code for Scala 2.x
+Specific code for Scala 2.13.x
+
+> ./mill bar[3.2.2].run
+Bar.value: bar-value
+
+*/

example/basic/6-cross-scala-version/foo/src-2.12/MinorVersionSpecific.scala

@@ -0,0 +1,4 @@
+package foo
+object MinorVersionSpecific {
+  def text(): String = "Specific code for Scala 2.12.x"
+}

example/basic/6-cross-scala-version/foo/src-2.13/MinorVersionSpecific.scala

@@ -0,0 +1,4 @@
+package foo
+object MinorVersionSpecific {
+  def text(): String = "Specific code for Scala 2.13.x"
+}

example/basic/6-cross-scala-version/foo/src-2/MajorVersionSpecific.scala

@@ -0,0 +1,4 @@
+package foo
+object MajorVersionSpecific {
+  def text(): String = "Specific code for Scala 2.x"
+}

example/basic/6-cross-scala-version/foo/src-3.2/MinorVersionSpecific.scala

@@ -0,0 +1,4 @@
+package foo
+object MinorVersionSpecific {
+  def text(): String = "Specific code for Scala 3.2.x"
+}

example/basic/6-cross-scala-version/foo/src-3/MajorVersionSpecific.scala

@@ -0,0 +1,4 @@
+package foo
+object MajorVersionSpecific {
+  def text(): String = "Specific code for Scala 3.x"
+}

example/basic/6-cross-scala-version/foo/src/Foo.scala

@@ -0,0 +1,10 @@
+package foo
+object Foo {
+  def main(args: Array[String]): Unit = {
+    println("Foo.value: " + foo.Foo.value)
+    println("Bar.value: " + bar.Bar.value)
+    println(MajorVersionSpecific.text())
+    println(MinorVersionSpecific.text())
+  }
+  val value = "Hello World " + scala.util.Properties.versionMsg
+}

example/basic/7-java-modules/bar/src/Bar.java

@@ -0,0 +1,4 @@
+package bar;
+public class Bar{
+    public static final int value = 271828;
+}

example/basic/7-java-modules/build.sc

@@ -0,0 +1,26 @@
+import mill._, scalalib._
+
+object foo extends JavaModule{
+  def moduleDeps = Seq(bar)
+}
+
+object bar extends JavaModule
+
+// Mill also supports `JavaModule`s, which can only contain pure Java code
+// without any Scala. These have the same set of tasks as `ScalaModules`:
+// `compile`, `run`, etc., and can similarly depend on each other.
+
+/* Example Usage
+
+> ./mill resolve __.run
+foo.run
+bar.run
+
+> ./mill foo.compile
+compiling 1 Java source
+
+> ./mill foo.run
+Foo.value: 31337
+Bar.value: 271828
+
+*/

example/basic/7-java-modules/foo/src/Foo.java

@@ -0,0 +1,8 @@
+package foo;
+public class Foo{
+    public static final int value = 31337;
+    public static void main(String[] args){
+        System.out.println("Foo.value: " + foo.Foo.value);
+        System.out.println("Bar.value: " + bar.Bar.value);
+    }
+}

example/basic/8-scala-combined/bar/src-2/BarVersionSpecific.scala

@@ -0,0 +1,4 @@
+package bar
+object BarVersionSpecific {
+  def text(): String = "Specific code for Scala 2.x"
+}

example/basic/8-scala-combined/bar/src-3/BarVersionSpecific.scala

@@ -0,0 +1,4 @@
+package bar
+object BarVersionSpecific {
+  def text(): String = "Specific code for Scala 3.x"
+}

example/basic/8-scala-combined/bar/src/Bar.scala

@@ -0,0 +1,5 @@
+package bar
+import scalatags.Text.all._
+object Bar {
+  val value = p("world", " ", BarVersionSpecific.text())
+}

example/basic/8-scala-combined/bar/test/src-2/BarVersionSpecificTests.scala

@@ -0,0 +1,9 @@
+package bar
+import utest._
+object BarVersionSpecificTests extends TestSuite {
+  def tests = Tests {
+    test("test") {
+      assert(BarVersionspecific.text().contains("2.x"))
+    }
+  }
+}

example/basic/8-scala-combined/bar/test/src-3/BarVersionSpecificTests.scala

@@ -0,0 +1,9 @@
+package bar
+import utest._
+object BarVersionSpecificTests extends TestSuite {
+  def tests = Tests {
+    test("test") {
+      assert(BarVersionspecific.text().contains("3.x"))
+    }
+  }
+}

example/basic/8-scala-combined/bar/test/src/BarTests.scala

@@ -0,0 +1,12 @@
+package bar
+import utest._
+object BarTests extends TestSuite {
+  def tests = Tests {
+    test("test") {
+      val result = Bar.value.toString
+      val matcher = "<p>world Specific code for Scala [23].x</p>".r
+      assert(matcher.matches(result))
+      result
+    }
+  }
+}

example/basic/8-scala-combined/build.sc

@@ -0,0 +1,111 @@
+import mill._, scalalib._, publish._
+
+trait MyModule extends PublishModule {
+  def publishVersion = "0.0.1"
+
+  def pomSettings = PomSettings(
+    description = "Hello",
+    organization = "com.lihaoyi",
+    url = "https://github.com/lihaoyi/example",
+    licenses = Seq(License.MIT),
+    versionControl = VersionControl.github("lihaoyi", "example"),
+    developers = Seq(Developer("lihaoyi", "Li Haoyi", "https://github.com/lihaoyi"))
+  )
+}
+
+trait MyScalaModule extends ScalaModule with MyModule {
+  def ivyDeps = Agg(ivy"com.lihaoyi::scalatags:0.12.0")
+  object test extends Tests {
+    def ivyDeps = Agg(ivy"com.lihaoyi::utest:0.7.11")
+    def testFramework = "utest.runner.Framework"
+  }
+}
+
+val scalaVersions = Seq("2.13.10", "3.2.2")
+
+object foo extends Cross[FooModule](scalaVersions:_*)
+class FooModule(val crossScalaVersion: String) extends MyScalaModule with CrossScalaModule{
+  def moduleDeps = Seq(bar(), qux)
+}
+
+object bar extends Cross[BarModule](scalaVersions:_*)
+class BarModule(val crossScalaVersion: String) extends MyScalaModule with CrossScalaModule{
+  def moduleDeps = Seq(qux)
+}
+
+object qux extends JavaModule with MyModule
+
+// A semi-realistic build setup, combining all the individual Mill concepts:
+//
+// - Two `CrossScalaModules` compiled against two Scala versions, that depend on
+//   each other as well as on a `JavaModule`
+//
+// - With unit testing and publishing set up
+//
+// - With version-specific sources
+//
+// Note that for multi-module builds like this, using queries like `__.test`
+// or `__.publishLocal` to run tasks on multiple targets at once can be very
+// convenient. Also note that `ScalaModule`s can depend on `JavaModule`s, and
+// when multiple inter-dependent modules are published they automatically will
+// include the inter-module dependencies in the publish metadata.
+//
+// Also note how you can use `trait`s to bundle together common combinations of
+// modules: `MyScalaModule` not only defines a `ScalaModule` with some common
+// configuration, but it also defines a `object test` module within it with its
+// own configuration. This is a very useful technique for managing the often
+// repetitive module structure in a typical project
+
+/* Example Usage
+
+> ./mill resolve __.run
+bar[2.13.10].run
+bar[2.13.10].test.run
+bar[3.2.2].run
+bar[3.2.2].test.run
+foo[2.13.10].run
+foo[2.13.10].test.run
+foo[3.2.2].run
+foo[3.2.2].test.run
+qux.run
+
+> ./mill foo[2.13.10].run
+Foo.value: <h1>hello Scala 2.x</h1>
+Bar.value: <p>world Specific code for Scala 2.x</p>
+Qux.value: 31337
+
+> ./mill bar[3.2.2].test
+bar.BarTests.test
+<p>world Specific code for Scala 3.x</p>
+
+> ./mill qux.run
+Qux.value: 31337
+
+> ./mill __.compile
+
+> ./mill __.test
++ bar.BarTests.test
+<p>world Specific code for Scala 2.x</p>
++ bar.BarTests.test
+<p>world Specific code for Scala 3.x</p>
++ foo.FooTests.test
+<h1>hello Scala 2.x</h1>
++ foo.FooTests.test
+<h1>hello Scala 3.x</h1>
+
+> ./mill __.publishLocal
+Publishing Artifact(com.lihaoyi,foo_2.13,0.0.1)
+Publishing Artifact(com.lihaoyi,bar_2.13,0.0.1)
+Publishing Artifact(com.lihaoyi,foo_3,0.0.1)
+Publishing Artifact(com.lihaoyi,bar_3,0.0.1)
+Publishing Artifact(com.lihaoyi,qux,0.0.1)
+
+> ./mill show foo[2.13.10].assembly
+out/foo/2.13.10/assembly.dest/out.jar
+
+> ./out/foo/2.13.10/assembly.dest/out.jar
+Foo.value: <h1>hello Scala 2.x</h1>
+Bar.value: <p>world Specific code for Scala 2.x</p>
+Qux.value: 31337
+
+*/

example/basic/8-scala-combined/foo/src-2/FooVersionSpecific.scala

@@ -0,0 +1,4 @@
+package foo
+object FooVersionSpecific{
+  def value = "hello Scala 2.x"
+}

example/basic/8-scala-combined/foo/src-3/FooVersionSpecific.scala

@@ -0,0 +1,4 @@
+package foo
+object FooVersionSpecific{
+  def value = "hello Scala 3.x"
+}

example/basic/8-scala-combined/foo/src/Foo.scala

@@ -0,0 +1,10 @@
+package foo
+import scalatags.Text.all._
+object Foo {
+  val value = h1(FooVersionSpecific.value)
+  def main(args: Array[String]): Unit = {
+    println("Foo.value: " + Foo.value)
+    println("Bar.value: " + bar.Bar.value)
+    println("Qux.value: " + qux.Qux.value)
+  }
+}

example/basic/8-scala-combined/foo/test/src/FooTests.scala

@@ -0,0 +1,12 @@
+package foo
+import utest._
+object FooTests extends TestSuite {
+  def tests = Tests {
+    test("test") {
+      val result = Foo.value.toString
+      val matcher = "<h1>hello Scala [23].x</h1>".r
+      assert(matcher.matches(result))
+      result
+    }
+  }
+}

example/basic/8-scala-combined/qux/src/Qux.java

@@ -0,0 +1,7 @@
+package qux;
+public class Qux{
+    public static final int value = 31337;
+    public static void main(String[] args){
+        System.out.println("Qux.value: " + Qux.value);
+    }
+}

example/misc/1-sbt-compat-modules/bar/src/main/scala-2.12/MinorVersionSpecific.scala

@@ -0,0 +1,4 @@
+package bar
+object MinorVersionSpecific {
+  def text(): String = "Specific code for Scala 2.12.x"
+}

example/misc/1-sbt-compat-modules/bar/src/main/scala-2.13/MinorVersionSpecific.scala

@@ -0,0 +1,4 @@
+package bar
+object MinorVersionSpecific {
+  def text(): String = "Specific code for Scala 2.13.x"
+}

example/misc/1-sbt-compat-modules/bar/src/main/scala/Bar.scala

@@ -0,0 +1,8 @@
+package bar
+object Bar {
+  def main(args: Array[String]): Unit = {
+    println("Bar.value: " + bar.Bar.value)
+    println(MinorVersionSpecific.text())
+  }
+  val value = "Hello World " + scala.util.Properties.versionMsg
+}

example/misc/1-sbt-compat-modules/build.sc

@@ -0,0 +1,60 @@
+import mill._, scalalib._
+
+object foo extends SbtModule {
+  def scalaVersion = "2.13.2"
+  object test extends Tests {
+    def ivyDeps = Agg(ivy"com.lihaoyi::utest:0.7.11")
+    def testFramework = "utest.runner.Framework"
+  }
+}
+
+
+object bar extends Cross[BarModule]("2.12.17", "2.13.10")
+class BarModule(val crossScalaVersion: String) extends CrossSbtModule{
+  object test extends Tests {
+    def ivyDeps = Agg(ivy"com.lihaoyi::utest:0.7.11")
+
+    def testFramework = "utest.runner.Framework"
+  }
+}
+
+
+// `SbtModule`/`CrossSbtModule` are variants of `ScalaModule`/`CrossScalaModule`
+// that use the more verbose folder layout of SBT, Maven, and other tools:
+//
+// - `foo/src/main/scala`
+// - `foo/src/main/scala-2.12`
+// - `foo/src/main/scala-2.13`
+// - `foo/src/test/scala`
+//
+// Rather than Mill's
+//
+// - `foo/src`
+// - `foo/src-2.12`
+// - `foo/src-2.13`
+// - `foo/test/src`
+//
+// This is especially useful during migrations, where a particular module may
+// be built using both SBT and Mill at the same time
+
+/* Example Usage
+
+> ./mill foo.compile
+compiling 1 Scala source
+
+> ./mill foo.test.compile
+compiling 1 Scala source
+
+> ./mill foo.test.test
++ foo.FooTests.hello
+
+> ./mill foo.test
++ foo.FooTests.hello
+
+> ./mill bar[2.13.10].run
+Hello World Scala library version 2.13.10
+
+> ./mill bar[2.12.17].run
+Hello World Scala library version 2.12.17
+
+*/

example/misc/1-sbt-compat-modules/foo/src/main/scala/Foo.scala

@@ -0,0 +1,7 @@
+package foo
+object Foo {
+  def main(args: Array[String]): Unit = {
+    println(hello())
+  }
+  def hello(): String = "Hello World"
+}

example/misc/1-sbt-compat-modules/foo/src/test/scala/FooTests.scala

@@ -0,0 +1,11 @@
+package foo
+import utest._
+object FooTests extends TestSuite {
+  def tests = Tests {
+    test("hello") {
+      val result = Foo.hello()
+      assert(result == "Hello World")
+      result
+    }
+  }
+}

example/misc/2-dynamic-cross-module/build.sc

@@ -0,0 +1,47 @@
+import mill._, scalalib._
+
+val moduleNames = interp.watchValue(os.list(millSourcePath / "modules").map(_.last))
+
+object modules extends Cross[FolderModule](moduleNames:_*)
+class FolderModule(name: String) extends ScalaModule{
+  def millSourcePath = super.millSourcePath / name
+  def scalaVersion = "2.13.2"
+}
+
+// It is sometimes necessary for the instances of a cross-module to vary based
+// on some kind of runtime information: perhaps the list of modules is stored
+// in some config file, or is inferred based on the folders present on the
+// filesystem.
+//
+// In those cases, you can write arbitrary code to populate the cross-module
+// cases, as long as you wrap the value in a `interp.watchValue`. This ensures
+// that Mill is aware that the module structure depends on that value, and will
+// re-compute the value and re-create the module structure if the value changes.
+
+/* Example Usage
+
+> ./mill resolve modules[_]
+modules[bar]
+modules[foo]
+modules[qux]
+
+> ./mill modules[bar].run
+Hello World Bar
+
+> ./mill modules[new].run
+error: Cannot resolve modules[new]
+
+> cp -r modules/bar modules/new
+
+> sed -i 's/Bar/New/g' modules/new/src/Example.scala
+
+> ./mill resolve modules[_]
+modules[bar]
+modules[foo]
+modules[qux]
+modules[new]
+
+> ./mill modules[new].run
+Hello World New
+
+*/

example/misc/2-dynamic-cross-module/modules/bar/src/Example.scala

@@ -0,0 +1,6 @@
+package bar
+object Example {
+  def main(args: Array[String]): Unit = {
+    println("Hello World Bar")
+  }
+}

example/misc/2-dynamic-cross-module/modules/foo/src/Example.scala

@@ -0,0 +1,6 @@
+package foo
+object Example {
+  def main(args: Array[String]): Unit = {
+    println("Hello World Foo")
+  }
+}

example/misc/2-dynamic-cross-module/modules/qux/src/Example.scala

@@ -0,0 +1,6 @@
+package qux
+object Example {
+  def main(args: Array[String]): Unit = {
+    println("Hello World Qux")
+  }
+}

example/misc/3-two-level-build/build.sc

@@ -0,0 +1,24 @@
+import mill._, scalalib._
+import scalatags.Text.all._
+
+object foo extends ScalaModule {
+  def scalaVersion = "2.13.2"
+
+  def forkEnv = Map(
+    "snippet" -> frag(h1("hello"), p("world"), p(constant.Constant.scalatagsVersion)).render
+  )
+}
+
+//
+
+/* Example Usage
+
+> ./mill foo.run
+<h1>hello</h1><p>world</p><p>0.8.2</p>
+
+> sed -i 's/0.8.2/0.12.0/g' mill-build/build.sc
+
+> ./mill foo.run
+<h1>hello</h1><p>world</p><p>0.12.0</p>
+
+*/

example/misc/3-two-level-build/foo/src/Example.scala

@@ -0,0 +1,7 @@
+package foo
+
+object Example {
+  def main(args: Array[String]): Unit = {
+    println(sys.env("snippet") + "?")
+  }
+}

example/misc/3-two-level-build/mill-build/build.sc

@@ -0,0 +1,17 @@
+import mill._, scalalib._
+
+object millbuild extends runner.MillBuildModule{
+  def ivyDeps = Agg(ivy"com.lihaoyi::scalatags:0.8.2")
+
+  def generatedSources = T {
+    os.write(
+      T.dest / "Constant.scala",
+      s"""package constant
+         |object Constant{
+         |  def scalatagsVersion = "0.8.2"
+         |}
+         |""".stripMargin
+    )
+    super.generatedSources() ++ Seq(PathRef(T.dest / "Constant.scala"))
+  }
+}

integration/failure/compile-error/repo/bar.sc

@@ -0,0 +1,4 @@
+def myScalaVersion = "2.13.2"
+
+
+println(doesntExist)

integration/failure/compile-error/repo/build.sc

@@ -0,0 +1,8 @@
+import $file.{bar, qux}
+import mill._
+import mill.scalalib._
+object foo extends ScalaModule {
+  def scalaVersion = bar.myScalaVersion
+}
+
+foo.noSuchMethod

integration/failure/compile-error/repo/qux.sc

@@ -0,0 +1,3 @@
+def myMsg = "<h1>world</h1>"
+
+def myOtherMsg = myMsg.substring("0")

integration/failure/compile-error/test/src/CompileErrorTests.scala

@@ -0,0 +1,22 @@
+
+package mill.integration
+
+import mill.util.Util
+import utest._
+
+object CompileErrorTests extends IntegrationTestSuite  {
+  def captureOutErr = true
+  val tests = Tests {
+    initWorkspace()
+
+    test {
+      val res = evalStdout("foo.scalaVersion")
+
+      assert(res.isSuccess == false)
+      assert(res.err.contains("""bar.sc:4:9: not found: value doesntExist"""))
+      assert(res.err.contains("""println(doesntExist)"""))
+      assert(res.err.contains("""qux.sc:3:34: type mismatch;"""))
+      assert(res.err.contains("""build.sc:8:5: value noSuchMethod is not a member of object build.this.foo"""))
+    }
+  }
+}

integration/failure/invalid-meta-module/test/src/InvalidMetaModuleTests.scala

@@ -0,0 +1,18 @@
+package mill.integration
+
+import utest._
+
+import scala.util.matching.Regex
+
+object InvalidMetaModuleTests extends IntegrationTestSuite {
+  val tests = Tests {
+    val workspaceRoot = initWorkspace()
+
+
+    test("success"){
+      val res = evalStdout("resolve", "_")
+      assert(res.isSuccess == false)
+      assert(res.err.contains("Top-level module in mill-build/build.sc must be of class mill.runner.MillBuildModule"))
+    }
+  }
+}

integration/failure/missing-build-file/test/src/MissingBuildFileTests.scala

@@ -0,0 +1,16 @@
+
+package mill.integration
+
+import utest._
+
+object MissingBuildFileTests extends IntegrationTestSuite {
+  val tests = Tests {
+    initWorkspace()
+
+    test {
+      val res = evalStdout("resolve", "_")
+      assert(!res.isSuccess)
+      assert(res.err.contains("build.sc file not found. Are you in a Mill project folder"))
+    }
+  }
+}

integration/failure/multiple-top-level-modules/repo/build.sc

@@ -0,0 +1,2 @@
+object foo extends BuildModule
+object bar extends BuildModule

integration/failure/multiple-top-level-modules/test/src/MultipleTopLevelModulesTests.scala

@@ -0,0 +1,17 @@
+package mill.integration
+
+import utest._
+
+import scala.util.matching.Regex
+
+object MultipleTopLevelModulesTests extends IntegrationTestSuite {
+  val tests = Tests {
+    val workspaceRoot = initWorkspace()
+
+    test("success"){
+      val res = evalStdout("resolve", "_")
+      assert(!res.isSuccess)
+      assert(res.err.contains("Only one BaseModule can be defined in a build, not 2: millbuild.build$bar$,millbuild.build$foo$"))
+    }
+  }
+}

integration/failure/parse-error/repo/bar.sc

@@ -0,0 +1,4 @@
+def myScalaVersion = "2.13.2"
+
+
+println(doesntExist})

integration/failure/parse-error/repo/build.sc

@@ -0,0 +1,7 @@
+import $file.{bar, qux}
+import mill._
+import mill.scalalib._
+object foo extends ScalaModule {
+  def scalaVersion = bar.myScalaVersion
+}
+

integration/failure/parse-error/repo/qux.sc

@@ -0,0 +1,3 @@
+def myMsg = "<h1>world</h1>"
+
+System.out.println(doesntExist

integration/failure/parse-error/test/src/ParseErrorTests.scala

@@ -0,0 +1,22 @@
+
+package mill.integration
+
+import mill.util.Util
+import utest._
+
+object ParseErrorTests extends IntegrationTestSuite {
+  val tests = Tests {
+    initWorkspace()
+
+    test {
+      val res = evalStdout("foo.scalaVersion")
+
+      assert(res.isSuccess == false)
+
+      assert(res.err.contains("""bar.sc:4:20 expected ")""""))
+      assert(res.err.contains("""println(doesntExist})"""))
+      assert(res.err.contains("""qux.sc:3:31 expected ")""""))
+      assert(res.err.contains("""System.out.println(doesntExist"""))
+    }
+  }
+}

bsp/test/src/mill/bsp/BspInstallDebugTests.scala → integration/feature/bsp-install/test/src/BspInstallDebugTests.scala

@@ -1,13 +1,11 @@
-package mill.bsp
-
-import mill.util.ScriptTestSuite
+package mill.integration
+package local
+import mill.bsp.Constants
 import utest._
 
-object BspInstallDebugTests extends ScriptTestSuite(false) {
-  override def workspaceSlug: String = "bsp-install"
-  override def scriptSourcePath: os.Path = os.pwd / "bsp" / "test" / "resources" / workspaceSlug
-  val bsp4jVersion = sys.props.getOrElse("BSP4J_VERSION", ???)
+object BspInstallDebugTests extends IntegrationTestSuite {
 
+  val bsp4jVersion = sys.props.getOrElse("BSP4J_VERSION", ???)
   // we purposely enable debugging in this simulated test env
   override val debugLog: Boolean = true
 

bsp/test/src/mill/bsp/BspInstallTests.scala → integration/feature/bsp-install/test/src/BspInstallTests.scala

@@ -1,11 +1,9 @@
-package mill.bsp
-
-import mill.util.ScriptTestSuite
+package mill.integration
+package local
+import mill.bsp.Constants
 import utest._
 
-object BspInstallTests extends ScriptTestSuite(false) {
-  override def workspaceSlug: String = "bsp-install"
-  override def scriptSourcePath: os.Path = os.pwd / "bsp" / "test" / "resources" / workspaceSlug
+object BspInstallTests extends IntegrationTestSuite {
   val bsp4jVersion = sys.props.getOrElse("BSP4J_VERSION", ???)
 
   def tests: Tests = Tests {

bsp/test/src/mill/bsp/BspModulesTests.scala → integration/feature/bsp-modules/test/src/BspModulesTests.scala

@@ -1,11 +1,9 @@
-package mill.bsp
-
-import mill.util.ScriptTestSuite
+package mill.integration
+package local
+import mill.bsp.Constants
 import utest._
 
-object BspModulesTests extends ScriptTestSuite(false) {
-  override def workspaceSlug: String = "bsp-modules"
-  override def scriptSourcePath: os.Path = os.pwd / "bsp" / "test" / "resources" / workspaceSlug
+object BspModulesTests extends IntegrationTestSuite {
   val bsp4jVersion = sys.props.getOrElse("BSP4J_VERSION", ???)
 
   def tests: Tests = Tests {

integration/local/src/mill/integration/CrossTests.scala → integration/feature/cross/test/src/CrossTests.scala

@@ -4,8 +4,7 @@ import mill.api.PathRef
 import utest._
 import utest.framework.TestPath
 
-class CrossTests(fork: Boolean, clientServer: Boolean)
-    extends IntegrationTestSuite("cross", fork, clientServer) {
+object CrossTests extends IntegrationTestSuite {
   val tests = Tests {
     def testCrossSourcePath(expectedPath: os.SubPath)(implicit tp: TestPath): Unit = {
       val target = tp.value.last

integration/local/src/mill/integration/DocAnnotationsTests.scala → integration/feature/docannotations/test/src/DocAnnotationsTests.scala

@@ -1,13 +1,11 @@
 package mill.integration
 
-import mill.util.ScriptTestSuite
 import utest._
 
-class DocAnnotationsTests(fork: Boolean, clientServer: Boolean)
-    extends IntegrationTestSuite("docannotations", fork, clientServer) {
+object DocAnnotationsTests extends IntegrationTestSuite {
   val tests = Tests {
     initWorkspace()
-    "test" - {
+    test("test") - {
       val res = eval("inspect", "core.test.ivyDeps")
       assert(res == true)
       val inheritedIvyDeps = ujson.read(meta("inspect"))("value").str

integration/feature/dynamic-cross-module/repo/build.sc

@@ -0,0 +1,10 @@
+import mill._, scalalib._
+
+val moduleNames = interp.watchValue(os.list(millSourcePath / "modules").map(_.last))
+
+object modules extends Cross[FolderModule](moduleNames:_*)
+class FolderModule(name: String) extends ScalaModule{
+  def millSourcePath = super.millSourcePath / name
+  def scalaVersion = "2.13.2"
+}
+

integration/feature/dynamic-cross-module/repo/modules/bar/src/Example.scala

@@ -0,0 +1,6 @@
+package bar
+object Example {
+  def main(args: Array[String]): Unit = {
+    println("Hello World Bar")
+  }
+}

integration/feature/dynamic-cross-module/repo/modules/foo/src/Example.scala

@@ -0,0 +1,6 @@
+package foo
+object Example {
+  def main(args: Array[String]): Unit = {
+    println("Hello World Foo")
+  }
+}

integration/feature/dynamic-cross-module/repo/modules/qux/src/Example.scala

@@ -0,0 +1,6 @@
+package qux
+object Example {
+  def main(args: Array[String]): Unit = {
+    println("Hello World Qux")
+  }
+}

integration/feature/dynamic-cross-module/test/src/DynamicCrossModuleTests.scala

@@ -0,0 +1,70 @@
+package mill.integration
+
+import utest._
+
+
+// Make sure that values watched by `interp.watchValue` properly cause the base
+// module to be re-evaluated, so that changes in the module tree that depend on
+// those changes can properly take place. This is most commonly due to defining
+// the cases of a cross-module to depend on the files present in a folder, in
+// which case the `interp.watchValue(os.list(...))` call will need to trigger
+// re-evaluation of the module tree when it changes.
+object DynamicCrossModuleTests extends IntegrationTestSuite {
+  val tests = Tests {
+    val wsRoot = initWorkspace()
+    test("test") - {
+
+
+      val res = evalStdout("resolve", "modules._")
+      assert(res.isSuccess == true)
+      assert(
+        res.out.linesIterator.toSet ==
+        Set("modules[bar]", "modules[foo]", "modules[qux]")
+      )
+
+      val res2 = evalStdout("modules[bar].run")
+      assert(res2.isSuccess == true)
+      if (integrationTestMode != "local") {
+        assert(res2.out.contains("Hello World Bar"))
+      }
+
+      val res3 = evalStdout("modules[new].run")
+      assert(res3.isSuccess == false)
+      assert(res3.err.contains("Cannot resolve modules[new]"))
+
+      val res4 = evalStdout("modules[newer].run")
+      assert(res4.isSuccess == false)
+      assert(res4.err.contains("Cannot resolve modules[newer]"))
+
+      os.copy(wsRoot / "modules" / "bar", wsRoot / "modules" / "new")
+      mangleFile(
+        wsRoot / "modules" / "new" / "src" / "Example.scala",
+        _.replace("Bar", "New")
+      )
+      os.copy(wsRoot / "modules" / "bar", wsRoot / "modules" / "newer")
+      mangleFile(
+        wsRoot / "modules" / "newer" / "src" / "Example.scala",
+        _.replace("Bar", "Newer")
+      )
+
+      val res5 = evalStdout("modules[new].run")
+      assert(res5.isSuccess == true)
+      if (integrationTestMode != "local") {
+        assert(res5.out.contains("Hello World New"))
+      }
+
+      val res6 = evalStdout("modules[newer].run")
+      assert(res6.isSuccess == true)
+      if (integrationTestMode != "local") {
+        assert(res6.out.contains("Hello World Newer"))
+      }
+
+      val res7 = evalStdout("resolve", "modules._")
+      assert(res7.isSuccess == true)
+      assert(
+        res7.out.linesIterator.toSet ==
+        Set("modules[bar]", "modules[foo]", "modules[qux]", "modules[new]", "modules[newer]")
+      )
+    }
+  }
+}

integration/feature/editing/repo/build.sc

@@ -0,0 +1,10 @@
+import mill._, scalalib._
+import scalatags.Text.all._
+
+object foo extends ScalaModule {
+  def scalaVersion = "2.13.2"
+
+  def forkEnv = Map(
+    "snippet" -> frag(h1("hello"), p("world"), p(constant.Constant.scalatagsVersion)).render
+  )
+}

integration/feature/editing/repo/foo/src/Example.scala

@@ -0,0 +1,7 @@
+package foo
+
+object Example {
+  def main(args: Array[String]): Unit = {
+    println(sys.env("snippet") + "!")
+  }
+}

integration/feature/editing/repo/mill-build/build.sc

@@ -0,0 +1,17 @@
+import mill._, scalalib._
+
+object millbuild extends runner.MillBuildModule{
+  def ivyDeps = Agg(ivy"com.lihaoyi::scalatags:${constant.MetaConstant.scalatagsVersion}")
+
+  def generatedSources = T {
+    os.write(
+      T.dest / "Constant.scala",
+      s"""package constant
+         |object Constant{
+         |  def scalatagsVersion = "${constant.MetaConstant.scalatagsVersion}"
+         |}
+         |""".stripMargin
+    )
+    super.generatedSources() ++ Seq(PathRef(T.dest / "Constant.scala"))
+  }
+}

integration/feature/editing/repo/mill-build/mill-build/build.sc

@@ -0,0 +1,16 @@
+// build.sc
+import mill._, scalalib._
+
+object millbuild extends runner.MillBuildModule {
+  def generatedSources = T{
+    os.write(
+      T.dest / "MetaConstant.scala",
+      """package constant
+        |object MetaConstant{
+        |  def scalatagsVersion = "0.8.2"
+        |}
+        |""".stripMargin
+    )
+    super.generatedSources() ++ Seq(PathRef(T.dest / "MetaConstant.scala"))
+  }
+}

integration/feature/editing/test/src/MultiLevelBuildTests.scala

@@ -0,0 +1,359 @@
+package mill.integration
+
+import mill.runner.RunnerState
+import utest._
+
+import scala.util.matching.Regex
+
+// Cause various kinds of changes - valid, parse errors, compile errors,
+// runtime errors - in various levels of build.sc meta-builds, ensuring
+// that the proper messages are reported, proper build classloaders are
+// re-used or invalidated, and the proper files end up getting watched
+// in all cases.
+object MultiLevelBuildTests extends IntegrationTestSuite {
+  val tests = Tests {
+    val wsRoot = initWorkspace()
+
+    def runAssertSuccess(expected: String) = {
+      val res = evalStdout("foo.run")
+      assert(res.isSuccess == true)
+      // Don't check foo.run stdout in local mode, because it the subprocess
+      // println is not properly captured by the test harness
+      if (integrationTestMode != "local") assert(res.out.contains(expected))
+    }
+
+    val fooPaths = Seq(
+      wsRoot / "foo" / "compile-resources",
+      wsRoot / "foo" / "resources",
+      wsRoot / "foo" / "src"
+    )
+    val buildPaths = Seq(
+      wsRoot / "build.sc",
+      wsRoot / "mill-build" / "compile-resources",
+      wsRoot / "mill-build" / "resources",
+      wsRoot / "mill-build" / "src"
+    )
+    val buildPaths2 = Seq(
+      wsRoot / "mill-build" / "build.sc",
+      wsRoot / "mill-build" / "mill-build" / "compile-resources",
+      wsRoot / "mill-build" / "mill-build" / "resources",
+      wsRoot / "mill-build" / "mill-build" / "src",
+    )
+    val buildPaths3 = Seq(
+      wsRoot / "mill-build" / "mill-build" / "build.sc",
+      wsRoot / "mill-build" / "mill-build" / "mill-build" / "compile-resources",
+      wsRoot / "mill-build" / "mill-build" / "mill-build" / "resources",
+      wsRoot / "mill-build" / "mill-build" / "mill-build" / "src"
+    )
+
+    def loadFrames(n: Int) = {
+      for(depth <- Range(0, n))
+      yield {
+        val path = wsRoot / "out" / Seq.fill(depth)("mill-build") / "mill-runner-state.json"
+        upickle.default.read[RunnerState.Frame.Logged](os.read(path)) -> path
+      }
+    }
+
+    /**
+     * Verify that each level of the multi-level build ends upcausing the
+     * appropriate files to get watched
+     */
+    def checkWatchedFiles(expected0: Seq[os.Path]*) = {
+      for((expectedWatched0, (frame, path)) <- expected0.zip(loadFrames(expected0.length))){
+        val frameWatched = frame.evalWatched.map(_.path).sorted
+        val expectedWatched = expectedWatched0.sorted
+        assert(frameWatched == expectedWatched)
+      }
+    }
+
+    def evalCheckErr(expected: String*) = {
+      val res = evalStdout("foo.run")
+      assert(res.isSuccess == false)
+      // Prepend a "\n" to allow callsites to use "\n" to test for start of
+      // line, even though the first line doesn't have a "\n" at the start
+      val err = "\n" + res.err
+      for (e <- expected) {
+        assert(err.contains(e))
+      }
+    }
+
+    var savedClassLoaderIds = Seq.empty[Option[Int]]
+
+    /**
+     * Check whether the classloaders of the nested meta-builds are changing as
+     * expected. `true` means a new classloader was created, `false` means
+     * the previous classloader was re-used, `null` means there is no
+     * classloader at that level
+     */
+    def checkChangedClassloaders(expectedChanged0: java.lang.Boolean*) = {
+      val currentClassLoaderIds =
+        for((frame, path) <- loadFrames(expectedChanged0.length))
+        yield frame.classLoaderIdentity
+
+      val changed = currentClassLoaderIds
+        .zipAll(savedClassLoaderIds, None, None)
+        .map{case (cur, old) =>
+          if (cur.isEmpty) null
+          else cur != old
+        }
+
+      val expectedChanged =
+        if (integrationTestMode != "fork") expectedChanged0
+        else expectedChanged0.map{case java.lang.Boolean.FALSE => true case n => n}
+
+      assert(changed == expectedChanged)
+
+      savedClassLoaderIds = currentClassLoaderIds
+    }
+
+    test("validEdits"){
+      runAssertSuccess("<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      // First run all classloaders are new, except level 0 running user code
+      // which doesn't need generate a classloader which never changes
+      checkChangedClassloaders(null, true, true, true)
+
+      mangleFile(wsRoot / "foo"  / "src" / "Example.scala", _.replace("!", "?"))
+      runAssertSuccess("<h1>hello</h1><p>world</p><p>0.8.2</p>?")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      // Second run with no build changes, all classloaders are unchanged
+      checkChangedClassloaders(null, false, false, false)
+
+      mangleFile(wsRoot / "build.sc", _.replace("hello", "HELLO"))
+      runAssertSuccess("<h1>HELLO</h1><p>world</p><p>0.8.2</p>?")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, false, false)
+
+      mangleFile(
+        wsRoot / "mill-build" / "build.sc",
+        _.replace("def scalatagsVersion = ", "def scalatagsVersion = \"changed-\" + ")
+      )
+      runAssertSuccess("<h1>HELLO</h1><p>world</p><p>changed-0.8.2</p>?")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, true, false)
+
+      mangleFile(
+        wsRoot / "mill-build" / "mill-build" / "build.sc",
+        _.replace("0.8.2", "0.12.0")
+      )
+      runAssertSuccess("<h1>HELLO</h1><p>world</p><p>changed-0.12.0</p>?")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, true, true)
+
+      mangleFile(
+        wsRoot / "mill-build" / "mill-build" / "build.sc",
+        _.replace("0.12.0", "0.8.2")
+      )
+      runAssertSuccess("<h1>HELLO</h1><p>world</p><p>changed-0.8.2</p>?")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, true, true)
+
+      mangleFile(
+        wsRoot / "mill-build" / "build.sc",
+        _.replace("def scalatagsVersion = \"changed-\" + ", "def scalatagsVersion = ")
+      )
+      runAssertSuccess("<h1>HELLO</h1><p>world</p><p>0.8.2</p>?")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, true, false)
+
+      mangleFile(wsRoot / "build.sc", _.replace("HELLO", "hello"))
+      runAssertSuccess("<h1>hello</h1><p>world</p><p>0.8.2</p>?")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, false, false)
+
+      mangleFile(wsRoot / "foo"  / "src" / "Example.scala", _.replace("?", "!"))
+      runAssertSuccess("<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, false, false, false)
+    }
+
+    test("parseErrorEdits") {
+      def causeParseError(p: os.Path) =
+        mangleFile(p, _.replace("extends", "extendx"))
+
+      def fixParseError(p: os.Path) =
+        mangleFile(p, _.replace("extendx", "extends"))
+
+      runAssertSuccess("<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, true, true)
+
+      causeParseError(wsRoot / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        "\ngenerateScriptSources build.sc"
+      )
+      checkWatchedFiles(Nil, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, false, false)
+
+      causeParseError(wsRoot / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        "\ngenerateScriptSources mill-build/build.sc"
+      )
+      checkWatchedFiles(Nil, Nil, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, null, false)
+
+      causeParseError(wsRoot / "mill-build" / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        "\ngenerateScriptSources mill-build/mill-build/build.sc"
+      )
+      checkWatchedFiles(Nil, Nil, Nil, buildPaths3)
+      checkChangedClassloaders(null, null, null, null)
+
+      fixParseError(wsRoot / "mill-build" / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        "\ngenerateScriptSources mill-build/build.sc"
+      )
+      checkWatchedFiles(Nil, Nil, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, null, true)
+
+      fixParseError(wsRoot / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        "\ngenerateScriptSources build.sc"
+      )
+      checkWatchedFiles(Nil, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, true, false)
+
+      fixParseError(wsRoot / "build.sc")
+      runAssertSuccess("<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, false, false)
+    }
+
+    test("compileErrorEdits") {
+      def causeCompileError(p: os.Path) =
+        mangleFile(p, _ + "\nimport doesnt.exist")
+
+      def fixCompileError(p: os.Path) =
+        mangleFile(p, _.replace("import doesnt.exist", ""))
+
+      runAssertSuccess("<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, true, true)
+
+      causeCompileError(wsRoot / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        // Ensure the file path in the compile error is properly adjusted to point
+        // at the original source file and not the generated file
+        (wsRoot / "build.sc").toString,
+        "not found: value doesnt"
+      )
+      checkWatchedFiles(Nil, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, false, false)
+
+      causeCompileError(wsRoot / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        (wsRoot / "mill-build" / "build.sc").toString,
+        "not found: value doesnt"
+      )
+      checkWatchedFiles(Nil, Nil, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, null, false)
+
+      causeCompileError(wsRoot / "mill-build" / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        (wsRoot / "mill-build" / "mill-build" / "build.sc").toString,
+        "not found: value doesnt"
+      )
+      checkWatchedFiles(Nil, Nil, Nil, buildPaths3)
+      checkChangedClassloaders(null, null, null, null)
+
+      fixCompileError(wsRoot / "mill-build" / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        (wsRoot / "mill-build" / "build.sc").toString,
+        "not found: value doesnt"
+      )
+      checkWatchedFiles(Nil, Nil, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, null, true)
+
+      fixCompileError(wsRoot / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        (wsRoot / "build.sc").toString,
+        "not found: value doesnt"
+      )
+      checkWatchedFiles(Nil, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, true, false)
+
+      fixCompileError(wsRoot / "build.sc")
+      runAssertSuccess("<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, false, false)
+    }
+
+    test("runtimeErrorEdits") {
+      val runErrorSnippet = """{
+          |override def runClasspath = T{
+          |  throw new Exception("boom")
+          |  super.runClasspath()
+          |}""".stripMargin
+
+      def causeRuntimeError(p: os.Path) =
+        mangleFile(p, _.replaceFirst("\\{", runErrorSnippet))
+
+      def fixRuntimeError(p: os.Path) =
+        mangleFile(p, _.replaceFirst(Regex.quote(runErrorSnippet), "\\{"))
+
+      runAssertSuccess("<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, true, true)
+
+      causeRuntimeError(wsRoot / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        "foo.runClasspath java.lang.Exception: boom"
+      )
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, false, false)
+
+      causeRuntimeError(wsRoot / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        "build.sc",
+        "runClasspath java.lang.Exception: boom"
+      )
+      checkWatchedFiles(Nil, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, true, false)
+
+      causeRuntimeError(wsRoot / "mill-build" / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        "build.sc",
+        "runClasspath java.lang.Exception: boom"
+      )
+      checkWatchedFiles(Nil, Nil, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, null, true)
+
+      fixRuntimeError(wsRoot / "mill-build" / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        "build.sc",
+        "runClasspath java.lang.Exception: boom"
+      )
+      checkWatchedFiles(Nil, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, null, true, true)
+
+      fixRuntimeError(wsRoot / "mill-build" / "build.sc")
+      evalCheckErr(
+        "\n1 targets failed",
+        "build.sc",
+        "foo.runClasspath java.lang.Exception: boom"
+      )
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, true, false)
+
+      fixRuntimeError(wsRoot / "build.sc")
+      runAssertSuccess("<h1>hello</h1><p>world</p><p>0.8.2</p>!")
+      checkWatchedFiles(fooPaths, buildPaths, buildPaths2, buildPaths3)
+      checkChangedClassloaders(null, true, false, false)
+
+    }
+  }
+}

integration/feature/foreign/test/src/ForeignBuildsTest.scala

@@ -0,0 +1,24 @@
+package mill.integration
+package local
+
+import utest._
+import utest.framework.TestPath
+
+object ForeignBuildsTest extends IntegrationTestSuite  {
+  override def buildPath = os.sub / "project" / "build.sc"
+
+  val tests = Tests {
+    initWorkspace()
+    def checkTarget()(implicit testPath: TestPath): Unit = assert(eval(testPath.value.last))
+    "checkProjectPaths" - checkTarget()
+    "checkInnerPaths" - checkTarget()
+    "checkOuterPaths" - checkTarget()
+    "checkOuterInnerPaths" - checkTarget()
+    "checkOtherPaths" - checkTarget()
+    "checkProjectDests" - checkTarget()
+    "checkInnerDests" - checkTarget()
+    "checkOuterDests" - checkTarget()
+    "checkOuterInnerDests" - checkTarget()
+    "checkOtherDests" - checkTarget()
+  }
+}

integration/feature/foreign/test/src/ForeignConflictTest.scala

@@ -0,0 +1,22 @@
+package mill.integration
+package local
+
+import utest._
+
+object ForeignConflictTest extends IntegrationTestSuite {
+
+  override def buildPath = os.sub / "conflict" / "build.sc"
+
+  val tests = Tests {
+    initWorkspace()
+    test("test") - {
+      // see https://github.com/lihaoyi/mill/issues/302
+      if (!mill.util.Util.java9OrAbove) {
+        assert(
+          eval("checkPaths"),
+          eval("checkDests")
+        )
+      }
+    }
+  }
+}

scalalib/test/src/mill/scalalib/GenIdeaExtendedTests.scala → integration/feature/gen-idea/test/src/GenIdeaExtendedTests.scala

@@ -1,17 +1,14 @@
-package mill.scalalib
+package mill.integration
+package local
 
-import scala.util.Try
-
-import mill.util.ScriptTestSuite
 import os.Path
 import utest._
 
-object GenIdeaExtendedTests extends ScriptTestSuite(false) {
+import scala.util.Try
 
-  override def workspaceSlug: String = "gen-idea-extended-hello-world"
+object GenIdeaExtendedTests extends IntegrationTestSuite {
 
-  override def scriptSourcePath: Path =
-    os.pwd / "scalalib" / "test" / "resources" / workspaceSlug
+  override def scriptSourcePath = super.scriptSourcePath / "extended"
 
   private val scalaVersionLibPart = "2_13_6"
 
@@ -35,8 +32,8 @@ object GenIdeaExtendedTests extends ScriptTestSuite(false) {
         os.sub / "compiler.xml"
       ).map { resource =>
         Try {
-          GenIdeaTests.assertIdeaXmlResourceMatchesFile(
-            workspaceSlug,
+          GenIdeaUtils.assertIdeaXmlResourceMatchesFile(
+            scriptSlug,
             workspacePath,
             resource
           )

integration/feature/gen-idea/test/src/GenIdeaTests.scala

@@ -0,0 +1,81 @@
+package mill.integration
+package local
+
+import os.Path
+import utest.{Tests, assert, _}
+
+
+import scala.util.Try
+import GenIdeaUtils._
+
+object GenIdeaTests extends IntegrationTestSuite {
+
+  override def scriptSourcePath = super.scriptSourcePath / "hello-world"
+  private val scalaVersionLibPart = "2_12_5"
+
+
+  def tests: Tests = Tests {
+    test("helper assertPartialContentMatches works") {
+      val testContent =
+        s"""line 1
+           |line 2
+           |line 3
+           |line 4
+           |""".stripMargin
+
+      assertPartialContentMatches(testContent, testContent)
+      intercept[utest.AssertionError] {
+        assertPartialContentMatches(testContent, "line 1")
+      }
+      assertPartialContentMatches(
+        found = testContent,
+        expected =
+          s"""line 1${ignoreString}line 4
+             |""".stripMargin
+      )
+      intercept[utest.AssertionError] {
+        assertPartialContentMatches(
+          found = testContent,
+          expected =
+            s"""line 1${ignoreString}line 2${ignoreString}line 2${ignoreString}line 4
+               |""".stripMargin
+        )
+      }
+      assertPartialContentMatches(
+        found = testContent,
+        expected = s"line 1${ignoreString}line 2$ignoreString"
+      )
+      intercept[utest.AssertionError] {
+        assertPartialContentMatches(
+          found = testContent,
+          expected = s"line 1${ignoreString}line 2${ignoreString}line 2$ignoreString"
+        )
+      }
+      ()
+    }
+
+    test("genIdeaTests") {
+      val workspacePath = initWorkspace()
+      eval("mill.scalalib.GenIdea/idea")
+
+      val checks = Seq(
+        os.sub / "mill_modules" / "helloworld.iml",
+        os.sub / "mill_modules" / "helloworld.test.iml",
+        os.sub / "mill_modules" / "mill-build.iml",
+        os.sub / "libraries" / s"scala_library_${scalaVersionLibPart}_jar.xml",
+        os.sub / "modules.xml",
+        os.sub / "misc.xml"
+      ).map { resource =>
+        Try {
+          assertIdeaXmlResourceMatchesFile(
+            scriptSlug,
+            workspacePath,
+            resource
+          )
+        }
+      }
+      assert(checks.forall(_.isSuccess))
+    }
+  }
+
+}

integration/feature/gen-idea/test/src/GenIdeaUtils.scala

@@ -0,0 +1,50 @@
+package mill.integration
+import java.util.regex.Pattern
+import scala.util.Try
+import utest.assert
+object GenIdeaUtils{
+
+  /**
+   * The resource content will loaded from the claspath and matched against the file.
+   * It may contain the `<!-- IGNORE -->` String, to simulate wildcard-matches.
+   */
+  def assertIdeaXmlResourceMatchesFile(workspaceSlug: String,
+                                       workspacePath: os.Path,
+                                       resource: os.RelPath): Unit = {
+    val expectedResourcePath = workspacePath / "idea" / resource
+    val actualResourcePath = workspacePath / ".idea" / resource
+
+    val expectedResourceString = os.read.lines(expectedResourcePath).mkString("\n")
+    val actualResourceString = normaliseLibraryPaths(os.read(actualResourcePath), workspacePath)
+
+    assertPartialContentMatches(
+      found = actualResourceString,
+      expected = expectedResourceString
+    )
+  }
+
+  def assertPartialContentMatches(found: String,
+                                  expected: String): Unit = {
+    if (!expected.contains(ignoreString)) {
+      assert(found == expected)
+    }
+
+    val pattern =
+      "(?s)^\\Q" + expected.replaceAll(Pattern.quote(ignoreString), "\\\\E.*\\\\Q") + "\\E$"
+    assert(Pattern.compile(pattern).matcher(found).matches())
+  }
+
+  private def normaliseLibraryPaths(in: String, workspacePath: os.Path): String = {
+    val coursierPath = os.Path(coursier.paths.CoursierPaths.cacheDirectory())
+    val path =
+      Try("$PROJECT_DIR$/" + coursierPath.relativeTo(workspacePath)).getOrElse(
+        coursierPath
+      ).toString().replace(
+        """\""",
+        "/"
+      )
+    in.replace(path, "COURSIER_HOME")
+  }
+
+  val ignoreString = "<!-- IGNORE -->"
+}

integration/local/src/mill/integration/HygieneTests.scala → integration/feature/hygiene/test/src/HygieneTests.scala

@@ -1,10 +1,8 @@
 package mill.integration
 
-import mill.util.ScriptTestSuite
 import utest._
 
-class HygieneTests(fork: Boolean, clientServer: Boolean)
-    extends IntegrationTestSuite("hygiene", fork, clientServer) {
+object HygieneTests extends IntegrationTestSuite {
   val tests = Tests {
     initWorkspace()
 

integration/local/src/mill/integration/ScriptsInvalidationForeignTests.scala → integration/feature/invalidation-foreign/test/src/ScriptsInvalidationForeignTests.scala

@@ -1,20 +1,18 @@
 package mill.integration
 
-import mill.util.ScriptTestSuite
 import os.Path
 import utest._
 
 import scala.collection.mutable
 
-class ScriptsInvalidationForeignTests(fork: Boolean, clientServer: Boolean)
-    extends IntegrationTestSuite("invalidation-foreign", fork, clientServer) {
+object ScriptsInvalidationForeignTests extends IntegrationTestSuite {
 
   override def buildPath = os.sub / "foreignA" / "build.sc"
 
   def runTask(task: String) = {
-    val (successful, stdout) = evalStdout(task)
-    assert(successful)
-    stdout.map(_.trim)
+    val res = evalStdout(task)
+    assert(res.isSuccess)
+    res.out.linesIterator.map(_.trim).toVector
   }
 
   val tests = Tests {

integration/local/src/mill/integration/ScriptsInvalidationTests.scala → integration/feature/invalidation/test/src/ScriptsInvalidationTests.scala

@@ -1,17 +1,15 @@
 package mill.integration
 
-import mill.util.ScriptTestSuite
 import utest._
 
 import scala.collection.mutable
 
-class ScriptsInvalidationTests(fork: Boolean, clientServer: Boolean)
-    extends IntegrationTestSuite("invalidation", fork, clientServer) {
+object ScriptsInvalidationTests extends IntegrationTestSuite {
 
   def runTask(task: String) = {
-    val (successful, stdout) = evalStdout(task)
-    assert(successful)
-    stdout.map(_.trim)
+    val res = evalStdout(task)
+    assert(res.isSuccess)
+    res.out.linesIterator.map(_.trim).toVector
   }
 
   val tests = Tests {

integration/feature/large-project/test/src/LargeProjectTests.scala

@@ -0,0 +1,13 @@
+package mill.integration
+
+import utest._
+
+object LargeProjectTests extends IntegrationTestSuite {
+  val tests = Tests {
+    initWorkspace()
+    test("test") - {
+
+      assert(eval("foo.common.one.compile"))
+    }
+  }
+}

integration/feature/mill-jvm-opts/test/src/MillJvmOptsTests.scala

@@ -0,0 +1,12 @@
+package mill.integration
+
+import utest._
+
+object MillJvmOptsTests extends IntegrationTestSuite {
+  val tests = Tests {
+    initWorkspace()
+    "JVM options from file .mill-jvm-opts are properly read" - {
+      if (integrationTestMode != "local") assert(eval("checkJvmOpts"))
+    }
+  }
+}

integration/local/src/mill/integration/ZincIncrementalCompilationTests.scala → integration/feature/zinc-incremental-compilation/test/src/ZincIncrementalCompilationTests.scala

@@ -3,8 +3,7 @@ package mill.integration
 import utest._
 
 // Regress test for issue https://github.com/com-lihaoyi/mill/issues/1901
-class ZincIncrementalCompilationTests(fork: Boolean, clientServer: Boolean)
-    extends IntegrationTestSuite("zinc-incremental-compilation", fork, clientServer) {
+object ZincIncrementalCompilationTests extends IntegrationTestSuite {
   val tests = Tests {
     initWorkspace()
     "incremental compilation only compiles changed files" - {

integration/src/mill/integration/ExampleTestSuite.scala

@@ -0,0 +1,60 @@
+package mill.integration
+import utest._
+object ExampleTestSuite extends IntegrationTestSuite{
+  val tests = Tests {
+    val workspaceRoot = initWorkspace()
+
+    test("exampleUsage") {
+      val usageComment =
+        os.read.lines(workspaceRoot / "build.sc")
+          .dropWhile(_ != "/* Example Usage")
+          .drop(1)
+          .takeWhile(_ != "*/")
+          .mkString("\n")
+
+      val commandBlocks = usageComment.trim.split("\n\n")
+
+      for(commandBlock <- commandBlocks){
+        val commandBlockLines = commandBlock.linesIterator.toVector
+        println("ExampleTestSuite: " + commandBlockLines.head)
+        commandBlockLines.head match{
+          case s"> ./$command" =>
+
+            val expectedSnippets = commandBlockLines.tail
+            val evalResult = command match{
+              case s"mill $rest" => evalStdout(rest.split(" "): _*)
+              case rest =>
+                val res = os.proc(rest.split(" ")).call(stdout=os.Pipe, stderr = os.Pipe, cwd = workspaceRoot)
+                IntegrationTestSuite.EvalResult(res.exitCode == 0, res.out.text(), res.err.text())
+            }
+
+            if (expectedSnippets.exists(_.startsWith("error: "))) assert(!evalResult.isSuccess)
+            else assert(evalResult.isSuccess)
+
+            val unwrappedExpected = expectedSnippets.map{
+              case s"error: $msg" => msg
+              case msg => msg
+            }
+
+            for (expected <- unwrappedExpected) {
+              if (integrationTestMode != "local") {
+                println("ExampleTestSuite expected: " + expected)
+                def plainText(s: String) =
+                  fansi.Str(s, errorMode = fansi.ErrorMode.Strip).plainText
+
+                assert(
+                  plainText(evalResult.err).contains(expected) ||
+                  plainText(evalResult.out).contains(expected)
+                )
+              }
+            }
+          case s"> cp -r $from $to" =>
+            os.copy(os.Path(from, workspaceRoot), os.Path(to, workspaceRoot))
+          case s"> sed -i 's/$oldStr/$newStr/g' $file" =>
+            mangleFile(os.Path(file, workspaceRoot), _.replace(oldStr, newStr))
+
+        }
+      }
+    }
+  }
+}

integration/src/mill/integration/IntegrationTestSuite.scala

@@ -0,0 +1,174 @@
+package mill.integration
+
+import mainargs.Flag
+import mill.MillCliConfig
+import mill.define.SelectMode
+import mill.runner.{MillBuildBootstrap, MillMain, RunnerState, Watching}
+import mill.util.SystemStreams
+import os.Path
+import utest._
+
+import java.io.{ByteArrayInputStream, ByteArrayOutputStream, PrintStream}
+import java.nio.file.NoSuchFileException
+import scala.util.control.NonFatal
+
+object IntegrationTestSuite{
+  case class EvalResult(isSuccess: Boolean, out: String, err: String)
+
+}
+
+abstract class IntegrationTestSuite extends TestSuite{
+  val scriptSlug: String = sys.env("MILL_INTEGRATION_TEST_SLUG")
+
+  val integrationTestMode: String = sys.env("MILL_INTEGRATION_TEST_MODE")
+  assert(Set("local", "fork", "server").contains(integrationTestMode))
+
+  def workspacePath: os.Path =
+    os.Path(sys.props.getOrElse("MILL_WORKSPACE_PATH", ???))
+
+  def scriptSourcePath: os.Path = os.Path(sys.env("MILL_INTEGRATION_REPO_ROOT"))
+
+  def buildPath: os.SubPath = os.sub / "build.sc"
+
+  def wd = workspacePath / buildPath / os.up
+
+  val stdIn = new ByteArrayInputStream(Array())
+  val disableTicker = false
+  val debugLog = false
+  val keepGoing = false
+  val userSpecifiedProperties = Map[String, String]()
+  val threadCount = sys.props.get("MILL_THREAD_COUNT").map(_.toInt).orElse(Some(1))
+
+  var runnerState = RunnerState.empty
+
+  private def runnerStdout(stdout: PrintStream, stderr: PrintStream, s: Seq[String]) = {
+
+    val streams = new SystemStreams(stdout, stderr, stdIn)
+    val config = MillCliConfig(
+      debugLog = Flag(debugLog),
+      keepGoing = Flag(keepGoing),
+      disableTicker = Flag(disableTicker)
+    )
+    val logger = mill.runner.MillMain.getLogger(
+      streams,
+      config,
+      mainInteractive = false,
+      enableTicker = Some(false)
+    )
+
+    val (isSuccess, newRunnerState) = Watching.watchLoop(
+      logger = logger,
+      ringBell = config.ringBell.value,
+      watch = config.watch.value,
+      streams = streams,
+      setIdle = _ => (),
+      evaluate = (prevStateOpt: Option[RunnerState]) => {
+        MillMain.adjustJvmProperties(userSpecifiedProperties, sys.props.toMap)
+        new MillBuildBootstrap(
+          projectRoot = wd,
+          config = config,
+          env = Map.empty,
+          threadCount = threadCount,
+          targetsAndParams = s.toList,
+          prevRunnerState = runnerState,
+          logger = logger,
+        ).evaluate()
+      }
+    )
+
+    runnerState = newRunnerState
+
+    (isSuccess, newRunnerState)
+  }
+
+  def eval(s: String*): Boolean = {
+    if (integrationTestMode == "local") runnerStdout(System.out, System.err, s)._1
+    else evalFork(os.Inherit, os.Inherit, s)
+  }
+
+  def evalStdout(s: String*): IntegrationTestSuite.EvalResult = {
+    if (integrationTestMode == "local") {
+      val outputStream = new ByteArrayOutputStream
+      val errorStream = new ByteArrayOutputStream
+      val printOutStream = new PrintStream(outputStream)
+      val printErrStream = new PrintStream(errorStream)
+      val result = runnerStdout(printOutStream, printErrStream, s.toList)
+      val stdoutArray = outputStream.toByteArray
+      val stdout: Seq[String] =
+        if (stdoutArray.isEmpty) Seq.empty
+        else new String(stdoutArray).split('\n')
+      val stderrArray = errorStream.toByteArray
+      val stderr: Seq[String] =
+        if (stderrArray.isEmpty) Seq.empty
+        else new String(stderrArray).split('\n')
+      IntegrationTestSuite.EvalResult(result._1, stdout.mkString("\n"), stderr.mkString("\n"))
+    } else {
+      val output = Seq.newBuilder[String]
+      val error = Seq.newBuilder[String]
+      val processOutput = os.ProcessOutput.Readlines(output += _)
+      val processError = os.ProcessOutput.Readlines(error += _)
+
+      val result = evalFork(processOutput, processError, s)
+      IntegrationTestSuite.EvalResult(result, output.result().mkString("\n"), error.result().mkString("\n"))
+    }
+  }
+
+  val millReleaseFileOpt = Option(System.getenv("MILL_TEST_RELEASE")).map(os.Path(_, os.pwd))
+  val millTestSuiteEnv = Map("MILL_TEST_SUITE" -> this.getClass().toString())
+
+  private def evalFork(stdout: os.ProcessOutput, stderr: os.ProcessOutput, s: Seq[String]): Boolean = {
+    val serverArgs = if (integrationTestMode == "server") Seq() else Seq("--no-server")
+    val debugArgs = if (debugLog) Seq("--debug") else Seq()
+    try {
+      os.proc(millReleaseFileOpt.get, serverArgs, debugArgs, s).call(
+        cwd = wd,
+        stdin = os.Inherit,
+        stdout = stdout,
+        stderr = stderr,
+        env = millTestSuiteEnv
+      )
+      true
+    } catch {
+      case NonFatal(_) => false
+    }
+  }
+
+  def meta(s: String): String = {
+    val Seq((List(selector), _)) =
+      mill.define.ParseArgs.apply(Seq(s), SelectMode.Single).getOrElse(???)
+
+    val segments = selector._2.value.flatMap(_.pathSegments)
+    os.read(wd / "out" / segments.init / s"${segments.last}.json")
+  }
+
+  def initWorkspace(): Path = {
+    os.remove.all(workspacePath)
+    os.makeDir.all(workspacePath / os.up)
+    // The unzipped git repo snapshots we get from github come with a
+    // wrapper-folder inside the zip file, so copy the wrapper folder to the
+    // destination instead of the folder containing the wrapper.
+
+    os.copy(scriptSourcePath, workspacePath)
+    workspacePath
+  }
+
+  def mangleFile(p: os.Path, f: String => String) = os.write.over(p, f(os.read(p)))
+
+  override def utestAfterEach(path: Seq[String]): Unit = {
+    runnerState = RunnerState.empty
+    if (integrationTestMode == "server") {
+      // try to stop the server
+      try {
+        os.proc(millReleaseFileOpt.get, "shutdown").call(
+          cwd = wd,
+          stdin = os.Inherit,
+          stdout = os.Inherit,
+          stderr = os.Inherit,
+          env = millTestSuiteEnv
+        )
+      } catch {
+        case NonFatal(e) =>
+      }
+    }
+  }
+}

integration/thirdparty/local/resources/acyclic/build.sc → integration/thirdparty/acyclic/repo/build.sc

@@ -28,4 +28,4 @@ class AcyclicModule(val crossScalaVersion: String) extends CrossSbtModule with P
       ivy"com.lihaoyi::utest:0.6.0"
     )
   }
-}
+}

integration/thirdparty/local/src/mill/integration/thirdparty/AcyclicTests.scala → integration/thirdparty/acyclic/test/src/AcyclicTests.scala

@@ -1,9 +1,9 @@
-package mill.integration.thirdparty
+package mill.integration
+package thirdparty
 
 import utest._
 
-class AcyclicTests(fork: Boolean)
-    extends IntegrationTestSuite("MILL_ACYCLIC_REPO", "acyclic", fork) {
+object AcyclicTests extends IntegrationTestSuite {
   val tests = Tests {
     initWorkspace()
 

integration/thirdparty/local/resources/ammonite/build.sc → integration/thirdparty/ammonite/repo/build.sc

@@ -174,7 +174,7 @@ object amm extends Cross[MainModule](fullCrossScalaVersions: _*) {
   }
 }
 class MainModule(val crossScalaVersion: String) extends AmmModule
-    with AmmDependenciesResourceFileModule {
+  with AmmDependenciesResourceFileModule {
 
   def artifactName = "ammonite"
 
@@ -293,13 +293,13 @@ def integrationTest(scalaVersion: String = sys.env("TRAVIS_SCALA_VERSION")) = T.
 }
 
 def generateConstantsFile(
-    version: String = buildVersion,
-    unstableVersion: String = "<fill-me-in-in-Constants.scala>",
-    curlUrl: String = "<fill-me-in-in-Constants.scala>",
-    unstableCurlUrl: String = "<fill-me-in-in-Constants.scala>",
-    oldCurlUrls: Seq[(String, String)] = Nil,
-    oldUnstableCurlUrls: Seq[(String, String)] = Nil
-)(implicit ctx: mill.api.Ctx.Dest) = {
+                           version: String = buildVersion,
+                           unstableVersion: String = "<fill-me-in-in-Constants.scala>",
+                           curlUrl: String = "<fill-me-in-in-Constants.scala>",
+                           unstableCurlUrl: String = "<fill-me-in-in-Constants.scala>",
+                           oldCurlUrls: Seq[(String, String)] = Nil,
+                           oldUnstableCurlUrls: Seq[(String, String)] = Nil
+                         )(implicit ctx: mill.api.Ctx.Dest) = {
   val versionTxt = s"""
     package ammonite
     object Constants{
@@ -312,8 +312,8 @@ def generateConstantsFile(
       )
       val oldUnstableCurlUrls = Seq[(String, String)](
         ${oldUnstableCurlUrls.map { case (name, value) => s""" "$name" -> "$value" """ }.mkString(
-      ",\n"
-    )}
+    ",\n"
+  )}
       )
     }
   """
@@ -324,10 +324,10 @@ def generateConstantsFile(
 }
 
 def generateDependenciesFile(
-    scalaVersion: String,
-    fileName: String,
-    deps: Seq[coursier.Dependency]
-)(implicit ctx: mill.api.Ctx.Dest) = {
+                              scalaVersion: String,
+                              fileName: String,
+                              deps: Seq[coursier.Dependency]
+                            )(implicit ctx: mill.api.Ctx.Dest) = {
 
   val dir = ctx.dest / "extra-resources"
   val dest = dir / fileName
@@ -347,4 +347,4 @@ def generateDependenciesFile(
   os.write(dest, content.getBytes("UTF-8"), createFolders = true)
 
   dir
-}
+}

integration/thirdparty/local/src/mill/integration/thirdparty/AmmoniteTests.scala → integration/thirdparty/ammonite/test/src/AmmoniteTests.scala

@@ -1,11 +1,11 @@
-package mill.integration.thirdparty
+package mill.integration
+package thirdparty
 
 import utest._
 
 import scala.util.Properties
 
-class AmmoniteTests(fork: Boolean)
-    extends IntegrationTestSuite("MILL_AMMONITE_REPO", "ammonite", fork) {
+object AmmoniteTests extends IntegrationTestSuite{
   val tests = Tests {
     initWorkspace()
 

integration/thirdparty/local/resources/caffeine/build.sc → integration/thirdparty/caffeine/repo/build.sc

@@ -154,4 +154,4 @@ object simulator extends CaffeineModule {
 
     def ivyDeps = super.ivyDeps() ++ testLibraries.testng
   }
-}
+}

integration/thirdparty/local/resources/caffeine/deps.sc → integration/thirdparty/caffeine/repo/deps.sc

@@ -131,4 +131,4 @@ object benchmarkLibraries {
   val rapidoid = ivy"org.rapidoid:rapidoid-commons:${benchmarkVersions.rapidoid}"
   val slf4jNop = ivy"org.slf4j:slf4j-nop:${benchmarkVersions.slf4j}"
   val tcache = ivy"com.trivago:triava:${benchmarkVersions.tcache}"
-}
+}

integration/thirdparty/local/src/mill/integration/thirdparty/CaffeineTests.scala → integration/thirdparty/caffeine/test/src/CaffeineTests.scala

@@ -1,9 +1,9 @@
-package mill.integration.thirdparty
+package mill.integration
+package thirdparty
 
 import utest._
 
-class CaffeineTests(fork: Boolean)
-    extends IntegrationTestSuite("MILL_CAFFEINE_REPO", "caffeine", fork) {
+object CaffeineTests extends IntegrationTestSuite {
 
   override def initWorkspace() = {
     val path = super.initWorkspace()
@@ -57,7 +57,7 @@ class CaffeineTests(fork: Boolean)
 
   val tests = Tests {
     initWorkspace()
-    "test" - {
+    test("test") - {
       // Caffeine only can build using Java 9 or up. Java 8 results in weird
       // type inference issues during the compile
       if (!mill.main.client.Util.isJava9OrAbove) {

integration/thirdparty/local/resources/jawn/build.sc → integration/thirdparty/jawn/repo/build.sc

@@ -59,4 +59,4 @@ class JawnModule(crossVersion: String) extends mill.Module {
     }
     object spray extends Support(ivy"io.spray::spray-json:1.3.3")
   }
-}
+}

integration/thirdparty/local/src/mill/integration/thirdparty/JawnTests.scala → integration/thirdparty/jawn/test/src/JawnTests.scala

@@ -1,9 +1,10 @@
-package mill.integration.thirdparty
+package mill.integration
+package thirdparty
 
 import mill.util.TestUtil
 import utest._
 
-class JawnTests(fork: Boolean) extends IntegrationTestSuite("MILL_JAWN_REPO", "jawn", fork) {
+object JawnTests extends IntegrationTestSuite {
   val tests = Tests {
     initWorkspace()
 

integration/thirdparty/local/resources/upickle/build.sc → integration/thirdparty/upickle/repo/build.sc

@@ -143,4 +143,4 @@ object test extends ScalaModule {
   def scalaVersion = scala212Version
   def moduleDeps = Seq(upickleJvm(scala212Version))
   def sources = T.sources { millSourcePath }
-}
+}

integration/thirdparty/local/src/mill/integration/thirdparty/UpickleTests.scala → integration/thirdparty/upickle/test/UpickleTests.scala

@@ -1,11 +1,11 @@
-package mill.integration.thirdparty
+package mill.integration
+package thirdparty
 
 import utest._
 
 import scala.util.Properties
 
-class UpickleTests(fork: Boolean)
-    extends IntegrationTestSuite("MILL_UPICKLE_REPO", "upickle", fork) {
+object UpickleTests extends ThirdPartyTestSuite("upickle") {
   val tests = Tests {
     initWorkspace()
     "jvm21111" - {

main/api/src/mill/api/PathRef.scala

@@ -20,7 +20,8 @@ case class PathRef private (
     revalidate: PathRef.Revalidate
 ) {
 
-  def validate(): Boolean = PathRef.apply(path, quick).sig == sig
+  def recomputeSig() = PathRef.apply(path, quick).sig
+  def validate(): Boolean = recomputeSig() == sig
 
   /* Hide case class specific copy method. */
   private def copy(

main/client/src/mill/main/client/IsolatedMillMainLoader.java

@@ -30,7 +30,7 @@ public static LoadResult load() {
             long startTime = System.currentTimeMillis();
             Optional<Method> millMainMethod = Optional.empty();
             try {
-                Class<?> millMainClass = IsolatedMillMainLoader.class.getClassLoader().loadClass("mill.MillMain");
+                Class<?> millMainClass = IsolatedMillMainLoader.class.getClassLoader().loadClass("mill.runner.MillMain");
                 Method mainMethod = millMainClass.getMethod("main", String[].class);
                 millMainMethod = Optional.of(mainMethod);
             } catch (ClassNotFoundException | NoSuchMethodException e) {
@@ -58,7 +58,7 @@ public static void runMain(String[] args) throws Exception {
                 mainMethod.invoke(null, new Object[]{args});
             }
         } else {
-            throw new RuntimeException("Cannot load mill.MillMain class");
+            throw new RuntimeException("Cannot load mill.runner.MillMain class");
         }
     }
 
@@ -67,7 +67,7 @@ private static int launchMillAsSubProcess(String[] args) throws Exception {
 
         List<String> l = new ArrayList<>();
         l.addAll(MillEnv.millLaunchJvmCommand(setJnaNoSys));
-        l.add("mill.MillMain");
+        l.add("mill.runner.MillMain");
         l.addAll(Arrays.asList(args));
 
         Process running = new ProcessBuilder()

main/client/src/mill/main/client/MillClientMain.java

@@ -43,7 +43,7 @@ public static final int ExitServerCodeWhenVersionMismatch() {
     static void initServer(String lockBase, boolean setJnaNoSys) throws IOException, URISyntaxException {
         List<String> l = new ArrayList<>();
         l.addAll(MillEnv.millLaunchJvmCommand(setJnaNoSys));
-        l.add("mill.main.MillServerMain");
+        l.add("mill.runner.MillServerMain");
         l.add(lockBase);
 
         File stdout = new java.io.File(lockBase + "/stdout");

main/core/src/mill/define/BaseModule.scala

@@ -1,4 +1,5 @@
 package mill.define
+import os.Path
 
 object BaseModule {
   case class Implicit(value: BaseModule)
@@ -35,6 +36,7 @@ abstract class BaseModule(
   override implicit def millModuleBasePath: Ctx.BasePath = Ctx.BasePath(millSourcePath)
   implicit def millImplicitBaseModule: BaseModule.Implicit = BaseModule.Implicit(this)
   def millDiscover: Discover[this.type]
+
 }
 
 abstract class ExternalModule(implicit

main/core/src/mill/define/Graph.scala

@@ -43,20 +43,20 @@ object Graph {
    * including the given targets.
    */
   def transitiveTargets(sourceTargets: Agg[Task[_]]): Agg[Task[_]] = {
-    transitiveNodes(sourceTargets)
+    transitiveNodes(sourceTargets)(_.inputs)
   }
 
   /**
    * Collects all transitive dependencies (nodes) of the given nodes,
    * including the given nodes.
    */
-  def transitiveNodes[T <: GraphNode[T]](sourceNodes: Agg[T]): Agg[T] = {
+  def transitiveNodes[T](sourceNodes: Agg[T])(inputsFor: T => Seq[T]): Agg[T] = {
     val transitiveNodes = new Agg.Mutable[T]
     def rec(t: T): Unit = {
       if (transitiveNodes.contains(t)) {} // do nothing
       else {
         transitiveNodes.append(t)
-        t.inputs.foreach(rec)
+        inputsFor(t).foreach(rec)
       }
     }
 

main/core/src/mill/define/Task.scala

@@ -14,7 +14,7 @@ import scala.reflect.macros.blackbox.Context
  * Generally not instantiated manually, but instead constructed via the
  * [[Target.apply]] & similar macros.
  */
-abstract class Task[+T] extends Task.Ops[T] with Applyable[Task, T] with GraphNode[Task[_]] {
+abstract class Task[+T] extends Task.Ops[T] with Applyable[Task, T] {
 
   /**
    * What other Targets does this Target depend on?

main/core/src/mill/define/Watchable.scala

@@ -0,0 +1,26 @@
+package mill.define
+
+import mill.api.internal
+
+/**
+ * Represents something that can be watched by the Mill build tool. Most often
+ * these are [[Watchable.Path]]s, but we use [[Watchable.Value]] to watch the
+ * value of arbitrary computations e.g. watching the result of `os.list` to
+ * react if a new folder is added.
+ */
+@internal
+trait Watchable {
+  def poll(): Long
+  def signature: Long
+  def validate(): Boolean = poll() == signature
+}
+@internal
+object Watchable{
+  case class Path(p: mill.api.PathRef) extends Watchable {
+    def poll() = p.recomputeSig()
+    def signature = p.sig
+  }
+  case class Value(f: () => Long, signature: Long) extends Watchable {
+    def poll() = f()
+  }
+}