Merge branch 'master' into restore-master

# Conflicts:
#	.travis.yml
#	scalalib/src/mill/scalalib/Dep.scala

12 files changed, 153 insertions, 84 deletions

diff --git a/.travis.yml b/.travis.yml
index a989ab14..a419ea32 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,9 +5,6 @@ dist: trusty
 matrix:
   include:
   - stage: build
-    env: CI_SCRIPT=ci/test-mill-bootstrap.sh
-    jdk: oraclejdk9
-  - stage: build
     env: CI_SCRIPT=ci/test-mill-0.sh
     jdk: oraclejdk8
   - stage: build
@@ -18,16 +15,21 @@ matrix:
     jdk: oraclejdk8
   - stage: build
     env: CI_SCRIPT=ci/test-mill-dev.sh
-    jdk: oraclejdk9
+    jdk: oraclejdk8
   - stage: build
-    env: CI_SCRIPT=ci/test-mill-dev.sh
+    env: CI_SCRIPT=ci/test-mill-release.sh
     jdk: oraclejdk8
+
   - stage: build
     env: CI_SCRIPT=ci/test-mill-release.sh
     jdk: oraclejdk9
   - stage: build
-    env: CI_SCRIPT=ci/test-mill-release.sh
-    jdk: oraclejdk8
+    env: CI_SCRIPT=ci/test-mill-dev.sh
+    jdk: oraclejdk9
+  - stage: build
+    env: CI_SCRIPT=ci/test-mill-0.sh
+    jdk: oraclejdk9
+
   - stage: release
     env: CI_SCRIPT="ci/on-master.py ci/release.sh"
     jdk: oraclejdk8
diff --git a/integration/test/resources/play-json/build.sc b/integration/test/resources/play-json/build.sc
index e5222ae1..c60eefba 100644
--- a/integration/test/resources/play-json/build.sc
+++ b/integration/test/resources/play-json/build.sc
@@ -1,5 +1,5 @@
 import mill._, mill.scalalib._, mill.scalalib.publish._, mill.scalajslib._
-import $file.version
+import $file.playJsonVersion
 import $file.reformat
 import reformat.Scalariform
 import $file.mima
