Merge pull request #5 from pikinier20/failing-flag

Add flags: failing, debug. Add addition operation to snippet compiler arg

Author: pikinier20

project/Build.scala

@@ -1650,7 +1650,7 @@ object Build {
                 s"$stdLibRoot=github://scala/scala/v${stdlibVersion(Bootstrapped)}#src/library," +
                 s"docs=github://lampepfl/dotty/master#docs",
               "-doc-root-content", docRootFile.toString,
-              "-snippet-compiler-args:" +
+              "-snippet-compiler:" +
                 s"$dottyLibRoot/scala/quoted=nocompile," +
                 s"$dottyLibRoot=compile",
               "-Ydocument-synthetic-types"
@@ -1663,7 +1663,11 @@ object Build {
             (Test / Build.testcasesOutputDir).value,
             "scaladoc testcases",
             "scaladoc/output/testcases",
-            "master")
+            "master",
+            Seq(
+              "-snippet-compiler-debug"
+            )
+          )
         }.value,
 
         Test / buildInfoKeys := Seq[BuildInfoKey](

scaladoc-testcases/src/tests/snippetCompilerTest.scala

@@ -7,6 +7,16 @@ package snippetCompiler
   * a
   * ```
   *
+  * ```scala sc:failing
+  * def a = 2
+  * val x = 1 + List()
+  * a
+  * ```
+  *
+  * ```scala sc:failing
+  * def a = 2
+  * ```
+  *
   * ```scala sc:nocompile
   * def a = 3
   * a()

scaladoc/src/dotty/tools/scaladoc/DocContext.scala

@@ -71,7 +71,7 @@ case class NavigationNode(name: String, dri: DRI, nested: Seq[NavigationNode])
 case class DocContext(args: Scaladoc.Args, compilerContext: CompilerContext):
   lazy val sourceLinks = SourceLinks.load(args.sourceLinks, args.revision)(using compilerContext)
 
-  lazy val snippetCompilerArgs = snippets.SnippetCompilerArgs.load(args.snippetCompilerArgs)(using compilerContext)
+  lazy val snippetCompilerArgs = snippets.SnippetCompilerArgs.load(args.snippetCompiler, args.snippetCompilerDebug)(using compilerContext)
 
   lazy val staticSiteContext = args.docsRoot.map(path => StaticSiteContext(
       File(path).getAbsoluteFile(),

scaladoc/src/dotty/tools/scaladoc/Scaladoc.scala

@@ -44,7 +44,8 @@ object Scaladoc:
     regexesToSkip: List[String] = Nil,
     rootDocPath: Option[String] = None,
     documentSyntheticTypes: Boolean = false,
-    snippetCompilerArgs: List[String] = Nil
+    snippetCompiler: List[String] = Nil,
+    snippetCompilerDebug: Boolean = false
   )
 
   def run(args: Array[String], rootContext: CompilerContext): Reporter =
@@ -175,7 +176,8 @@ object Scaladoc:
         skipByRegex.get,
         docRootContent.nonDefault,
         YdocumentSyntheticTypes.get,
-        snippetCompilerArgs.get
+        snippetCompiler.get,
+        snippetCompilerDebug.get
       )
       (Some(docArgs), newContext)
     }

scaladoc/src/dotty/tools/scaladoc/ScaladocSettings.scala

@@ -60,8 +60,11 @@ class ScaladocSettings extends SettingGroup with CommonScalaSettings:
   val YdocumentSyntheticTypes: Setting[Boolean] =
     BooleanSetting("-Ydocument-synthetic-types", "Documents intrinsic types e. g. Any, Nothing. Setting is useful only for stdlib", false)
 
-  val snippetCompilerArgs: Setting[List[String]] =
-    MultiStringSetting("-snippet-compiler-args", "snippet-compiler-args", snippets.SnippetCompilerArgs.usage)
+  val snippetCompiler: Setting[List[String]] =
+    MultiStringSetting("-snippet-compiler", "snippet-compiler", snippets.SnippetCompilerArgs.usage)
+
+  val snippetCompilerDebug: Setting[Boolean] =
+    BooleanSetting("-snippet-compiler-debug", snippets.SnippetCompilerArgs.debugUsage, false)
 
   def scaladocSpecificSettings: Set[Setting[_]] =
-    Set(sourceLinks, syntax, revision, externalDocumentationMappings, socialLinks, skipById, skipByRegex, deprecatedSkipPackages, docRootContent, snippetCompilerArgs)
+    Set(sourceLinks, syntax, revision, externalDocumentationMappings, socialLinks, skipById, skipByRegex, deprecatedSkipPackages, docRootContent, snippetCompiler, snippetCompilerDebug)

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

