Fix snippet wrapper. Integrate snippet checker with Wiki and Markdown renderers

Author: pikinier20

scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala

@@ -13,7 +13,7 @@ import translators._
 class MemberRenderer(signatureRenderer: SignatureRenderer)(using DocContext) extends DocRender(signatureRenderer):
   import signatureRenderer._
 
-  def doc(m: Member): Seq[AppliedTag] =  m.docs.fold(Nil)(d => Seq(renderDocPart(d.body)))
+  def doc(m: Member): Seq[AppliedTag] =  m.docs.fold(Nil)(d => Seq(renderDocPart(d.body)(using m)))
 
   def tableRow(name: String, content: AppliedTag) = Seq(dt(name), dd(content))
 
@@ -37,14 +37,14 @@ class MemberRenderer(signatureRenderer: SignatureRenderer)(using DocContext) ext
     def nested(name: String, on: SortedMap[String, DocPart]): Seq[AppliedTag] =
       if on.isEmpty then Nil else
         tableRow(name, dl(cls := "attributes")(
-          on.map { case (name, value) => tableRow(name, renderDocPart(value))}.toList:_*
+          on.map { case (name, value) => tableRow(name, renderDocPart(value)(using m))}.toList:_*
         ))
 
     def list(name: String, on: List[DocPart]): Seq[AppliedTag] =
-      if on.isEmpty then Nil else tableRow(name, div(on.map(e => div(renderDocPart(e)))))
+      if on.isEmpty then Nil else tableRow(name, div(on.map(e => div(renderDocPart(e)(using m)))))
 
     def opt(name: String, on: Option[DocPart]): Seq[AppliedTag] =
-      if on.isEmpty then Nil else tableRow(name, renderDocPart(on.get))
+      if on.isEmpty then Nil else tableRow(name, renderDocPart(on.get)(using m))
 
     m.docs.fold(Nil)(d =>
       nested("Type Params", d.typeParams) ++
@@ -87,13 +87,13 @@ class MemberRenderer(signatureRenderer: SignatureRenderer)(using DocContext) ext
       Seq(
         since.map(s => code("[Since version ", parameter(s), "] ")),
         message.map(m => parameter(m)))
-      ++ m.docs.map(_.deprecated.toSeq.map(renderDocPart))
+      ++ m.docs.map(_.deprecated.toSeq.map(renderDocPart(_)(using m)))
     ).flatten
     Seq(dt("Deprecated"), dd(content:_*))
   }
 
   def memberInfo(m: Member): Seq[AppliedTag] =
