Extend Flexmark with doc strings

Remove rest of dokka usages

Author: romanowski

scala3doc-testcases/src/tests/docString.scala

@@ -0,0 +1,82 @@
+package tests
+
+package commonlinks:
+  class SomeOtherPackage:
+    def method = 123
+
+  object SomeOtherPackage
+
+  enum SomeOtherEnum:
+    case A
+    case B
+
+
+
+package wikilinks:
+  class SomeClass:
+    def method = 123
+
+  /**
+   * [[AnNonExisitingObject]]
+   * [[SomeClass!.ala]]
+   * @syntax wiki
+   */
+  class BrokenLinks
+
+  /**
+   * [[tests.commonlinks.SomeOtherPackage]]
+   * @syntax wiki
+   */
+  class OtherPackageLink
+
+  /**
+   * [[tests.commonlinks.SomeOtherPackage!method]]
+   * [[tests.commonlinks.SomeOtherPackage#]]
+   * [[tests.commonlinks.SomeOtherEnum!A]]
+   * @syntax wiki
+   */
+  class OtherPackageMembers
+  /**
+   * [[SomeClass]]
+   * @syntax wiki
+   */
+  class SamePackageLink
+
+  /**
+   * [[SomeClass.method]]
+   * @syntax wiki
+   */
+  class SamePackageMembers
+
+// It should be exact copy of wikilinks
+package mdlinks:
+  class SomeClass:
+    def method = 123
+
+  /**
+   * [[AnNonExisitingObject]]
+   * [[SomeClass!.ala]]
+   */
+  class BrokenLinks
+
+  /**
+   * [[tests.commonlinks.SomeOtherPackage]]
+   */
+  class OtherPackageLink
+
+  /**
+   * [[tests.commonlinks.SomeOtherPackage!method]]
+   * [[tests.commonlinks.SomeOtherPackage#]]
+   * [[tests.commonlinks.SomeOtherEnum!A]]
+   * @syntax wiki
+   */
+  class OtherPackageMembers
+  /**
+   * [[SomeClass]]
+   */
+  class SamePackageLink
+
+  /**
+   * [[SomeClass.method]]
+   */
+  class SamePackageMembers

scala3doc-testcases/src/tests/site.scala

@@ -0,0 +1,52 @@
+package tests.site
+
+
+package some.other:
+  class SomeOtherPackage
+
+class SomeClass:
+  def method(a: Int): Int
+    = 123 + a
+  val field =
+    123
+
+/**
+ * Broken link, that should result a warning not break compilation
+ * [[tests.links.AnObject]]
+
+ */
+class BrokenLink:
+  def verifyIfLinksTestIsGenerated(b: Int): Int
+    = 123
+
+/**
+ * [[tests.links.some.other.SomeOtherPackage]]
+ */
+class OtherPackageLink
+
+/**
+ * [[tests.links.SomeClass]]
+ */
+class SamePackageLink
+
+
+/**
+ * Broken link, that should result a warning not break compilation
+ * [[tests.links.AnObject]]
+
+ */
+class BrokenLinkWiki:
+  def verifyIfLinksTestIsGenerated(b: Int): Int
+    = 123
+
+/**
+ * [[tests.links.some.other.SomeOtherPackage]]
+ *  @syntax wiki
+ */
+class OtherPackageLinkWiki
+
+/**
+ * [[tests.links.SomeClass]]
+ *  @syntax wiki
+ */
+class SamePackageLinkWiki

scala3doc/src/dotty/dokka/DRI.scala

@@ -1,16 +1,13 @@
 package dotty.dokka
 
 import java.nio.file.Path
-import org.jetbrains.dokka.links.PointingToDeclaration
 
 val staticFileSymbolUUID = "___staticFile___"
 
 val topLevelDri = DRI("/")
 
-type DDRI = org.jetbrains.dokka.links.DRI
-
 // we may need target...