@@ -14,8 +14,6 @@ import java.nio.file.Files
 import java.nio.file.FileVisitOption
 import java.io.File
 
-import dotty.tools.scaladoc.snippets._
-
 case class Page(link: Link, content: Member | ResolvedTemplate | String, children: Seq[Page]):
   def withNewChildren(newChildren: Seq[Page]) = copy(children = children ++ newChildren)
 
@@ -28,7 +26,6 @@ case class Page(link: Link, content: Member | ResolvedTemplate | String, childre
 class HtmlRenderer(rootPackage: Member, val members: Map[DRI, Member])(using ctx: DocContext)
   extends SiteRenderer, Resources, Locations, Writer:
   private val args = summon[DocContext].args
-  private val snippetChecker = SnippetChecker()
   val staticSite = summon[DocContext].staticSiteContext
 
   val effectiveMembers = members
@@ -78,7 +75,7 @@ class HtmlRenderer(rootPackage: Member, val members: Map[DRI, Member])(using ctx
         def link(dri: DRI): Option[String] =
           Some(pathToPage(currentDri, dri)).filter(_ != UnresolvedLocationLink)
 
-      MemberRenderer(signatureRenderer, snippetChecker).fullMember(m)
+      MemberRenderer(signatureRenderer).fullMember(m)
     case t: ResolvedTemplate => siteContent(page.link.dri, t)
     case a: String =>  raw(a)
 
@@ -122,7 +119,6 @@ class HtmlRenderer(rootPackage: Member, val members: Map[DRI, Member])(using ctx
   def render(): Unit =
     val renderedResources = renderResources()
     val sites = allPages.map(renderPage(_, Vector.empty))
-    println(snippetChecker.summary)
 
   def mkHead(page: Page): AppliedTag =
     val resources = page.content match

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

@@ -9,12 +9,11 @@ import dotty.tools.scaladoc.tasty.comments.markdown.DocFlexmarkRenderer
 import com.vladsch.flexmark.util.ast.{Node => MdNode}
 import dotty.tools.scaladoc.tasty.comments.wiki.WikiDocElement
 import translators._
-import dotty.tools.scaladoc.snippets._
 
-class MemberRenderer(signatureRenderer: SignatureRenderer, snippetChecker: SnippetChecker)(using DocContext) extends DocRender(signatureRenderer, snippetChecker):
+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)(using m)))
+  def doc(m: Member): Seq[AppliedTag] =  m.docs.fold(Nil)(d => Seq(renderDocPart(d.body)))
 
   def tableRow(name: String, content: AppliedTag) = Seq(dt(name), dd(content))
 
@@ -38,14 +37,14 @@ class MemberRenderer(signatureRenderer: SignatureRenderer, snippetChecker: Snipp
     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)(using m))}.toList:_*
+          on.map { case (name, value) => tableRow(name, renderDocPart(value))}.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)(using m)))))
+      if on.isEmpty then Nil else tableRow(name, div(on.map(e => div(renderDocPart(e)))))
 
     def opt(name: String, on: Option[DocPart]): Seq[AppliedTag] =
-      if on.isEmpty then Nil else tableRow(name, renderDocPart(on.get)(using m))
+      if on.isEmpty then Nil else tableRow(name, renderDocPart(on.get))
 
     m.docs.fold(Nil)(d =>
       nested("Type Params", d.typeParams) ++
@@ -88,17 +87,17 @@ class MemberRenderer(signatureRenderer: SignatureRenderer, snippetChecker: Snipp
       Seq(
         since.map(s => code("[Since version ", parameter(s), "] ")),
         message.map(m => parameter(m)))
-      ++ m.docs.map(_.deprecated.toSeq.map(renderDocPart(_)(using m)))
+      ++ m.docs.map(_.deprecated.toSeq.map(renderDocPart))
     ).flatten
     Seq(dt("Deprecated"), dd(content:_*))
   }
 
   def memberInfo(m: Member): Seq[AppliedTag] =
     val comment = m.docs
