Add failing flag

Author: pikinier20

scaladoc-testcases/src/tests/snippetCompilerTest.scala

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

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

@@ -16,9 +16,9 @@ class DocRender(signatureRenderer: SignatureRenderer, snippetChecker: SnippetChe
           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, _) =>
+              case r: SnippetCompilationResult if !r.isSuccessful =>
                 println(s"In member ${m.name} (${m.dri.location}):")
                 println(r.getSummary)
               case _ =>

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

@@ -11,8 +11,8 @@ 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
+  private var warningsCount = 0
+  private var errorsCount = 0
 
   def checkSnippet(
     snippet: String,
@@ -30,9 +30,9 @@ 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)
+      if !res.isSuccessful && res.messages.exists(_.level == MessageLevel.Error) then errorsCount = errorsCount + 1
+      if !res.isSuccessful && res.messages.exists(_.level == MessageLevel.Warning) then warningsCount = warningsCount + 1
       Some(res)
     else None
   }

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

@@ -3,10 +3,23 @@ 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(
+  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):

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(arg: SnippetCompilerArg, context: Context): Seq[SnippetCompilerMessage] = {
+    Option.when(arg.is(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.is(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(arg, context)
+
+    val t = Option.when(!context.reporter.hasErrors)(target)
+    SnippetCompilationResult(isSuccessful(arg, context), t, messages)
   }

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

@@ -12,6 +12,7 @@ object SnippetCompilerArg:
 enum SCFlags(val flagName: String, val forbiddenFlags: Set[SCFlags]):
   case Compile extends SCFlags("compile", Set())
   case NoCompile extends SCFlags("nocompile", Set())
+  case Fail extends SCFlags("failing", Set())
 
 case class SnippetCompilerArgs(scArgs: PathBased[SnippetCompilerArg]):
   def get(member: Member): Option[SnippetCompilerArg] = member.sources.flatMap(s => scArgs.get(s.path).map(_.elem))