-case class DRI(
+final case class DRI(
   location: String,
   anchor: String = "",
   origin: String = "",
@@ -20,25 +17,5 @@ case class DRI(
 
   def isStaticFile = symbolUUID == staticFileSymbolUUID
 
-  def asDokka: DDRI = new DDRI(
-    location,
-    anchor,
-    null,
-    PointingToDeclaration.INSTANCE,
-    origin + ":" + symbolUUID
-  )
-
 object DRI:
   def forPath(path: Path) = DRI(location = path.toString, symbolUUID = staticFileSymbolUUID)
-
-extension (dokkaDri: DDRI)
-  def asScala: DRI =
-    val elements = dokkaDri.getExtra.split(":")
-    val origin = elements.headOption.getOrElse("")
-    val symbolUUID = elements.drop(1).mkString(":")
-    DRI(
-      dokkaDri.getPackageName,
-      dokkaDri.getClassNames,
-      origin,
-      symbolUUID
-    )

scala3doc/src/dotty/dokka/DocContext.scala

@@ -1,7 +1,5 @@
 package dotty.dokka
 
-import org.jetbrains.dokka._
-import org.jetbrains.dokka.plugability.DokkaContext
 import java.io.File
 import java.nio.file.Files
 import java.nio.file.Path
@@ -25,9 +23,6 @@ type CompilerContext = dotty.tools.dotc.core.Contexts.Context
 given compilerContext(using docContext: DocContext): CompilerContext =
   docContext.compilerContext
 
-given docContextFromDokka(using dokkaContext: DokkaContext): DocContext =
-  dokkaContext.getConfiguration.asInstanceOf[DocContext]
-
 val report = dotty.tools.dotc.report
 
 def relativePath(p: Path)(using Context): Path =
@@ -73,34 +68,16 @@ extension (r: report.type)
 
 case class NavigationNode(name: String, dri: DRI, nested: Seq[NavigationNode])
 
-case class DocContext(args: Scala3doc.Args, compilerContext: CompilerContext)
-  extends DokkaConfiguration:
-    override def getOutputDir: File = args.output
-    override def getCacheRoot: File = null
-    override def getOfflineMode: Boolean = false
-    override def getFailOnWarning: Boolean = false
-    override def getSourceSets: JList[DokkaSourceSet] = JNil
-    override def getModules: JList[DokkaConfiguration.DokkaModuleDescription] = JNil
-    override def getPluginsClasspath: JList[File] = JNil
-    override def getModuleName(): String = "ModuleName"
-    override def getModuleVersion(): String = ""
-
-    lazy val sourceLinks: SourceLinks = SourceLinks.load(using this)
-
-    lazy val displaySourceSets = getSourceSets.toDisplaySourceSet
-
-    // Nasty hack but will get rid of it once we migrate away from dokka renderer
-    var navigationNode: Option[NavigationNode] = None
-
-    val logger = new Scala3DocDokkaLogger(using compilerContext)
+case class DocContext(args: Scala3doc.Args, compilerContext: CompilerContext):
+  lazy val sourceLinks: SourceLinks = SourceLinks.load(using this)
 
-    lazy val staticSiteContext = args.docsRoot.map(path => StaticSiteContext(
-        File(path).getAbsoluteFile(),
-        args,
-        sourceLinks
-      )(using compilerContext))
+  // Nasty hack but will get rid of it once we migrate away from dokka renderer
+  var navigationNode: Option[NavigationNode] = None
 
-    val externalDocumentationLinks = args.externalMappings
+  lazy val staticSiteContext = args.docsRoot.map(path => StaticSiteContext(
+      File(path).getAbsoluteFile(),
+      args,
+      sourceLinks
+    )(using compilerContext))
 
-    override def getPluginsConfiguration: JList[DokkaConfiguration.PluginConfiguration] =
-      JNil
+  val externalDocumentationLinks = args.externalMappings

scala3doc/src/dotty/dokka/Scala3doc.scala

@@ -1,8 +1,5 @@
 package dotty.dokka
 
-import org.jetbrains.dokka._
-import org.jetbrains.dokka.utilities._
-import org.jetbrains.dokka.plugability._
 import java.util.ServiceLoader
 import java.io.File
 import java.util.jar._
@@ -15,31 +12,6 @@ import dotty.tools.dotc.config.Settings._
 import dotty.tools.dotc.config.CommonScalaSettings
 import dotty.tools.dotc.reporting.Reporter
 
-
-class Scala3DocDokkaLogger(using CompilerContext) extends DokkaLogger:
-  def debug(msg: String): Unit = report.debuglog(msg)
-
-  // We do not want errors from dokka (that are) not critical to fail our runs
-  def error(msg: String): Unit =
-    errors += 1
-    report.warning(msg)
-
-  def info(msg: String): Unit = report.inform(msg)
-  def progress(msg: String): Unit = report.informProgress(msg)
-
-  private val dokkaAlphaWarning = "Dokka 1.4.* is an alpha project"
-  def warn(msg: String): Unit =
-    if msg != dokkaAlphaWarning then
-      warnings += 1
-      report.warning(msg)
-
-  private var errors = 0
-  private var warnings = 0
-  def getErrorsCount(): Int = errors
-  def getWarningsCount(): Int = warnings
-  def setErrorsCount(count: Int): Unit = errors = count
-  def setWarningsCount(count: Int): Unit = warnings = count
-
 object Scala3doc:
   enum CommentSyntax:
     case Wiki
@@ -94,21 +66,10 @@ object Scala3doc:
 
 
   private [dokka] def run(args: Args)(using ctx: CompilerContext): DocContext =
-
     given docContext: DocContext = new DocContext(args, ctx)
-
     val module = ScalaModuleProvider.mkModule()
-    given dokkaContext: DokkaContext =
-      DokkaContext.Companion.create(docContext, docContext.logger, JList())
-    val dokkaRenderer = new DokkaScalaHtmlRenderer
-
-    val renderer = new dotty.dokka.renderers.HtmlRenderer(
-      module.rootPackage,
-      module.members,
-      dri => c => dokkaRenderer.buildWithKotlinx(c, FakeContentPage(dri.asDokka, c), null)
-    )
-    dokkaRenderer.init(renderer)
-    renderer.render()
+
+    new dotty.dokka.renderers.HtmlRenderer(module.rootPackage, module.members).render()
     report.inform("generation completed successfully")
     docContext
 

scala3doc/src/dotty/dokka/ScalaModuleCreator.scala

@@ -2,15 +2,14 @@ package dotty.dokka
 
 import dotty.dokka.tasty.DokkaTastyInspector
 import dotty.dokka.model.api._
-import org.jetbrains.dokka.base.parsers.MarkdownParser
 import collection.JavaConverters._
 import kotlin.coroutines.Continuation
 
 case class Module(rootPackage: Member, members: Map[DRI, Member])
 
 object ScalaModuleProvider:
   def mkModule()(using ctx: DocContext): Module =
-    val (result, rootDoc) = DokkaTastyInspector(new MarkdownParser(_ => null)).result()
+    val (result, rootDoc) = DokkaTastyInspector().result()
     val (rootPck, rest) = result.partition(_.name == "API")
     val packageMembers = (rest ++ rootPck.flatMap(_.members)).sortBy(_.name)