Use inline macro to build projectMap

Author: romanowski

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

@@ -0,0 +1,9 @@
+package dotty.communitybuild
+
+import scala.quoted.Type
+
+class FieldsDsl[V](v: V):
+  inline def of[T]: Seq[T] = FieldsImpl.fieldsOfType[V, T](v)
+
+extension [V](on: V):
+  def fields = FieldsDsl(on)

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

@@ -0,0 +1,17 @@
+package dotty.communitybuild
+
+import scala.quoted._
+
+object FieldsImpl:
+  inline def fieldsOfType[V, T](inline v: V): Seq[T] =
+    ${ fieldsImpl[V, T]('v) }
+
+  def fieldsImpl[V: Type, T: Type](from: Expr[V])(using Quotes): Expr[Seq[T]] =
+    import quotes.reflect._
+    val retType = TypeTree.of[T].tpe
+    def isProjectField(s: Symbol) = 
+      s.isValDef && s.tree.asInstanceOf[ValDef].tpt.tpe <:< retType
+    val projectsTree = Term.of(from)
+    val symbols = TypeTree.of[V].symbol.members.filter(isProjectField)
+    val selects = symbols.map(Select(projectsTree, _).asExprOf[T])
+    '{ println(${Expr(retType.show)}); ${Varargs(selects)} }

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

@@ -7,7 +7,6 @@ import scala.sys.process._
 
 
 object Main:
-  def allProjects = projects.projectMap.keys.toList.sorted
 
   private def generateDocs(project: CommunityProject): Seq[Path] =
     val name = project.project
@@ -29,7 +28,7 @@ object Main:
         Seq("rm", "-rf", "destStr").!
         Files.createDirectory(dest)
         val (toRun, ignored) =
-          allProjects.map(projects.projectMap).partition(_.docCommand != null)
+          allProjects.partition(_.docCommand != null)
 
         val paths = toRun.map { project =>
           val name = project.project
@@ -67,13 +66,13 @@ object Main:
           sys.exit(1)
 
       case "doc" :: names if names.nonEmpty =>
-        val missing = names.filterNot(projects.projectMap.contains)
+        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(projects.projectMap(p))
+          val docsRoots = generateDocs(projectMap(p))
           if docsRoots.nonEmpty then println(s"Docs for $p generated in $docsRoots")
           docsRoots.isEmpty
         }

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

@@ -451,50 +451,11 @@ object projects:
   lazy val verify = SbtCommunityProject(
     project        = "verify",
     sbtTestCommand = "verifyJVM/test",
+    sbtDocCommand = "verifyJVM/doc",
   )
-  
-  val projectMap = Map(
-    "utest" -> utest,
-    "sourcecode" -> sourcecode,
-    "oslib" -> oslib,
-    "oslibWatch" -> oslibWatch,
-    "ujson" -> ujson,
-    "upickle" -> upickle,
-    "upickleCore" -> upickleCore,
-    "geny" -> geny,
-    "fansi" -> fansi,
-    "pprint" -> pprint,
-    "requests" -> requests,
-    "scas" -> scas,
-    "intent" -> intent,
-    "algebra" -> algebra,
-    "scalacheck" -> scalacheck,
-    "scalatest" -> scalatest,
-    "scalatestplusScalacheck" -> scalatestplusScalacheck,
-    "scalaXml" -> scalaXml,
-    "scalap" -> scalap,
-    "betterfiles" -> betterfiles,
-    "ScalaPB" -> ScalaPB,
-    "minitest" -> minitest,
-    "fastparse" -> fastparse,
-    "stdLib213" -> stdLib213,
-    "shapeless" -> shapeless,
-    "xmlInterpolator" -> xmlInterpolator,
-    "effpi" -> effpi,
-    "sconfig" -> sconfig,
-    "zio" -> zio,
-    "munit" -> munit,
-    "scodecBits" -> scodecBits,
-    "scodec" -> scodec,
-    "scalaParserCombinators" -> scalaParserCombinators,
-    "dottyCpsAsync" -> dottyCpsAsync,
-    "scalaz" -> scalaz,
-    "endpoints4s" -> endpoints4s,
-    "catsEffect2" -> catsEffect2,
-    "catsEffect3" -> catsEffect3,
-    "scalaCollectionCompat" -> scalaCollectionCompat,
-    "scalaParallelCollections" -> scalaParallelCollections,
-  )
-  def apply(key: String) = projectMap(key)
 
 end projects
+
+def allProjects = projects.fields.of[CommunityProject].sortBy(_.project)
+
+lazy val projectMap = allProjects.map(p => p.project -> p).toMap