@@ -47,7 +47,7 @@ trait PlayJsonModule extends BaseModule with PublishModule with MiMa {
   def scalacOptions  = Seq("-deprecation", "-feature", "-unchecked", "-encoding", "utf8")
   def javacOptions = Seq("-encoding", "UTF-8", "-Xlint:-options")
 
-  def publishVersion = version.current
+  def publishVersion = playJsonVersion.current
 }
 
 abstract class PlayJson(val platformSegment: String) extends PlayJsonModule {
@@ -329,14 +329,14 @@ object release extends Module {
   private val ReleaseVersion = raw"""(\d+)\.(\d+)\.(\d+)""".r
   private val MinorSnapshotVersion = raw"""(\d+)\.(\d+)\.(\d+)-SNAPSHOT""".r
 
-  private val releaseVersion = version.current match {
+  private val releaseVersion = playJsonVersion.current match {
     case MinorSnapshotVersion(major, minor, patch) =>
       s"${major}.${minor}.${patch.toInt}"
     case ReleaseVersion(major, minor, patch) =>
       s"${major}.${minor}.${patch.toInt}"
   }
 
-  private val nextVersion = version.current match {
+  private val nextVersion = playJsonVersion.current match {
     case v@MinorSnapshotVersion(major, minor, patch) => v
     case ReleaseVersion(major, minor, patch) =>
       s"${major}.${minor}.${patch.toInt + 1}-SNAPSHOT"
diff --git a/integration/test/resources/play-json/mima.sc b/integration/test/resources/play-json/mima.sc
index ebab2c72..3902f2c7 100644
--- a/integration/test/resources/play-json/mima.sc
+++ b/integration/test/resources/play-json/mima.sc
@@ -18,12 +18,7 @@ trait MiMa extends ScalaModule with PublishModule {
 
   def previousDeps = T {
     Agg.from(previousVersions().map { version =>
-      Dep.Java(
-        pomSettings().organization,
-        artifactId(),
-        version,
-        cross = false
-      )
+      ivy"${pomSettings().organization}:${artifactId()}:${version}"
     })
   }
 
diff --git a/integration/test/resources/play-json/version.sc b/integration/test/resources/play-json/playJsonVersion.sc
index e9dbb12f..e9dbb12f 100644
--- a/integration/test/resources/play-json/version.sc
+++ b/integration/test/resources/play-json/playJsonVersion.sc
diff --git a/main/test/src/mill/eval/JavaCompileJarTests.scala b/main/test/src/mill/eval/JavaCompileJarTests.scala
index 1ac00c79..2e73b339 100644
--- a/main/test/src/mill/eval/JavaCompileJarTests.scala
+++ b/main/test/src/mill/eval/JavaCompileJarTests.scala
@@ -11,10 +11,10 @@ import mill.util.Strict.Agg
 import utest._
 import mill._
 object JavaCompileJarTests extends TestSuite{
-  def compileAll(sources: Seq[PathRef])(implicit ctx: Dest) = {
+  def compileAll(sources: mill.util.Loose.Agg[PathRef])(implicit ctx: Dest) = {
     mkdir(ctx.dest)
     import ammonite.ops._
-    %("javac", sources.map(_.path.toString()), "-d", ctx.dest)(wd = ctx.dest)
+    %("javac", sources.map(_.path.toString()).toSeq, "-d", ctx.dest)(wd = ctx.dest)
     PathRef(ctx.dest)
   }
 
diff --git a/main/test/src/mill/util/ScriptTestSuite.scala b/main/test/src/mill/util/ScriptTestSuite.scala
index a2f2676a..2df1c0c0 100644
--- a/main/test/src/mill/util/ScriptTestSuite.scala
+++ b/main/test/src/mill/util/ScriptTestSuite.scala
@@ -10,8 +10,8 @@ abstract class ScriptTestSuite(fork: Boolean) extends TestSuite{
   def scriptSourcePath: Path
 
   val workspacePath = pwd / 'target / 'workspace / workspaceSlug
-  val stdOutErr = new PrintStream(new ByteArrayOutputStream())
-//  val stdOutErr = new PrintStream(System.out)
+//  val stdOutErr = new PrintStream(new ByteArrayOutputStream())
+  val stdOutErr = new PrintStream(System.out)
   val stdIn = new ByteArrayInputStream(Array())
   lazy val runner = new mill.main.MainRunner(
     ammonite.main.Cli.Config(wd = workspacePath),
@@ -21,7 +21,7 @@ abstract class ScriptTestSuite(fork: Boolean) extends TestSuite{
     if (!fork) runner.runScript(workspacePath / "build.sc", s.toList)
     else{
       try {
-        %%(home / "mill-release", "-i", s)(workspacePath)
+        %(home / "mill-release", "-i", s)(workspacePath)
         true
       }catch{case e: Throwable => false}
     }
diff --git a/scalalib/src/mill/scalalib/Dep.scala b/scalalib/src/mill/scalalib/Dep.scala
index f67eed03..9719bd2d 100644
--- a/scalalib/src/mill/scalalib/Dep.scala
+++ b/scalalib/src/mill/scalalib/Dep.scala
@@ -3,20 +3,24 @@ import mill.util.JsonFormatters._
 import upickle.default.{macroRW, ReadWriter => RW}
 sealed trait Dep {
   def configure(attributes: coursier.Attributes): Dep
-  def exclude(exclusions: (String, String)*): Dep =
-    this match {
-      case dep : Dep.Java => dep.copy(dep = dep.dep.copy(exclusions = dep.dep.exclusions ++ exclusions))
-      case dep : Dep.Scala => dep.copy(dep = dep.dep.copy(exclusions = dep.dep.exclusions ++ exclusions))
-      case dep : Dep.Point => dep.copy(dep = dep.dep.copy(exclusions = dep.dep.exclusions ++ exclusions))
-    }
+  def force: Boolean
+  def forceVersion(): Dep = this match {
+    case dep : Dep.Java => dep.copy(force = true)
+    case dep : Dep.Scala => dep.copy(force = true)
+    case dep : Dep.Point => dep.copy(force = true)
+  }
+  def exclude(exclusions: (String, String)*): Dep = this match {
+    case dep : Dep.Java => dep.copy(dep = dep.dep.copy(exclusions = dep.dep.exclusions ++ exclusions))
+    case dep : Dep.Scala => dep.copy(dep = dep.dep.copy(exclusions = dep.dep.exclusions ++ exclusions))
+    case dep : Dep.Point => dep.copy(dep = dep.dep.copy(exclusions = dep.dep.exclusions ++ exclusions))
+  }
   def excludeOrg(organizations: String*): Dep = exclude(organizations.map(_ -> "*"): _*)
   def excludeName(names: String*): Dep = exclude(names.map("*" -> _): _*)
-  def withConfiguration(configuration: String): Dep =
-    this match {
-      case dep : Dep.Java => dep.copy(dep = dep.dep.copy(configuration = configuration))
-      case dep : Dep.Scala => dep.copy(dep = dep.dep.copy(configuration = configuration))
-      case dep : Dep.Point => dep.copy(dep = dep.dep.copy(configuration = configuration))
-    }
+  def withConfiguration(configuration: String): Dep = this match {
+    case dep : Dep.Java => dep.copy(dep = dep.dep.copy(configuration = configuration))
+    case dep : Dep.Scala => dep.copy(dep = dep.dep.copy(configuration = configuration))
+    case dep : Dep.Point => dep.copy(dep = dep.dep.copy(configuration = configuration))
+  }
 }
 object Dep{
 
@@ -33,45 +37,45 @@ object Dep{
       }
     }
     (module.split(':') match {
-      case Array(a, b, c) => Dep.Java(a, b, c, cross = false)
-      case Array(a, b, "", c) => Dep.Java(a, b, c, cross = true)
-      case Array(a, "", b, c) => Dep.Scala(a, b, c, cross = false)
-      case Array(a, "", b, "", c) => Dep.Scala(a, b, c, cross = true)
-      case Array(a, "", "", b, c) => Dep.Point(a, b, c, cross = false)
-      case Array(a, "", "", b, "", c) => Dep.Point(a, b, c, cross = true)
+      case Array(a, b, c) => Dep.Java(a, b, c, cross = false, force = false)
+      case Array(a, b, "", c) => Dep.Java(a, b, c, cross = true, force = false)
+      case Array(a, "", b, c) => Dep.Scala(a, b, c, cross = false, force = false)
+      case Array(a, "", b, "", c) => Dep.Scala(a, b, c, cross = true, force = false)
+      case Array(a, "", "", b, c) => Dep.Point(a, b, c, cross = false, force = false)
+      case Array(a, "", "", b, "", c) => Dep.Point(a, b, c, cross = true, force = false)
       case _ => throw new Exception(s"Unable to parse signature: [$signature]")
     }).configure(attributes = attributes)
   }
   def apply(org: String, name: String, version: String, cross: Boolean): Dep = {
     this(coursier.Dependency(coursier.Module(org, name), version, DefaultConfiguration), cross)
   }
-  case class Java(dep: coursier.Dependency, cross: Boolean) extends Dep {
+  case class Java(dep: coursier.Dependency, cross: Boolean, force: Boolean) extends Dep {
     def configure(attributes: coursier.Attributes): Dep = copy(dep = dep.copy(attributes = attributes))
   }
   object Java{
     implicit def rw: RW[Java] = macroRW
-    def apply(org: String, name: String, version: String, cross: Boolean): Dep = {
-      Java(coursier.Dependency(coursier.Module(org, name), version, DefaultConfiguration), cross)
+    def apply(org: String, name: String, version: String, cross: Boolean, force: Boolean): Dep = {
+      Java(coursier.Dependency(coursier.Module(org, name), version, DefaultConfiguration), cross, force)
     }
   }
-  implicit def default(dep: coursier.Dependency): Dep = new Java(dep, false)
-  def apply(dep: coursier.Dependency, cross: Boolean) = Scala(dep, cross)
-  case class Scala(dep: coursier.Dependency, cross: Boolean) extends Dep {
+  implicit def default(dep: coursier.Dependency): Dep = new Java(dep, false, false)
+  def apply(dep: coursier.Dependency, cross: Boolean) = Scala(dep, cross, false)
+  case class Scala(dep: coursier.Dependency, cross: Boolean, force: Boolean) extends Dep {
     def configure(attributes: coursier.Attributes): Dep = copy(dep = dep.copy(attributes = attributes))
   }
   object Scala{
     implicit def rw: RW[Scala] = macroRW
-    def apply(org: String, name: String, version: String, cross: Boolean): Dep = {
-      Scala(coursier.Dependency(coursier.Module(org, name), version, DefaultConfiguration), cross)
+    def apply(org: String, name: String, version: String, cross: Boolean, force: Boolean): Dep = {
+      Scala(coursier.Dependency(coursier.Module(org, name), version, DefaultConfiguration), cross, force)
     }
   }
-  case class Point(dep: coursier.Dependency, cross: Boolean) extends Dep {
+  case class Point(dep: coursier.Dependency, cross: Boolean, force: Boolean) extends Dep {
     def configure(attributes: coursier.Attributes): Dep = copy(dep = dep.copy(attributes = attributes))
   }
   object Point{
     implicit def rw: RW[Point] = macroRW
-    def apply(org: String, name: String, version: String, cross: Boolean): Dep = {
-      Point(coursier.Dependency(coursier.Module(org, name), version, DefaultConfiguration), cross)
+    def apply(org: String, name: String, version: String, cross: Boolean, force: Boolean): Dep = {
+      Point(coursier.Dependency(coursier.Module(org, name), version, DefaultConfiguration), cross, force)
     }
   }
   implicit def rw = RW.merge[Dep](
diff --git a/scalalib/src/mill/scalalib/Lib.scala b/scalalib/src/mill/scalalib/Lib.scala
index e6a7a255..46296333 100644
--- a/scalalib/src/mill/scalalib/Lib.scala
+++ b/scalalib/src/mill/scalalib/Lib.scala
@@ -36,7 +36,7 @@ object Lib{
 
   def depToDependency(dep: Dep, scalaVersion: String, platformSuffix: String = ""): Dependency =
     dep match {
-      case Dep.Java(dep, cross) =>
+      case Dep.Java(dep, cross, force) =>
         dep.copy(
           module = dep.module.copy(
             name =
@@ -44,7 +44,7 @@ object Lib{
               (if (!cross) "" else platformSuffix)
           )
         )
-      case Dep.Scala(dep, cross) =>
+      case Dep.Scala(dep, cross, force) =>
         dep.copy(
           module = dep.module.copy(
             name =
@@ -53,7 +53,7 @@ object Lib{
               "_" + scalaBinaryVersion(scalaVersion)
           )
         )
-      case Dep.Point(dep, cross) =>
+      case Dep.Point(dep, cross, force) =>
         dep.copy(
           module = dep.module.copy(
             name =
@@ -65,7 +65,30 @@ object Lib{
     }
 
 
+  def resolveDependenciesMetadata(repositories: Seq[Repository],
+                                  scalaVersion: String,
+                                  deps: TraversableOnce[Dep],
+                                  platformSuffix: String = "",
+                                  mapDependencies: Option[Dependency => Dependency] = None) = {
+    val depSeq = deps.toSeq
+    val flattened = depSeq.map(depToDependency(_, scalaVersion, platformSuffix))
+
+    val forceVersions = depSeq.filter(_.force)
+      .map(depToDependency(_, scalaVersion, platformSuffix))
+      .map(mapDependencies.getOrElse(identity[Dependency](_)))
+      .map{d => d.module -> d.version}
+      .toMap
+
+    val start = Resolution(
+      flattened.map(mapDependencies.getOrElse(identity[Dependency](_))).toSet,
+      forceVersions = forceVersions,
+      mapDependencies = mapDependencies
+    )
 
+    val fetch = Fetch.from(repositories, Cache.fetch())
+    val resolution = start.process.run(fetch).unsafePerformSync
+    (flattened, resolution)
+  }
   /**
     * Resolve dependencies using Coursier.
     *
@@ -77,13 +100,12 @@ object Lib{
                           scalaVersion: String,
                           deps: TraversableOnce[Dep],
                           platformSuffix: String = "",
-                          sources: Boolean = false): Result[Agg[PathRef]] = {
+                          sources: Boolean = false,
+                          mapDependencies: Option[Dependency => Dependency] = None): Result[Agg[PathRef]] = {
 
-    val flattened = deps.map(depToDependency(_, scalaVersion, platformSuffix)).toSet
-    val start = Resolution(flattened)
-
-    val fetch = Fetch.from(repositories, Cache.fetch())
-    val resolution = start.process.run(fetch).unsafePerformSync
+    val (_, resolution) = resolveDependenciesMetadata(
+      repositories, scalaVersion, deps, platformSuffix, mapDependencies
+    )
     val errs = resolution.metadataErrors
     if(errs.nonEmpty) {
       val header =
@@ -130,16 +152,17 @@ object Lib{
     }
   }
   def scalaCompilerIvyDeps(scalaVersion: String) = Agg[Dep](
-    ivy"org.scala-lang:scala-compiler:$scalaVersion",
-    ivy"org.scala-lang:scala-reflect:$scalaVersion"
+    ivy"org.scala-lang:scala-compiler:$scalaVersion".forceVersion(),
+    ivy"org.scala-lang:scala-reflect:$scalaVersion".forceVersion()
   )
   def scalaRuntimeIvyDeps(scalaVersion: String) = Agg[Dep](
-    ivy"org.scala-lang:scala-library:$scalaVersion"
+    ivy"org.scala-lang:scala-library:$scalaVersion".forceVersion()
   )
   def compilerBridgeIvyDep(scalaVersion: String) =
     Dep.Point(
       coursier.Dependency(coursier.Module("com.lihaoyi", "mill-bridge"), "0.1", transitive = false),
-      cross = false
+      cross = false,
+      force = false
     )
 
 }
diff --git a/scalalib/src/mill/scalalib/ScalaModule.scala b/scalalib/src/mill/scalalib/ScalaModule.scala
index 33905a7e..562b60d6 100644
--- a/scalalib/src/mill/scalalib/ScalaModule.scala
+++ b/scalalib/src/mill/scalalib/ScalaModule.scala
@@ -2,7 +2,7 @@ package mill
 package scalalib
 
 import ammonite.ops._
-import coursier.Repository
+import coursier.{Dependency, Repository}
 import mill.define.Task
 import mill.define.TaskModule
 import mill.eval.{PathRef, Result}
@@ -22,6 +22,7 @@ trait ScalaModule extends mill.Module with TaskModule { outer =>
     override def repositories = outer.repositories
     override def scalacPluginIvyDeps = outer.scalacPluginIvyDeps
     override def scalacOptions = outer.scalacOptions
+    override def javacOptions = outer.javacOptions
     override def scalaWorker = outer.scalaWorker
     override def moduleDeps = Seq(outer)
   }
@@ -85,13 +86,16 @@ trait ScalaModule extends mill.Module with TaskModule { outer =>
     )().flatten
   }
 
+  def mapDependencies(d: coursier.Dependency) = d
+
   def resolveDeps(deps: Task[Agg[Dep]], sources: Boolean = false) = T.task{
     resolveDependencies(
       repositories,
       scalaVersion(),
       deps(),
       platformSuffix(),
-      sources
+      sources,
+      mapDependencies = Some(mapDependencies)
     )
   }
 
@@ -262,12 +266,9 @@ trait ScalaModule extends mill.Module with TaskModule { outer =>
   }
 
   def ivyDepsTree(inverse: Boolean = false) = T.command {
-    import coursier.{Cache, Fetch, Resolution}
-
-    val flattened = ivyDeps().map(depToDependency(_, scalaVersion(), platformSuffix())).toSeq
-    val start = Resolution(flattened.toSet)
-    val fetch = Fetch.from(repositories, Cache.fetch())
-    val resolution = start.process.run(fetch).unsafePerformSync
+    val (flattened, resolution) = Lib.resolveDependenciesMetadata(
+      repositories, scalaVersion(), ivyDeps(), platformSuffix(), Some(mapDependencies)
+    )
 
     println(coursier.util.Print.dependencyTree(flattened, resolution,
       printExclusions = false, reverse = inverse))
@@ -329,15 +330,22 @@ trait ScalaModule extends mill.Module with TaskModule { outer =>
   }
 
   def ammoniteReplClasspath = T{
-    resolveDeps(T.task{Agg(ivy"com.lihaoyi:::ammonite:1.1.0-7-33b728c")})()
+    localClasspath() ++
+    transitiveLocalClasspath() ++
+    unmanagedClasspath() ++
+    resolveDeps(T.task{
+      runIvyDeps() ++ scalaLibraryIvyDeps() ++ transitiveIvyDeps() ++
+      Agg(ivy"com.lihaoyi:::ammonite:1.1.0-7-33b728c")
+    })()
   }
+
   def repl() = T.command{
     if (T.ctx().log.inStream == DummyInputStream){
       Result.Failure("repl needs to be run with the -i/--interactive flag")
     }else{
       Jvm.interactiveSubprocess(
         mainClass = "ammonite.Main",
-        classPath = runClasspath().map(_.path) ++ ammoniteReplClasspath().map(_.path),
+        classPath = ammoniteReplClasspath().map(_.path),
         mainArgs = Nil,
         workingDir = pwd
       )
diff --git a/scalalib/src/mill/scalalib/publish/settings.scala b/scalalib/src/mill/scalalib/publish/settings.scala
index 34f7e7ad..596f29c9 100644
--- a/scalalib/src/mill/scalalib/publish/settings.scala
+++ b/scalalib/src/mill/scalalib/publish/settings.scala
@@ -12,14 +12,14 @@ object Artifact {
               scalaFull: String,
               scalaBin: String): Dependency = {
     dep match {
-      case Dep.Java(dep, cross) =>
+      case Dep.Java(dep, cross, force) =>
         Dependency(
           Artifact(dep.module.organization, dep.module.name, dep.version),
           Scope.Compile,
           if (dep.configuration == "" ) None else Some(dep.configuration),
           dep.exclusions.toList
         )
-      case Dep.Scala(dep, cross) =>
+      case Dep.Scala(dep, cross, force) =>
         Dependency(
           Artifact(
             dep.module.organization,
@@ -30,7 +30,7 @@ object Artifact {
           if (dep.configuration == "") None else Some(dep.configuration),
           dep.exclusions.toList
         )
-      case Dep.Point(dep, cross) =>
+      case Dep.Point(dep, cross, force) =>
         Dependency(
           Artifact(
             dep.module.organization,
diff --git a/scalalib/test/src/mill/scalalib/HelloWorldTests.scala b/scalalib/test/src/mill/scalalib/HelloWorldTests.scala
index 74078221..d6980314 100644
--- a/scalalib/test/src/mill/scalalib/HelloWorldTests.scala
+++ b/scalalib/test/src/mill/scalalib/HelloWorldTests.scala
@@ -98,6 +98,24 @@ object HelloWorldTests extends TestSuite {
       override def ivyDeps = Agg(ivy"com.lihaoyi::sourcecode:0.1.4")
     }
   }
+
+  object HelloWorldTypeLevel extends HelloBase{
+    object foo extends ScalaModule {
+      def scalaVersion = "2.11.8"
+      override def mapDependencies(d: coursier.Dependency) = {
+        val artifacts = Set("scala-library", "scala-compiler", "scala-reflect")
+        if (d.module.organization != "org.scala-lang" || !artifacts(d.module.name)) d
+        else d.copy(module = d.module.copy(organization = "org.typelevel"))
+      }
+
+      def ivyDeps = Agg(
+        ivy"com.github.julien-truffaut::monocle-macro::1.4.0"
+      )
+      def scalacPluginIvyDeps = super.scalacPluginIvyDeps() ++ Agg(
+        ivy"org.scalamacros:::paradise:2.1.0"
+      )
+    }
+  }
   val resourcePath = pwd / 'scalalib / 'test / 'resources / "hello-world"
 
   def jarMainClass(jar: JarFile): Option[String] = {
@@ -438,6 +456,25 @@ object HelloWorldTests extends TestSuite {
         !result2.exists(_.path.last == "sourcecode_2.12-0.1.3.jar")
       )
     }
+    'typeLevel - workspaceTest(HelloWorldTypeLevel){ eval =>
+      val classPathsToCheck = Seq(
+        HelloWorldTypeLevel.foo.runClasspath,
+        HelloWorldTypeLevel.foo.ammoniteReplClasspath,
+        HelloWorldTypeLevel.foo.compileClasspath
+      )
+      for(cp <- classPathsToCheck){
+        val Right((result, _)) = eval.apply(cp)
+        assert(
+          // Make sure every relevant piece org.scala-lang has been substituted for org.typelevel
+          !result.map(_.toString).exists(x =>
+            x.contains("scala-lang") &&
+            (x.contains("scala-library") || x.contains("scala-compiler") || x.contains("scala-reflect"))
+          ),
+          result.map(_.toString).exists(x => x.contains("typelevel") && x.contains("scala-library"))
+
+        )
+      }
+    }
   }
 
 
diff --git a/scalalib/test/src/mill/scalalib/publish/IvyTests.scala b/scalalib/test/src/mill/scalalib/publish/IvyTests.scala
index 0f275dd9..d187f969 100644
--- a/scalalib/test/src/mill/scalalib/publish/IvyTests.scala
+++ b/scalalib/test/src/mill/scalalib/publish/IvyTests.scala
@@ -26,9 +26,9 @@ object IvyTests extends TestSuite {
       'topLevel - {
         val info = singleNode(fullIvy \ "info")
         assert(
-          singleAttr(info, "organisation") == artifact.group
-        , singleAttr(info, "module") == artifact.id
-        , singleAttr(info, "revision") == artifact.version
+          singleAttr(info, "organisation") == artifact.group,
+          singleAttr(info, "module") == artifact.id,
+          singleAttr(info, "revision") == artifact.version
         )
       }
 
@@ -40,10 +40,10 @@ object IvyTests extends TestSuite {
 
         dependencies.zipWithIndex.foreach { case (dep, index) =>
           assert(
-            singleAttr(dep, "org") == ivyDeps(index).artifact.group
-          , singleAttr(dep, "name") == ivyDeps(index).artifact.id
-          , singleAttr(dep, "rev") == ivyDeps(index).artifact.version
-          , (dep \ "exclude").zipWithIndex forall { case (exclude, j) =>
+            singleAttr(dep, "org") == ivyDeps(index).artifact.group,
+            singleAttr(dep, "name") == ivyDeps(index).artifact.id,
+            singleAttr(dep, "rev") == ivyDeps(index).artifact.version,
+            (dep \ "exclude").zipWithIndex forall { case (exclude, j) =>
               singleAttr(exclude, "org") == ivyDeps(index).exclusions(j)._1 &&
                 singleAttr(exclude, "name") == ivyDeps(index).exclusions(j)._2
             }