Support module.sc files in subfolders

bsp/worker/src/mill/bsp/worker/State.scala

@@ -9,7 +9,7 @@ import mill.eval.Evaluator
 private class State(evaluators: Seq[Evaluator], debug: String => Unit) {
   lazy val bspModulesById: Map[BuildTargetIdentifier, (BspModule, Evaluator)] = {
     val modules: Seq[(Module, Seq[Module], Evaluator)] = evaluators
-      .map(ev => (ev.rootModule, JavaModuleUtils.transitiveModules(ev.rootModule), ev))
+      .flatMap(ev => ev.rootModules.map(rm => (rm, JavaModuleUtils.transitiveModules(rm), ev)))
 
     val map = modules
       .flatMap { case (rootModule, otherModules, eval) =>
@@ -28,7 +28,7 @@ private class State(evaluators: Seq[Evaluator], debug: String => Unit) {
     map
   }
 
-  lazy val rootModules: Seq[mill.define.BaseModule] = evaluators.map(_.rootModule)
+  lazy val rootModules: Seq[mill.define.BaseModule] = evaluators.flatMap(_.rootModules)
 
   lazy val bspIdByModule: Map[BspModule, BuildTargetIdentifier] =
     bspModulesById.view.mapValues(_._1).map(_.swap).toMap

build.sc

@@ -506,7 +506,11 @@ trait MillStableScalaModule extends MillPublishScalaModule with Mima {
     ),
     ProblemFilter.exclude[ReversedMissingMethodProblem](
       "mill.scalalib.JavaModule.mill$scalalib$JavaModule$$super$runMain"
-    )
+    ),
+
+    // Not sure why mima is picking up this stuff which is private[mill]
+    ProblemFilter.exclude[Problem]("mill.resolve.*.resolve0"),
+    ProblemFilter.exclude[Problem]("mill.resolve.*.resolveRootModule"),
   )
   def mimaPreviousVersions: T[Seq[String]] = Settings.mimaBaseVersions
 

ci/mill-bootstrap.patch

@@ -0,0 +1,13 @@
+diff --git a/build.sc b/build.sc
+index 526ebaa9cf..616be491f9 100644
+--- a/build.sc
++++ b/build.sc
+@@ -1968,7 +1968,7 @@ def uploadToGithub(authKey: String) = T.command {
+
+ private def resolveTasks[T](taskNames: String*): Seq[NamedTask[T]] = {
+   mill.resolve.Resolve.Tasks.resolve(
+-    build,
++    build.`package`,
+     taskNames,
+     SelectMode.Separated
+   ).map(x => x.asInstanceOf[Seq[mill.define.NamedTask[T]]]).getOrElse(???)

contrib/bloop/src/mill/contrib/bloop/BloopImpl.scala

@@ -120,7 +120,7 @@ class BloopImpl(evs: () => Seq[Evaluator], wd: os.Path) extends ExternalModule {
     val evals = evs()
     evals.flatMap { eval =>
       if (eval != null)
-        JavaModuleUtils.transitiveModules(eval.rootModule, accept)
+        eval.rootModules.flatMap(JavaModuleUtils.transitiveModules(_, accept))
           .collect { case jm: JavaModule => jm }
       else
         Seq.empty

contrib/scoverage/src/mill/contrib/scoverage/ScoverageReport.scala

@@ -91,15 +91,15 @@ trait ScoverageReport extends Module {
       dataTargets: String
   ): Task[PathRef] = {
     val sourcesTasks: Seq[Task[Seq[PathRef]]] = Resolve.Tasks.resolve(
-      evaluator.rootModule,
+      evaluator.rootModules,
       Seq(sources),
       SelectMode.Separated
     ) match {
       case Left(err) => throw new Exception(err)
       case Right(tasks) => tasks.asInstanceOf[Seq[Task[Seq[PathRef]]]]
     }
     val dataTasks: Seq[Task[PathRef]] = Resolve.Tasks.resolve(
-      evaluator.rootModule,
+      evaluator.rootModules,
       Seq(dataTargets),
       SelectMode.Separated
     ) match {

example/misc/8-multi-build-file/bar/qux/module.sc

@@ -0,0 +1,5 @@
+import mill._, scalalib._
+
+object module extends build.MyModule {
+  def ivyDeps = Agg(ivy"com.lihaoyi::scalatags:0.8.2")
+}

example/misc/8-multi-build-file/bar/qux/module/src/BarQux.scala

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

example/misc/8-multi-build-file/build.sc

@@ -0,0 +1,21 @@
+import mill._, scalalib._
+
+trait MyModule extends ScalaModule {
+  def scalaVersion = "2.13.11"
+}
+
+// Example Docs
+
+
+/** Usage
+
+> ./mill resolve __
+
+> ./mill bar.qux.module.compile
+
+> ./mill foo.compile
+
+> ./mill foo.run --foo-text hello --bar-qux-text world
+Foo.value: hello
+BarQux.value: <p>world</p>
+*/

example/misc/8-multi-build-file/foo/module.sc

@@ -0,0 +1,6 @@
+import mill._, scalalib._
+
+object build extends RootModule with MyModule {
+  def moduleDeps = Seq(bar.qux.module)
+  def ivyDeps = Agg(ivy"com.lihaoyi::mainargs:0.4.0")
+}

example/misc/8-multi-build-file/foo/src/Foo.scala

@@ -0,0 +1,14 @@
+package foo
+import mainargs.{main, ParserForMethods, arg}
+object Foo {
+  val value = "hello"
+
+  @main
+  def main(@arg(name = "foo-text") fooText: String,
+           @arg(name = "bar-qux-text") barQuxText: String): Unit = {
+    println("Foo.value: " + Foo.value)
+    bar.qux.BarQux.printText(barQuxText)
+  }
+
+  def main(args: Array[String]): Unit = ParserForMethods(this).runOrExit(args)
+}

example/src/mill/integration/ExampleTestSuite.scala

@@ -72,18 +72,17 @@ object ExampleTestSuite extends IntegrationTestSuite {
     }
 
     test("exampleUsage") {
+
       val parsed = upickle.default.read[Seq[(String, String)]](sys.env("MILL_EXAMPLE_PARSED"))
       val usageComment = parsed.collect { case ("example", txt) => txt }.mkString("\n\n")
       val commandBlocks = ("\n" + usageComment.trim).split("\n> ").filter(_.nonEmpty)
 
       retryOnTimeout(3) {
-        try {
-          for (commandBlock <- commandBlocks) processCommandBlock(workspaceRoot, commandBlock)
-          if (integrationTestMode != "fork") evalStdout("shutdown")
-        } finally {
-          try os.remove.all(workspaceRoot / "out")
-          catch { case e: Throwable => /*do nothing*/ }
-        }
+        try os.remove.all(workspaceRoot / "out")
+        catch { case e: Throwable => /*do nothing*/ }
+
+        for (commandBlock <- commandBlocks) processCommandBlock(workspaceRoot, commandBlock)
+        if (integrationTestMode != "fork") evalStdout("shutdown")
       }
     }
   }

idea/src/mill/idea/GenIdeaImpl.scala

@@ -22,7 +22,7 @@ case class GenIdeaImpl(
 )(implicit ctx: Ctx) {
   import GenIdeaImpl._
 
-  val workDir: os.Path = evaluators.head.rootModule.millSourcePath
+  val workDir: os.Path = evaluators.head.rootModules.head.millSourcePath
   val ideaDir: os.Path = workDir / ".idea"
 
   val ideaConfigVersion = 4
@@ -67,7 +67,9 @@ case class GenIdeaImpl(
       fetchMillModules: Boolean = true
   ): Seq[(os.SubPath, scala.xml.Node)] = {
 
-    val rootModules = evaluators.zipWithIndex.map { case (ev, idx) => (ev.rootModule, ev, idx) }
+    val rootModules = evaluators.zipWithIndex.map { case (ev, idx) =>
+      (ev.rootModules.head, ev, idx)
+    }
     val transitive: Seq[(BaseModule, Seq[Module], Evaluator, Int)] = rootModules
       .map { case (rootModule, ev, idx) =>
         (rootModule, JavaModuleUtils.transitiveModules(rootModule), ev, idx)
@@ -118,7 +120,7 @@ case class GenIdeaImpl(
     }
 
     // is head the right one?
-    val buildDepsPaths = Classpath.allJars(evaluators.head.rootModule.getClass.getClassLoader)
+    val buildDepsPaths = Classpath.allJars(evaluators.head.rootModules.head.getClass.getClassLoader)
       .map(url => os.Path(java.nio.file.Paths.get(url.toURI)))
 
     def resolveTasks: Map[Evaluator, Seq[Task[ResolvedModule]]] =

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

@@ -15,7 +15,7 @@ object CompileErrorTests extends IntegrationTestSuite {
       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"""
+        """build.sc:8:5: value noSuchMethod is not a member of object"""
       ))
     }
   }

integration/failure/cross-collisions/test/src/CrossCollisionsTests.scala

@@ -9,9 +9,10 @@ object CrossCollisionsTests extends IntegrationTestSuite {
     test("detect-collision") {
       val res = evalStdout("resolve", "foo._")
       assert(!res.isSuccess)
+      assert(res.err.contains("Cross module "))
       assert(
         res.err.contains(
-          "Cross module millbuild.build#foo contains colliding cross values: List(List(a, b), List(c)) and List(List(a), List(b, c))"
+          " contains colliding cross values: List(List(a, b), List(c)) and List(List(a), List(b, c))"
         )
       )
     }

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

@@ -10,7 +10,7 @@ object MultipleTopLevelModulesTests extends IntegrationTestSuite {
       val res = evalStdout("resolve", "_")
       assert(!res.isSuccess)
       assert(res.err.contains(
-        "Only one RootModule can be defined in a build, not 2: millbuild.build$bar$,millbuild.build$foo$"
+        "Only one RootModule can be defined in a build, not 2:"
       ))
     }
   }

integration/feature/bsp-modules/repo/build.sc

@@ -1,9 +1,6 @@
 import mill._
 import mill.api.{PathRef}
 import mill.scalalib._
-import $file.proj1.{build => proj1}
-import $file.proj2.{build => proj2}
-import $file.proj3.{build => proj3}
 
 trait HelloBspModule extends ScalaModule {
   def scalaVersion = sys.props.getOrElse("TEST_SCALA_2_13_VERSION", ???)
@@ -12,17 +9,17 @@ trait HelloBspModule extends ScalaModule {
 
 object HelloBsp extends HelloBspModule {
   // Explicitly depends on proj1
-  def moduleDeps: Seq[JavaModule] = Seq(proj1.proj1)
+  def moduleDeps: Seq[JavaModule] = Seq(build.proj1.module)
   // Explicitly depends on proj2
-  def compileModuleDeps: Seq[JavaModule] = Seq(proj2.proj2)
+  def compileModuleDeps: Seq[JavaModule] = Seq(build.proj2.module)
   // Implicitly depends on proj3 via a target
   override def unmanagedClasspath: T[Agg[PathRef]] = T {
-    Agg(proj3.proj3.jar())
+    Agg(build.proj3.module.jar())
   }
 }
 
 def validate() = T.command {
-  val transitiveModules = mill.scalalib.internal.JavaModuleUtils.transitiveModules(build)
+  val transitiveModules = mill.scalalib.internal.JavaModuleUtils.transitiveModules(build.`package`)
   val file = T.dest / "transitive-modules.json"
   val moduleNames = transitiveModules.map(m =>
     mill.scalalib.internal.ModuleUtils.moduleDisplayName(m)

integration/feature/bsp-modules/repo/proj1/build.sc → integration/feature/bsp-modules/repo/proj1/module.sc

@@ -1,6 +1,6 @@
 import mill._
 import mill.scalalib._
 
-object proj1 extends ScalaModule {
+object module extends ScalaModule {
   def scalaVersion = sys.props.getOrElse("TEST_SCALA_2_13_VERSION", ???)
 }

integration/feature/bsp-modules/repo/proj2/build.sc → integration/feature/bsp-modules/repo/proj2/module.sc

@@ -1,6 +1,6 @@
 import mill._
 import mill.scalalib._
 
-object proj2 extends ScalaModule {
+object module extends ScalaModule {
   def scalaVersion = sys.props.getOrElse("TEST_SCALA_2_13_VERSION", ???)
 }

integration/feature/bsp-modules/repo/proj3/build.sc → integration/feature/bsp-modules/repo/proj3/module.sc

@@ -1,6 +1,6 @@
 import mill._
 import mill.scalalib._
 
-object proj3 extends ScalaModule {
+object module extends ScalaModule {
   def scalaVersion = sys.props.getOrElse("TEST_SCALA_2_13_VERSION", ???)
 }

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

@@ -23,8 +23,8 @@ object BspModulesTests extends IntegrationTestSuite {
           "", // the root module has no segments at all
           "HelloBsp",
           "HelloBsp.test",
-          "foreign-modules.proj1.build.proj1",
-          "foreign-modules.proj2.build.proj2"
+          "proj1.module",
+          "proj2.module"
           // "foreign-modules.proj3.proj3" // still not detected
         ).sorted
         assert(readModules == expectedModules)

integration/feature/foreign/repo/conflict/build.sc

@@ -1,4 +1,4 @@
-import $file.inner.{build => innerBuild}
+import build.conflict.inner
 import mill._
 
 // In this build, we have a local module targeting

integration/feature/foreign/repo/outer/build.sc → integration/feature/foreign/repo/outer/module.sc

@@ -1,4 +1,4 @@
-import $file.inner.build
+
 import mill._
 
 trait PathAware extends mill.Module {