scala3doc has similar api like compiler

use arguments extends of --tasty-root parameter

Author: romanowski

project/Build.scala

@@ -1472,7 +1472,7 @@ object Build {
       def generateDocumentation(targets: String, name: String, outDir: String, ref: String, params: String = "") = Def.taskDyn {
           val projectVersion = version.value
           val sourcesAndRevision = s"-s github://lampepfl/dotty  --revision $ref --projectVersion $projectVersion"
-          val cmd = s""" -d $outDir -t $targets -n "$name" $sourcesAndRevision $params"""
+          val cmd = s""" -d $outDir -n "$name" $sourcesAndRevision $params $targets"""
           run.in(Compile).toTask(cmd)
       }
 
@@ -1525,7 +1525,7 @@ object Build {
               (`scala3-library-bootstrapped`/Compile/products).value,
             ).flatten
 
-            val roots = joinProducts(dottyJars)
+            val roots = dottyJars.mkString(" ")
 
             if (dottyJars.isEmpty) Def.task { streams.value.log.error("Dotty lib wasn't found") }
             else Def.task{

sbt-dotty/src/dotty/tools/sbtplugin/DottyPlugin.scala

@@ -362,11 +362,9 @@ object DottyPlugin extends AutoPlugin {
       useScala3doc := false,
       scala3docOptions := Nil,
       Compile / doc / scalacOptions := {
-        // We are passing scala3doc argument list as single argument to scala instance starting with magic prefix "--+DOC+"
-        val s3dOpts = scala3docOptions.value.map("--+DOC+" + _)
         val s3cOpts = (Compile / doc / scalacOptions).value
         if (isDotty.value && useScala3doc.value) {
-           s3dOpts ++ s3cOpts
+           scala3docOptions.value ++ s3cOpts
         } else {
           s3cOpts
         }

scala3doc/src/dotty/dokka/Main.scala

@@ -14,12 +14,7 @@ import java.nio.file.Files
 
 import dotty.tools.dotc.config.Settings._
 
-abstract class Scala3Args(reportError: String => Unit) extends SettingGroup:
-  private val tastyRootsUsage = "Roots where tools should look for tasty files. Directories and jars are accepted"
-  val tastyRoots: Setting[String] =
-    StringSetting("--tastyRoots", "tastyRoots", tastyRootsUsage, "", aliases = List("-t"))
-  val tastyRootsAlias: Setting[String] =
-    StringSetting("-t", "tastyRoots", tastyRootsUsage, "", aliases = List("-t"))
+class Scala3Args(reportError: String => Unit) extends SettingGroup:
 
   val dest: Setting[String] =
     StringSetting("--dest", "dest", "Output to generate documentation to", "", aliases = List("-d"))
@@ -29,7 +24,7 @@ abstract class Scala3Args(reportError: String => Unit) extends SettingGroup:
   val classpath: Setting[String] =
     StringSetting("--classpath", "classpath", "Classpath to load dependencies from", "", aliases = List("--cp", "-c"))
   val classpathAlias1: Setting[String] =
-    StringSetting("--cp", "classpath", "Classpath to load dependencies from", "", aliases = List("--cp", "-c"))
+    StringSetting("-classpath", "classpath", "Classpath to load dependencies from", "", aliases = List("--cp", "-c"))
   val classpathAlias2: Setting[String] =
     StringSetting("-c", "classpath", "Classpath to load dependencies from", "", aliases = List("--cp", "-c"))
 
@@ -71,9 +66,7 @@ abstract class Scala3Args(reportError: String => Unit) extends SettingGroup:
   val syntax: Setting[String] =
     StringSetting("--syntax", "syntax", "Syntax of the comment used", "")
 
-  protected def defaultName(): String
-  protected def defaultTastFiles(): List[File]
-  protected def defaultDest(): File
+  protected def defaultDest(): File = sys.error(s"Argument '${dest.name}' is required")
 
   def extract(args: List[String]) =
     val initialSummary = ArgsSummary(defaultState, args, errors = Nil, warnings = Nil)
@@ -95,11 +88,13 @@ abstract class Scala3Args(reportError: String => Unit) extends SettingGroup:
 
     def parseTastyRoots(roots: String) = roots.split(File.pathSeparatorChar).toList.map(new File(_))
 
+    val tastyRoots = res.arguments.map(new File(_)) // check provided files
+
     Args(
-      parseOptionalArg(name, nameAlias).getOrElse(defaultName()),
-      parseOptionalArg(tastyRoots, tastyRootsAlias).fold(defaultTastFiles())(parseTastyRoots),
+      parseOptionalArg(name, nameAlias).getOrElse("root"),
+      tastyRoots,
       parseOptionalArg(classpath, classpathAlias1, classpathAlias2).getOrElse(System.getProperty("java.class.path")),
-      parseOptionalArg(dest, destAlias).fold(defaultDest())(new File(_)),
+      parseOptionalArg(dest, destAlias).fold(defaultDest())(File(_)),
       parseOptionalArg(docsRoot, docsRootAlias),
       parseOptionalArg(projectVersion, projectVersionAlias),
       parseOptionalArg(projectTitle, projectTitleAlias),
@@ -158,40 +153,35 @@ enum DocConfiguration extends BaseDocConfiguration:
   */
 object Main:
   def main(parsedArgs: Args): Unit =
-    try
-      val (files, dirs) = parsedArgs.tastyRoots.partition(_.isFile)
-      val (providedTastyFiles, jars) = files.toList.map(_.getAbsolutePath).partition(_.endsWith(".tasty"))
-      jars.foreach(j => if(!j.endsWith(".jar")) sys.error(s"Provided file $j is not jar not tasty file") )
+    val (files, dirs) = parsedArgs.tastyRoots.partition(_.isFile)
+    val (providedTastyFiles, jars) = files.toList.map(_.getAbsolutePath).partition(_.endsWith(".tasty"))
+    jars.foreach(j => if(!j.endsWith(".jar")) sys.error(s"Provided file $j is not jar not tasty file") )
 
+    def listTastyFiles(f: File): Seq[String] =
+      val (files, dirs) = Option(f.listFiles()).toArray.flatten.partition(_.isFile)
+      ArraySeq.unsafeWrapArray(
+        files.filter(_.getName.endsWith(".tasty")).map(_.toString) ++ dirs.flatMap(listTastyFiles)
+      )
+    val tastyFiles = providedTastyFiles ++ dirs.flatMap(listTastyFiles)
 
-      def listTastyFiles(f: File): Seq[String] =
-        val (files, dirs) = f.listFiles().partition(_.isFile)
-        ArraySeq.unsafeWrapArray(
-          files.filter(_.getName.endsWith(".tasty")).map(_.toString) ++ dirs.flatMap(listTastyFiles)
-        )
-      val tastyFiles = providedTastyFiles ++ dirs.flatMap(listTastyFiles)
+    val config = DocConfiguration.Standalone(parsedArgs, tastyFiles, jars)
 
-      val config = DocConfiguration.Standalone(parsedArgs, tastyFiles, jars)
+    if (parsedArgs.output.exists()) IO.delete(parsedArgs.output)
 
-      if (parsedArgs.output.exists()) IO.delete(parsedArgs.output)
+    new DokkaGenerator(new DottyDokkaConfig(config), DokkaConsoleLogger.INSTANCE).generate()
+    println("Done")
 
-      new DokkaGenerator(new DottyDokkaConfig(config), DokkaConsoleLogger.INSTANCE).generate()
 
-      println("Done")
+  def main(args: Array[String]): Unit =
+    try
+      val argDefinition = new Scala3Args(sys.error)
+      main(argDefinition.extract(args.toList))
+      // Sometimes jvm is hanging, so we want to be sure that we force shout down the jvm
+      sys.exit(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)
 
-  def main(args: Array[String]): Unit =
-      val argDefinition = new Scala3Args(sys.error) {
-        protected def defaultName(): String = sys.error(s"Argument '${name.name}' is required")
-        protected def defaultTastFiles(): List[File] = sys.error(s"Argument '${tastyRoots.name}' is required")
-        protected def defaultDest(): File = sys.error(s"Argument '${dest.name}' is required")
-      }
-      main(argDefinition.extract(args.toList))
-      // Sometimes jvm is hanging, so we want to be sure that we force shout down the jvm
-      sys.exit(0)
-
 

scala3doc/src/dotty/tools/dottydoc/Main.scala

@@ -33,20 +33,13 @@ object Main extends Driver {
     * how they're split).
     */
   override def process(args: Array[String], rootCtx: Context): Reporter = {
+    given Context = rootCtx
 
+    val argDefinition = new Scala3Args(error(_))
+    val parsedArgs = argDefinition.extract(args.toList)
 
-    val (filesToCompile, ctx) = setup(args, rootCtx)
-    given Context = ctx
+    dotty.dokka.Main.main(parsedArgs)
 
-    val argDefinition = new Scala3Args(error(_)) {
-        protected def defaultName(): String = ctx.settings.projectName.value
-        protected def defaultTastFiles(): List[File] = Nil
-        protected def defaultDest(): File = File(ctx.settings.outputDir.value.toString)
-    }
-
-    val config = DocConfiguration.Sbt(argDefinition.extract(args.toList), filesToCompile, ctx)
-    val dokkaCfg = new DottyDokkaConfig(config)
-    new DokkaGenerator(dokkaCfg, DokkaConsoleLogger.INSTANCE).generate()
 
     rootCtx.reporter
   }