-    val bodyContents = m.docs.fold(Nil)(e => renderDocPart(e.body) :: Nil)
+    val bodyContents = m.docs.fold(Nil)(e => renderDocPart(e.body)(using m) :: Nil)
 
     Seq(
       div(cls := "documentableBrief doc")(bodyContents.take(1)),
@@ -246,8 +246,8 @@ class MemberRenderer(signatureRenderer: SignatureRenderer)(using DocContext) ext
       val rawGroups = membersInGroups.groupBy(_.docs.flatMap(_.group)).collect {
           case (Some(groupName), members) =>
             ExpandedGroup(
-              names.get(groupName).fold(raw(groupName))(renderDocPart),
-              descriptions.get(groupName).fold(raw(""))(renderDocPart),
+              names.get(groupName).fold(raw(groupName))(renderDocPart(_)(using m)),
+              descriptions.get(groupName).fold(raw(""))(renderDocPart(_)(using m)),
               prios.getOrElse(groupName, 1000)
             ) -> members
         }

scaladoc/src/dotty/tools/scaladoc/renderers/WikiDocRenderer.scala

@@ -6,21 +6,38 @@ import util.HTML._
 import com.vladsch.flexmark.util.ast.{Node => MdNode}
 import dotty.tools.scaladoc.tasty.comments.wiki.WikiDocElement
 import dotty.tools.scaladoc.tasty.comments.markdown.DocFlexmarkRenderer
+import dotty.tools.scaladoc.snippets._
 
 class DocRender(signatureRenderer: SignatureRenderer)(using DocContext):
 
-  def renderDocPart(doc: DocPart): AppliedTag = doc match
+  private val snippetChecker = SnippetChecker()
+
+  private val snippetCheckingFunc: Member => String => Unit =
+  (m: Member) => {
+    (str: String) => {
+      snippetChecker.checkSnippet(str) match {
+        case r @ SnippetCompilationResult(None, _) =>
+          println(s"In member ${m.name}:")
+          println(r.getSummary)
+        case _ =>
+      }
+    }
+  }
+
+  def renderDocPart(doc: DocPart)(using Member): AppliedTag = doc match
     case md: MdNode => renderMarkdown(md)
     case Nil => raw("")
     case Seq(elem: WikiDocElement) => renderElement(elem)
     case list: Seq[WikiDocElement @unchecked] => div(list.map(renderElement))
 
-  private def renderMarkdown(el: MdNode): AppliedTag =
-    raw(DocFlexmarkRenderer.render(el)( (link,name) =>
-      renderLink(link, default => text(if name.isEmpty then default else name)).toString
+  private def renderMarkdown(el: MdNode)(using m: Member): AppliedTag =
+    raw(DocFlexmarkRenderer.render(el)(
+      (link,name) =>
+        renderLink(link, default => text(if name.isEmpty then default else name)).toString,
+      snippetCheckingFunc(m)
     ))
 
-  private def listItems(items: Seq[WikiDocElement]) =
+  private def listItems(items: Seq[WikiDocElement])(using m: Member) =
     items.map(i => li(renderElement(i)))
   private def notSupported(name: String, content: AppliedTag): AppliedTag =
     report.warning(s"Wiki syntax does not support $name in ${signatureRenderer.currentDri.location}")
@@ -35,7 +52,7 @@ class DocRender(signatureRenderer: SignatureRenderer)(using DocContext):
         val tooltip = s"Problem linking $query: $msg"
         signatureRenderer.unresolvedLink(linkBody(query), titleAttr :=  tooltip)
 
-  private def renderElement(e: WikiDocElement): AppliedTag = e match
+  private def renderElement(e: WikiDocElement)(using m: Member): AppliedTag = e match
     case Title(text, level) =>
       val content = renderElement(text)
       level match
@@ -46,7 +63,9 @@ class DocRender(signatureRenderer: SignatureRenderer)(using DocContext):
           case 5 => h5(content)
           case 6 => h6(content)
     case Paragraph(text) => p(renderElement(text))
-    case Code(data: String) => pre(code(raw(data))) // TODO add classes
+    case Code(data: String) =>
+      snippetCheckingFunc(m)(data)
+      pre(code(raw(data))) // TODO add classes
     case HorizontalRule => hr
 
     case UnorderedList(items) => ul(listItems(items))

scaladoc/src/dotty/tools/scaladoc/snippets/SnippetWrapper.scala

@@ -1,13 +1,20 @@
 package dotty.tools.scaladoc
 package snippets
 
+import java.io.ByteArrayOutputStream
+import java.io.PrintStream
+
 class SnippetWrapper:
-  def wrap(str: String): String = s"""
-  |package snippets
-  |object Snippet {
-  |  $str
-  |}
-  |""".stripMargin
+  extension (ps: PrintStream) def printlnWithIndent(indent: Int, str: String) =
+    ps.println((" " * indent) + str)
+  def wrap(str: String): String =
+    val baos = new ByteArrayOutputStream()
+    val ps = new PrintStream(baos)
+    ps.println("package snippets")
+    ps.println("object Snippet {")
+    str.split('\n').foreach(ps.printlnWithIndent(2, _))
+    ps.println("}")
+    baos.toString
 
 object SnippetWrapper:
   val lineOffset = 2

scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/DocFlexmarkExtension.scala

@@ -10,7 +10,7 @@ import com.vladsch.flexmark.ext.wikilink.internal.WikiLinkLinkRefProcessor
 import com.vladsch.flexmark.util.ast._
 import com.vladsch.flexmark.util.options._
 import com.vladsch.flexmark.util.sequence.BasedSequence
-
+import com.vladsch.flexmark._
 
 class DocLinkNode(
   val target: DocLink,
@@ -45,17 +45,32 @@ object DocFlexmarkParser {
     }
 }
 
-case class DocFlexmarkRenderer(renderLink: (DocLink, String) => String)
+case class DocFlexmarkRenderer(renderLink: (DocLink, String) => String, snippetCheckingFunc: (String) => Unit)
   extends HtmlRenderer.HtmlRendererExtension:
+
     def rendererOptions(opt: MutableDataHolder): Unit = () // noop
 
+    object CodeHandler extends CustomNodeRenderer[ast.Code]:
+      override def render(node: ast.Code, c: NodeRendererContext, html: HtmlWriter): Unit =
+        snippetCheckingFunc(node.getText.toString)
+        c.delegateRender()
+
+    object CodeBlockHandler extends CustomNodeRenderer[ast.CodeBlock]:
+      override def render(node: ast.CodeBlock, c: NodeRendererContext, html: HtmlWriter): Unit =
+        snippetCheckingFunc(node.getContentChars.toString)
+        c.delegateRender()
+
     object Handler extends CustomNodeRenderer[DocLinkNode]:
       override def render(node: DocLinkNode, c: NodeRendererContext, html: HtmlWriter): Unit =
         html.raw(renderLink(node.target, node.body))
 
     object Render extends NodeRenderer:
       override def getNodeRenderingHandlers: JSet[NodeRenderingHandler[_]] =
-        JSet(new NodeRenderingHandler(classOf[DocLinkNode], Handler))
+        JSet(
+          new NodeRenderingHandler(classOf[DocLinkNode], Handler),
+          new NodeRenderingHandler(classOf[ast.Code], CodeHandler),
+          new NodeRenderingHandler(classOf[ast.CodeBlock], CodeBlockHandler)
+        )
 
     object Factory extends NodeRendererFactory:
       override def create(options: DataHolder): NodeRenderer = Render
@@ -64,6 +79,6 @@ case class DocFlexmarkRenderer(renderLink: (DocLink, String) => String)
       htmlRendererBuilder.nodeRendererFactory(Factory)
 
 object DocFlexmarkRenderer:
-  def render(node: Node)(renderLink: (DocLink, String) => String) =
-    val opts = MarkdownParser.mkMarkdownOptions(Seq(DocFlexmarkRenderer(renderLink)))
+  def render(node: Node)(renderLink: (DocLink, String) => String, snippetCheckingFunc: (String) => Unit) =
+    val opts = MarkdownParser.mkMarkdownOptions(Seq(DocFlexmarkRenderer(renderLink, snippetCheckingFunc)))
     HtmlRenderer.builder(opts).build().render(node)