Scala doc support for MillSome of mill projects are added to community build as well.

Author: romanowski

community-build/src/scala/dotty/communitybuild/Main.scala

@@ -19,32 +19,34 @@ object Main:
         e.printStackTrace()
         Nil
 
-  def withProjects[T](names: Seq[String], opName: String)(op: CommunityProject => Unit): Unit =
+  def withProjects[T](names: Seq[String], opName: String)(op: CommunityProject => T): Seq[T] =
     val missing = names.filterNot(projectMap.contains)
     if missing.nonEmpty then
-      println(s"Missing projects: ${missing.mkString(", ")}. All projects: ${allProjects.mkString(", ")}")
+      val allNames = allProjects.map(_.project).mkString(", ")
+      println(s"Missing projects: ${missing.mkString(", ")}. All projects: $allNames")
       sys.exit(1)
 
-    val failed = names.flatMap( o =>
+    val (failed, completed) = names.flatMap(projectMap.apply).partitionMap( o =>
       try
-        op(projectMap(o))
-        None
+        Right(op(o))
       catch case e: Throwable =>
         e.printStackTrace()
-        Some(o)
+        Left(o)
     )
 
     if failed.nonEmpty then
       println(s"$opName failed for ${failed.mkString(", ")}")
       sys.exit(1)
 
+    completed
+
   /** Allows running various commands on community build projects. */
   def main(args: Array[String]): Unit =
     args.toList match
-      case "publish" :: names  =>
+      case "publish" :: names if names.nonEmpty =>
         withProjects(names, "Publishing")(_.publish())
 
-      case "build" :: names =>
+      case "build" :: names if names.nonEmpty =>
         withProjects(names, "Build")(_.build())
 
       case "doc" :: "all" :: destStr :: Nil =>
@@ -90,16 +92,13 @@ object Main:
           sys.exit(1)
 
       case "doc" :: names if names.nonEmpty =>
-        val missing = names.filterNot(projectMap.contains)
-        if missing.nonEmpty then
-          println(s"Missing projects: ${missing.mkString(", ")}. All projects: ${allProjects.mkString(", ")}")
-          sys.exit(1)
-
-        val failed = names.filter{ p =>
-          val docsRoots = generateDocs(projectMap(p))
+        val failed = withProjects(names, "Documenting"){ p =>
+          val docsRoots = generateDocs(p)
+          println(docsRoots)
           if docsRoots.nonEmpty then println(s"Docs for $p generated in $docsRoots")
-          docsRoots.isEmpty
-        }
+          if docsRoots.isEmpty then Some(p.project) else None
+        }.flatten
+
         if failed.nonEmpty then
           println(s"Documentation not found for ${failed.mkString(", ")}")
           sys.exit(1)

community-build/src/scala/dotty/communitybuild/projects.scala

@@ -93,11 +93,15 @@ end CommunityProject
 final case class MillCommunityProject(
     project: String,
     baseCommand: String,
-    dependencies: List[CommunityProject] = Nil) extends CommunityProject:
+    dependencies: List[CommunityProject] = Nil,
+    ignoreDocs: Boolean = false,
+    ) extends CommunityProject:
   override val binaryName: String = "./mill"
   override val testCommand = s"$baseCommand.test"
   override val publishCommand = s"$baseCommand.publishLocal"
   override val docCommand = null
+    // uncomment once mill is released
+    // if ignoreDocs then null else s"$baseCommand.docJar"
   override val runCommandsArgs = List("-i", "-D", s"dottyVersion=$compilerVersion")
 
 final case class SbtCommunityProject(
@@ -198,11 +202,13 @@ object projects:
   lazy val utest = MillCommunityProject(
     project = "utest",
     baseCommand = s"utest.jvm[$compilerVersion]",
+    ignoreDocs = true
   )
 
   lazy val sourcecode = MillCommunityProject(
     project = "sourcecode",
     baseCommand = s"sourcecode.jvm[$compilerVersion]",
+    ignoreDocs = true
   )
 
   lazy val oslib = MillCommunityProject(
@@ -214,7 +220,8 @@ object projects:
   lazy val oslibWatch = MillCommunityProject(
     project = "os-lib",
     baseCommand = s"os.watch[$compilerVersion]",
-    dependencies = List(utest, sourcecode)
+    dependencies = List(utest, sourcecode),
+    ignoreDocs = true
   )
 
   lazy val ujson = MillCommunityProject(
@@ -244,13 +251,15 @@ object projects:
   lazy val fansi = MillCommunityProject(
     project = "fansi",
     baseCommand = s"fansi.jvm[$compilerVersion]",
-    dependencies = List(utest, sourcecode)
+    dependencies = List(utest, sourcecode),
+    ignoreDocs = true
   )
 
   lazy val pprint = MillCommunityProject(
     project = "PPrint",
     baseCommand = s"pprint.jvm[$compilerVersion]",
-    dependencies = List(fansi)
+    dependencies = List(fansi),
+    ignoreDocs = true
   )
 
   lazy val requests = MillCommunityProject(
@@ -705,4 +714,4 @@ def allProjects = List(
   projects.perspective,
 )
 
-lazy val projectMap = allProjects.map(p => p.project -> p).toMap
+lazy val projectMap = allProjects.groupBy(_.project)

project/Build.scala

@@ -1160,6 +1160,8 @@ object Build {
   val generateTestcasesDocumentation  = taskKey[Unit]("Generate documentation for testcases, usefull for debugging tests")
   lazy val `scaladoc` = project.in(file("scaladoc")).asScaladoc
   lazy val `scaladoc-nonBootstrapped` = project.in(file("scaladoc")).scaladocBasic(NonBootstrapped).settings(
+    // Unit tests in scaladoc depends on scaladoc-testcases
+    // we do not want to just cross compile them with bootstrapped and unbootstrapped compiler
     sources.in(Test) := Nil
   )
 

scaladoc/src/dotty/tools/scaladoc/Main.scala

@@ -13,17 +13,19 @@ import dotty.tools.dotc.config.CommonScalaSettings
 import dotty.tools.dotc.core.Contexts._
 
 /** Main class for the doctool when used from cli. */
+class Main:
+  // This is an entry point for Mill or other tools in the future since it provides easy access to reporter
+  def run(args: Array[String]) = Scaladoc.run(args, (new ContextBase).initialCtx)
+
 object Main:
   def main(args: Array[String]): Unit =
-    try
-      // We should create our own context here...
-      val reporter = Scaladoc.run(args, (new ContextBase).initialCtx)
+  try
+    // We should create our own context here...
+    val reporter = Main().run(args)
+    // Sometimes jvm is hanging, so we want to be sure that we force shout down the jvm
+    sys.exit(if reporter.hasErrors then 1 else 0)
+  catch
+    case a: Exception =>
+      a.printStackTrace()
       // Sometimes jvm is hanging, so we want to be sure that we force shout down the jvm
-      sys.exit(if reporter.hasErrors then 1 else 0)
-    catch
-      case a: Exception =>
-        a.printStackTrace()
-        // Sometimes jvm is hanging, so we want to be sure that we force shout down the jvm
-        sys.exit(1)
-
-
+      sys.exit(1)