Export diagnostics (including unused warnings) to SemanticDB

Author: tanishiking

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -38,7 +38,7 @@ class Compiler {
     List(new CheckUnused.PostTyper) ::  // Check for unused elements
     List(new YCheckPositions) ::    // YCheck positions
     List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
-    List(new semanticdb.ExtractSemanticDB) :: // Extract info into .semanticdb files
+    List(new semanticdb.ExtractSemanticDB.PostTyper) :: // Extract info into .semanticdb files
     List(new PostTyper) ::          // Additional checks and cleanups after type checking
     List(new sjs.PrepJSInterop) ::  // Additional checks and transformations for Scala.js (Scala.js only)
     List(new sbt.ExtractAPI) ::     // Sends a representation of the API of classes to sbt via callbacks
@@ -51,6 +51,7 @@ class Compiler {
     List(new Inlining) ::           // Inline and execute macros
     List(new PostInlining) ::       // Add mirror support for inlined code
     List(new CheckUnused.PostInlining) ::  // Check for unused elements
+    List(new semanticdb.ExtractSemanticDB.PostInlining) :: // Extract info into .semanticdb files
     List(new Staging) ::            // Check staging levels and heal staged types
     List(new Splicing) ::           // Replace level 1 splices with holes
     List(new PickleQuotes) ::       // Turn quoted trees into explicit run-time data structures

compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -109,9 +109,14 @@ abstract class Reporter extends interfaces.ReporterResult {
 
   private var errors: List[Error] = Nil
 
+  private var warnings: List[Warning] = Nil
+
   /** All errors reported by this reporter (ignoring outer reporters) */
   def allErrors: List[Error] = errors
 
+  /** All errors reported by this reporter (ignoring outer reporters) */
+  def allWarnings: List[Warning] = warnings
+
   /** Were sticky errors reported? Overridden in StoreReporter. */
   def hasStickyErrors: Boolean = false
 
@@ -157,7 +162,9 @@ abstract class Reporter extends interfaces.ReporterResult {
         markReported(d)
         withMode(Mode.Printing)(doReport(d))
         d match {
-          case _: Warning => _warningCount += 1
+          case w: Warning =>
+            warnings = w :: warnings
+            _warningCount += 1
           case e: Error   =>
             errors = e :: errors
             _errorCount += 1

compiler/src/dotty/tools/dotc/semanticdb/DiagnosticOps.scala

@@ -0,0 +1,20 @@
+package dotty.tools.dotc.semanticdb
+
+import dotty.tools.dotc.reporting.Diagnostic
+import dotty.tools.dotc.{semanticdb => s}
+import dotty.tools.dotc.interfaces.Diagnostic.{ERROR, INFO, WARNING}
+import dotty.tools.dotc.core.Contexts.Context
+
+object DiagnosticOps:
+  extension (d: Diagnostic)
+    def toSemanticDiagnostic(using Context): s.Diagnostic =
+      val severity = d.level match
+        case ERROR => s.Diagnostic.Severity.ERROR
+        case WARNING => s.Diagnostic.Severity.WARNING
+        case INFO => s.Diagnostic.Severity.INFORMATION
+        case _ => s.Diagnostic.Severity.INFORMATION
+      s.Diagnostic(
+        range = Scala3.range(d.pos.span, d.pos.source),
+        severity = severity,
+        message = d.msg.message
+      )

compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala

@@ -25,16 +25,17 @@ import scala.PartialFunction.condOpt
 
 import dotty.tools.dotc.{semanticdb => s}
 import dotty.tools.io.{AbstractFile, JarArchive}
+import dotty.tools.dotc.util.Property
+import dotty.tools.dotc.semanticdb.DiagnosticOps.*
+
 
 /** Extract symbol references and uses to semanticdb files.
  *  See https://scalameta.org/docs/semanticdb/specification.html#symbol-1
  *  for a description of the format.
- *  TODO: Also extract type information
  */
-class ExtractSemanticDB extends Phase:
-  import Scala3.{_, given}
+class ExtractSemanticDB private (phaseMode: ExtractSemanticDB.PhaseMode, suffix: String, _key: Property.Key[TextDocument]) extends Phase:
 
-  override val phaseName: String = ExtractSemanticDB.name
+  override def phaseName: String = ExtractSemanticDB.phaseNamePrefix + suffix
 
   override val description: String = ExtractSemanticDB.description
 
@@ -48,16 +49,94 @@ class ExtractSemanticDB extends Phase:
 
   override def run(using Context): Unit =
     val unit = ctx.compilationUnit
-    val extractor = Extractor()
-    extractor.extract(unit.tpdTree)
-    ExtractSemanticDB.write(unit.source, extractor.occurrences.toList, extractor.symbolInfos.toList, extractor.synthetics.toList)
+    if (phaseMode == ExtractSemanticDB.PhaseMode.PostTyper)
+      val extractor = ExtractSemanticDB.Extractor()
+      extractor.extract(unit.tpdTree)
+      unit.tpdTree.putAttachment(_key, extractor.toTextDocument(unit.source))
+    else
+      unit.tpdTree.getAttachment(_key) match
+        case None => ???
+        case Some(doc) =>
+          val warnings = ctx.reporter.allWarnings.collect {
+            case w if w.pos.source == ctx.source => w.toSemanticDiagnostic
+          }
+          ExtractSemanticDB.write(unit.source, doc.copy(diagnostics = warnings))
+end ExtractSemanticDB
+
+object ExtractSemanticDB:
+  import java.nio.file.Path
+  import java.nio.file.Files
+  import java.nio.file.Paths
+
+  val phaseNamePrefix: String = "extractSemanticDB"
+  val description: String = "extract info into .semanticdb files"
+
+  enum PhaseMode:
+    case PostTyper
+    case PostInlining
+
+  /**
+   * The key used to retrieve the "unused entity" analysis metadata,
+   * from the compilation `Context`
+   */
+  private val _key = Property.StickyKey[TextDocument]
+
+  class PostTyper extends ExtractSemanticDB(PhaseMode.PostTyper, "PostTyper", _key)
+
+  class PostInlining extends ExtractSemanticDB(PhaseMode.PostInlining, "PostInlining", _key)
+
+  private def semanticdbTarget(using Context): Option[Path] =
+    Option(ctx.settings.semanticdbTarget.value)
+      .filterNot(_.isEmpty)
+      .map(Paths.get(_))
+
+  private def outputDirectory(using Context): AbstractFile = ctx.settings.outputDir.value
+
+  private def absolutePath(path: Path): Path = path.toAbsolutePath.normalize
+
+  private def write(
+    source: SourceFile,
+    doc: TextDocument
+  )(using Context): Unit =
+    val relPath = SourceFile.relativePath(source, ctx.settings.sourceroot.value)
+    val outpath = absolutePath(semanticdbTarget.getOrElse(outputDirectory.jpath))
+      .resolve("META-INF")
+      .resolve("semanticdb")
+      .resolve(relPath)
+      .resolveSibling(source.name + ".semanticdb")
+    Files.createDirectories(outpath.getParent())
+    val docs = TextDocuments(List(doc))
+    val out = Files.newOutputStream(outpath)
+    try
+      val stream = internal.SemanticdbOutputStream.newInstance(out)
+      docs.writeTo(stream)
+      stream.flush()
+    finally
+      out.close()
+  end write
+
 
   /** Extractor of symbol occurrences from trees */
-  class Extractor extends TreeTraverser:
+  private class Extractor extends TreeTraverser:
+    import Scala3.{_, given}
     given s.SemanticSymbolBuilder = s.SemanticSymbolBuilder()
     val synth = SyntheticsExtractor()
     given converter: s.TypeOps = s.TypeOps()
 
+
+    def toTextDocument(source: SourceFile)(using Context): TextDocument =
+      val relPath = SourceFile.relativePath(source, ctx.settings.sourceroot.value)
+      TextDocument(
+        schema = Schema.SEMANTICDB4,
+        language = Language.SCALA,
+        uri = Tools.mkURIstring(Paths.get(relPath)),
+        text = "",
+        md5 = internal.MD5.compute(String(source.content)),
+        symbols = symbolInfos.toList,
+        occurrences = occurrences.toList,
+        synthetics = synthetics.toList,
+      )
+
     /** The bodies of synthetic locals */
     private val localBodies = mutable.HashMap[Symbol, Tree]()
 
@@ -468,52 +547,5 @@ class ExtractSemanticDB extends Phase:
           registerSymbol(vparam.symbol, symkinds)
         traverse(vparam.tpt)
       tparams.foreach(tp => traverse(tp.rhs))
-
-
-object ExtractSemanticDB:
-  import java.nio.file.Path
-  import java.nio.file.Files
-  import java.nio.file.Paths
-
-  val name: String = "extractSemanticDB"
-  val description: String = "extract info into .semanticdb files"
-
-  private def semanticdbTarget(using Context): Option[Path] =
-    Option(ctx.settings.semanticdbTarget.value)
-      .filterNot(_.isEmpty)
-      .map(Paths.get(_))
-
-  private def outputDirectory(using Context): AbstractFile = ctx.settings.outputDir.value
-
-  def write(
-    source: SourceFile,
-    occurrences: List[SymbolOccurrence],
-    symbolInfos: List[SymbolInformation],
-    synthetics: List[Synthetic],
-  )(using Context): Unit =
-    def absolutePath(path: Path): Path = path.toAbsolutePath.normalize
-    val relPath = SourceFile.relativePath(source, ctx.settings.sourceroot.value)
-    val outpath = absolutePath(semanticdbTarget.getOrElse(outputDirectory.jpath))
-      .resolve("META-INF")
-      .resolve("semanticdb")
-      .resolve(relPath)
-      .resolveSibling(source.name + ".semanticdb")
-    Files.createDirectories(outpath.getParent())
-    val doc: TextDocument = TextDocument(
-      schema = Schema.SEMANTICDB4,
-      language = Language.SCALA,
-      uri = Tools.mkURIstring(Paths.get(relPath)),
-      text = "",
-      md5 = internal.MD5.compute(String(source.content)),
-      symbols = symbolInfos,
-      occurrences = occurrences,
-      synthetics = synthetics,
-    )
-    val docs = TextDocuments(List(doc))
-    val out = Files.newOutputStream(outpath)
-    try
-      val stream = internal.SemanticdbOutputStream.newInstance(out)
-      docs.writeTo(stream)
-      stream.flush()
-    finally
-      out.close()
+  end Extractor
+end ExtractSemanticDB

compiler/src/dotty/tools/dotc/semanticdb/Scala3.scala

@@ -484,6 +484,8 @@ object Scala3:
 
   given Ordering[SymbolInformation] = Ordering.by[SymbolInformation, String](_.symbol)(IdentifierOrdering())
 
+  given Ordering[Diagnostic] = (x, y) => compareRange(x.range, y.range)
+
   given Ordering[Synthetic] = (x, y) => compareRange(x.range, y.range)
 
   /**

compiler/src/dotty/tools/dotc/semanticdb/Tools.scala

@@ -69,6 +69,8 @@ object Tools:
     sb.append("Language => ").append(languageString(doc.language)).nl
     sb.append("Symbols => ").append(doc.symbols.length).append(" entries").nl
     sb.append("Occurrences => ").append(doc.occurrences.length).append(" entries").nl
+    if doc.diagnostics.nonEmpty then
+      sb.append("Diagnostics => ").append(doc.diagnostics.length).append(" entries").nl
     if doc.synthetics.nonEmpty then
       sb.append("Synthetics => ").append(doc.synthetics.length).append(" entries").nl
     sb.nl
@@ -78,6 +80,10 @@ object Tools:
     sb.append("Occurrences:").nl
     doc.occurrences.sorted.foreach(processOccurrence)
     sb.nl
+    if doc.diagnostics.nonEmpty then
+      sb.append("Diagnostics:").nl
+      doc.diagnostics.sorted.foreach(d => processDiag(d))
+      sb.nl
     if doc.synthetics.nonEmpty then
       sb.append("Synthetics:").nl
       doc.synthetics.sorted.foreach(s => processSynth(s, synthPrinter))
@@ -108,6 +114,20 @@ object Tools:
   private def processSynth(synth: Synthetic, printer: SyntheticPrinter)(using sb: StringBuilder): Unit =
     sb.append(printer.pprint(synth)).nl
 
+  private def processDiag(d: Diagnostic)(using sb: StringBuilder): Unit =
+    d.range match
+      case Some(range) => processRange(sb, range)
+      case _ => sb.append("[):")
+    sb.append(" ")
+    d.severity match
+      case Diagnostic.Severity.ERROR => sb.append("[error]")
+      case Diagnostic.Severity.WARNING => sb.append("[warning]")
+      case Diagnostic.Severity.INFORMATION => sb.append("[info]")
+      case _ => sb.append("[unknown]")
+    sb.append(" ")
+    sb.append(d.message)
+    sb.nl
+
   private def processOccurrence(occ: SymbolOccurrence)(using sb: StringBuilder, sourceFile: SourceFile): Unit =
     occ.range match
     case Some(range) =>

tests/semanticdb/metac.expect

@@ -923,6 +923,7 @@ Text => empty
 Language => Scala
 Symbols => 181 entries
 Occurrences => 148 entries
+Diagnostics => 1 entries
 Synthetics => 6 entries
 
 Symbols:
@@ -1258,6 +1259,9 @@ Occurrences:
 [68:9..68:16): Neptune <- _empty_/Enums.Planet.Neptune.
 [68:25..68:31): Planet -> _empty_/Enums.Planet#
 
+Diagnostics:
+[48:13..48:13): [warning] `:` after symbolic operator is deprecated; use backticks around operator instead
+
 Synthetics:
 [52:9..52:13):Refl => *.unapply[Option[B]]
 [52:31..52:50):identity[Option[B]] => *[Function1[A, Option[B]]]
@@ -1537,6 +1541,7 @@ Text => empty
 Language => Scala
 Symbols => 29 entries
 Occurrences => 65 entries
+Diagnostics => 1 entries
 Synthetics => 3 entries
 
 Symbols:
@@ -1637,6 +1642,11 @@ Occurrences:
 [26:57..26:58): A -> a/b/Givens.foo().(A)
 [26:59..26:64): empty -> a/b/Givens.Monoid#empty().
 
+Diagnostics:
+[24:53..24:63): [warning] An inline given alias with a function value as right-hand side can significantly increase
+generated code size. You should either drop the `inline` or rewrite the given with an
+explicit `apply` method.
+
 Synthetics:
 [12:17..12:25):sayHello => *[Int]
 [13:19..13:29):sayGoodbye => *[Int]