[WIP] Don't parse TextDocuments in AppendDiagnostics

Author: tanishiking

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

@@ -30,6 +30,11 @@ import dotty.tools.io.{AbstractFile, JarArchive}
 import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.semanticdb.DiagnosticOps.*
 import scala.util.{Using, Failure, Success}
+import com.google.protobuf.Empty
+import com.google.protobuf.UnknownFieldSet
+import com.google.protobuf.UnknownFieldSet.Field
+import java.io.ByteArrayOutputStream
+import java.io.BufferedOutputStream
 
 
 /** Extract symbol references and uses to semanticdb files.
@@ -63,22 +68,20 @@ class ExtractSemanticDB private (phaseMode: ExtractSemanticDB.PhaseMode, suffix:
 
   override def runOn(units: List[CompilationUnit])(using ctx: Context): List[CompilationUnit] = {
     val appendDiagnostics = phaseMode == ExtractSemanticDB.PhaseMode.AppendDiagnostics
-    val warnings =
-      if (appendDiagnostics)
-        ctx.reporter.allWarnings.groupBy(w => w.pos.source)
-      else Map.empty
-
-    units.asJava.parallelStream().forEach { unit =>
-      val unitCtx = ctx.fresh.setCompilationUnit(unit).withRootImports
-      if (appendDiagnostics)
+    if (appendDiagnostics)
+      val warnings = ctx.reporter.allWarnings.groupBy(w => w.pos.source)
+      units.asJava.parallelStream().forEach { unit =>
+        val unitCtx = ctx.fresh.setCompilationUnit(unit).withRootImports
         warnings.get(unit.source).foreach { ws =>
           ExtractSemanticDB.appendDiagnostics(unit.source, ws.map(_.toSemanticDiagnostic))
         }
-      else
+      }
+    else
+      units.foreach { unit =>
         val extractor = ExtractSemanticDB.Extractor()
         extractor.extract(unit.tpdTree)
         ExtractSemanticDB.write(unit.source, extractor.occurrences.toList, extractor.symbolInfos.toList, extractor.synthetics.toList)
-    }
+      }
     units
   }
 
@@ -145,15 +148,43 @@ object ExtractSemanticDB:
     val path = semanticdbPath(source)
     Using.Manager { use =>
       val in = use(Files.newInputStream(path))
-      val sin = internal.SemanticdbInputStream.newInstance(in)
-      val docs = TextDocuments.parseFrom(sin)
+      // val sin = internal.SemanticdbInputStream.newInstance(in)
+      val textDocuments = Empty.parseFrom(in)
+      val docsBytes = textDocuments.getUnknownFields().getField(TextDocuments.DOCUMENTS_FIELD_NUMBER).getLengthDelimitedList()
+      val docFields = Empty.parseFrom(docsBytes.get(0)).getUnknownFields()
+      if (source.file.name == "ValPattern.scala")
+        println(docFields)
+      //docMap.put(7, )
+
+      // val docs = TextDocuments.parseFrom(sin)
+
+      val bos = use(new ByteArrayOutputStream())
+      val sbos = internal.SemanticdbOutputStream.newInstance(bos)
+      val doc = TextDocument(diagnostics = diagnostics)
+      doc.writeTo(sbos)
+      sbos.flush()
+      val diagnosticsOnly = Empty.parseFrom(bos.toByteArray()).getUnknownFields()
+
+      val merged = docFields.toBuilder().mergeFrom(diagnosticsOnly).build()
+      // println(merged)
+      val field = Field.newBuilder().addLengthDelimited(merged.toByteString()).build()
+
+      val fields = textDocuments.getUnknownFields().toBuilder().mergeField(TextDocuments.DOCUMENTS_FIELD_NUMBER, field).build()
+      // println(fields)
+      val updated = textDocuments.toBuilder().setUnknownFields(fields).build()
+      if (source.file.name == "ValPattern.scala")
+        println(updated)
 
       val out = use(Files.newOutputStream(path))
-      val sout = internal.SemanticdbOutputStream.newInstance(out)
-      TextDocuments(docs.documents.map(_.withDiagnostics(diagnostics))).writeTo(sout)
-      sout.flush()
+      val bout = new BufferedOutputStream(out)
+      updated.writeTo(bout)
+      bout.flush()
+      // val sout = internal.SemanticdbOutputStream.newInstance(out)
+      // TextDocuments(docs.documents.map(_.withDiagnostics(diagnostics))).writeTo(sout)
     } match
-      case Failure(ex) => // failed somehow, should we say something?
+      case Failure(ex) =>
+        println(ex.getMessage())
+        // failed somehow, should we say something?
       case Success(_) => // success to update semanticdb, say nothing
   end appendDiagnostics
 

compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala

@@ -87,8 +87,12 @@ class SemanticdbTests:
         .resolve("semanticdb")
         .resolve(relpath)
         .resolveSibling(filename + ".semanticdb")
+      println(semanticdbPath)
       val expectPath = source.resolveSibling(filename.replace(".scala", ".expect.scala"))
       val doc = Tools.loadTextDocument(source, relpath, semanticdbPath)
+      println(semanticdbPath.getFileName().toString())
+      if (semanticdbPath.getFileName().toString() == "ValPattern.scala.semanticdb")
+      println(doc)
       Tools.metac(doc, rootSrc.relativize(source))(using metacSb)
       val obtained = trimTrailingWhitespace(SemanticdbTests.printTextDocument(doc))
       collectErrorOrUpdate(expectPath, obtained)