-    val bodyContents = m.docs.fold(Nil)(e => renderDocPart(e.body)(using m) :: Nil)
+    val bodyContents = m.docs.fold(Nil)(e => renderDocPart(e.body) :: Nil)
 
     Seq(
-      div(cls := "documentableBrief doc")(comment.flatMap(_.short).fold("")(renderDocPart(_)(using m))),
+      div(cls := "documentableBrief doc")(comment.flatMap(_.short).fold("")(renderDocPart)),
       div(cls := "cover")(
         div(cls := "doc")(bodyContents),
         dl(cls := "attributes")(
@@ -248,8 +247,8 @@ class MemberRenderer(signatureRenderer: SignatureRenderer, snippetChecker: Snipp
       val rawGroups = membersInGroups.groupBy(_.docs.flatMap(_.group)).collect {
           case (Some(groupName), members) =>
             ExpandedGroup(
-              names.get(groupName).fold(raw(groupName))(renderDocPart(_)(using m)),
-              descriptions.get(groupName).fold(raw(""))(renderDocPart(_)(using m)),
+              names.get(groupName).fold(raw(groupName))(renderDocPart),
+              descriptions.get(groupName).fold(raw(""))(renderDocPart),
               prios.getOrElse(groupName, 1000)
             ) -> members
         }

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

@@ -6,41 +6,21 @@ 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, snippetChecker: SnippetChecker)(using ctx: DocContext):
+class DocRender(signatureRenderer: SignatureRenderer)(using DocContext):
 
-  private val snippetCheckingFuncFromMember: Member => SnippetChecker.SnippetCheckingFunc =
-    (m: Member) => {
-      (str: String, lineOffset: SnippetChecker.LineOffset, argOverride: Option[SnippetCompilerArg]) => {
-          val arg = argOverride.getOrElse(
-            ctx.snippetCompilerArgs.get(m).getOrElse(SnippetCompilerArg.default)
-          )
-          
-          snippetChecker.checkSnippet(str, m.docs.map(_.snippetCompilerData), arg, lineOffset).foreach { _ match {
-              case r @ SnippetCompilationResult(None, _) =>
-                println(s"In member ${m.name} (${m.dri.location}):")
-                println(r.getSummary)
-              case _ =>
-            }
-          }
-      }
-    }
-
-  def renderDocPart(doc: DocPart)(using Member): AppliedTag = doc match
+  def renderDocPart(doc: DocPart): 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)(using m: Member): AppliedTag =
-    raw(DocFlexmarkRenderer.render(el)(
-      (link,name) =>
-        renderLink(link, default => text(if name.isEmpty then default else name)).toString,
-        snippetCheckingFuncFromMember(m)
+  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 listItems(items: Seq[WikiDocElement])(using m: Member) =
+  private def listItems(items: Seq[WikiDocElement]) =
     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}")
@@ -55,7 +35,7 @@ class DocRender(signatureRenderer: SignatureRenderer, snippetChecker: SnippetChe
         val tooltip = s"Problem linking $query: $msg"
         signatureRenderer.unresolvedLink(linkBody(query), titleAttr :=  tooltip)
 
-  private def renderElement(e: WikiDocElement)(using m: Member): AppliedTag = e match
+  private def renderElement(e: WikiDocElement): AppliedTag = e match
     case Title(text, level) =>
       val content = renderElement(text)
       level match
@@ -66,9 +46,7 @@ class DocRender(signatureRenderer: SignatureRenderer, snippetChecker: SnippetChe
           case 5 => h5(content)
           case 6 => h6(content)
     case Paragraph(text) => p(renderElement(text))
-    case Code(data: String) =>
-      snippetCheckingFuncFromMember(m)(data, 0, None)
-      pre(code(raw(data))) // TODO add classes
+    case Code(data: String) => pre(code(raw(data))) // TODO add classes
     case HorizontalRule => hr
 
     case UnorderedList(items) => ul(listItems(items))

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

@@ -11,16 +11,13 @@ class SnippetChecker()(using ctx: DocContext):
       ctx.args.tastyDirs.map(_.getAbsolutePath()).mkString(sep)
   private val compiler: SnippetCompiler = SnippetCompiler(classpath = cp)
 
-  var warningsCount = 0
-  var errorsCount = 0
-
   def checkSnippet(
     snippet: String,
     data: Option[SnippetCompilerData],
     arg: SnippetCompilerArg,
     lineOffset: SnippetChecker.LineOffset
   ): Option[SnippetCompilationResult] = {
-    if arg.is(SCFlags.Compile) then
+    if arg.flag != SCFlags.NoCompile then
       val wrapped = WrappedSnippet(
         snippet,
         data.map(_.packageName),
@@ -30,19 +27,11 @@ class SnippetChecker()(using ctx: DocContext):
         lineOffset + data.fold(0)(_.position.line) + 1,
         data.fold(0)(_.position.column)
       )
-      val res = compiler.compile(wrapped)
-      if !res.messages.filter(_.level == MessageLevel.Error).isEmpty then errorsCount = errorsCount + 1
-      if !res.messages.filter(_.level == MessageLevel.Warning).isEmpty then warningsCount = warningsCount + 1
+      val res = compiler.compile(wrapped, arg)
       Some(res)
     else None
   }
 
-  def summary: String = s"""
-  |Snippet compiler summary:
-  |  Found $warningsCount warnings
-  |  Found $errorsCount errors
-  |""".stripMargin
-
 object SnippetChecker:
   type LineOffset = Int
-  type SnippetCheckingFunc = (String, LineOffset, Option[SnippetCompilerArg]) => Unit
+  type SnippetCheckingFunc = (String, LineOffset, Option[SCFlags]) => Option[SnippetCompilationResult]

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

@@ -3,14 +3,29 @@ package snippets
 
 import dotty.tools.io.{ AbstractFile }
 
-case class SnippetCompilerMessage(line: Int, column: Int, sourceLine: String, message: String, level: MessageLevel)
+case class Position(line: Int, column: Int, sourceLine: String)
 
-case class SnippetCompilationResult(result: Option[AbstractFile], messages: Seq[SnippetCompilerMessage]):
-  def getSummary: String = messages.map(m => s"At ${m.line}:${m.column}:\n${m.sourceLine}${m.level.text}: ${m.message}").mkString("\n")
+case class SnippetCompilerMessage(position: Option[Position], message: String, level: MessageLevel)
+
+case class SnippetCompilationResult(
+  wrappedSnippet: String,
+  isSuccessful: Boolean,
+  result: Option[AbstractFile],
+  messages: Seq[SnippetCompilerMessage]
+):
+  def getSummary: String =
+    messages.map(m =>
+      m.position.fold(
+        s"${m.level.text}: ${m.message}"
+      )(pos =>
+        s"At ${pos.line}:${pos.column}:\n${pos.sourceLine}${m.level.text}: ${m.message}"
+      )
+    ).mkString("\n")
 
 
 enum MessageLevel(val text: String):
   case Info extends MessageLevel("Info")
   case Warning extends MessageLevel("Warning")
   case Error extends MessageLevel("Error")
+  case Debug extends MessageLevel("Debug")
 

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

@@ -46,19 +46,34 @@ class SnippetCompiler(
     val infos = diagnostics.toSeq.sortBy(_.pos.source.path)
     val errorMessages = infos.map {
       case diagnostic if diagnostic.position.isPresent =>
-        val pos = diagnostic.position.get
+        val diagPos = diagnostic.position.get
+        val pos = Some(
+          Position(diagPos.line + line, diagPos.column + column, diagPos.lineContent)
+        )
         val msg = nullableMessage(diagnostic.message)
         val level = MessageLevel.fromOrdinal(diagnostic.level)
-        SnippetCompilerMessage(pos.line + line, pos.column + column, pos.lineContent, msg, level)
+        SnippetCompilerMessage(pos, msg, level)
       case d =>
         val level = MessageLevel.fromOrdinal(d.level)
-        SnippetCompilerMessage(-1, -1, "", nullableMessage(d.message), level)
+        SnippetCompilerMessage(None, nullableMessage(d.message), level)
     }
     errorMessages
   }
 
+  private def additionalMessages(wrappedSnippet: WrappedSnippet, arg: SnippetCompilerArg, context: Context): Seq[SnippetCompilerMessage] = {
+      Option.when(arg.flag == SCFlags.Fail && !context.reporter.hasErrors)(
+        SnippetCompilerMessage(None, "Snippet should not compile but compiled succesfully", MessageLevel.Error)
+      ).toList
+  }
+
+  private def isSuccessful(arg: SnippetCompilerArg, context: Context): Boolean = {
+    if arg.flag == SCFlags.Fail then context.reporter.hasErrors
+    else !context.reporter.hasErrors
+  }
+
   def compile(
-    wrappedSnippet: WrappedSnippet
+    wrappedSnippet: WrappedSnippet,
+    arg: SnippetCompilerArg
   ): SnippetCompilationResult = {
     val context = driver.currentCtx.fresh
       .setSetting(
@@ -68,7 +83,11 @@ class SnippetCompiler(
       .setReporter(new StoreReporter)
     val run = newRun(using context)
     run.compileFromStrings(List(wrappedSnippet.snippet))
-    val messages = createReportMessage(context.reporter.pendingMessages(using context), wrappedSnippet.lineOffset, wrappedSnippet.columnOffset)
-    val targetIfSuccessful = Option.when(!context.reporter.hasErrors)(target)
-    SnippetCompilationResult(targetIfSuccessful, messages)
+
+    val messages =
+      createReportMessage(context.reporter.pendingMessages(using context), wrappedSnippet.lineOffset, wrappedSnippet.columnOffset) ++
+      additionalMessages(wrappedSnippet, arg, context)
+
+    val t = Option.when(!context.reporter.hasErrors)(target)
+    SnippetCompilationResult(wrappedSnippet.snippet, isSuccessful(arg, context), t, messages)
   }