Reuse relativize logic in semanticDB

Author: liufengyun

compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala

@@ -8,20 +8,21 @@ import dotty.tools.tasty.TastyBuffer
 import TastyBuffer._
 
 import ast._
-import ast.Trees._
-import ast.Trees.WithLazyField
+import Trees.WithLazyField
 import util.{SourceFile, NoSource}
 import core._
-import Contexts._, Symbols._, Annotations._, Decorators._
+import Annotations._, Decorators._
 import collection.mutable
 import util.Spans._
 
 class PositionPickler(
     pickler: TastyPickler,
     addrOfTree: PositionPickler.TreeToAddr,
-    treeAnnots: untpd.MemberDef => List[tpd.Tree])(using Context) {
+    treeAnnots: untpd.MemberDef => List[tpd.Tree],
+    relativePathReference: String){
 
   import ast.tpd._
+
   val buf: TastyBuffer = new TastyBuffer(5000)
   pickler.newSection(PositionsSection, buf)
 
@@ -67,9 +68,9 @@ class PositionPickler(
         // specialization.
     }
 
-    def pickleSource(source: SourceFile)(using Context): Unit = {
+    def pickleSource(source: SourceFile): Unit = {
       buf.writeInt(SOURCE)
-      val relativePath = SourceFile.relativePath(source)
+      val relativePath = SourceFile.relativePath(source, relativePathReference)
       buf.writeInt(pickler.nameBuffer.nameIndex(relativePath.toTermName).index)
     }
 
@@ -94,7 +95,7 @@ class PositionPickler(
       case _ => false
     }
 
-    def traverse(x: Any, current: SourceFile)(using Context): Unit = x match {
+    def traverse(x: Any, current: SourceFile): Unit = x match {
       case x: untpd.Tree =>
         if (x.span.exists) {
           val addr = addrOfTree(x)

compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala

@@ -167,7 +167,8 @@ object PickledQuotes {
     treePkl.compactify()
     if tree.span.exists then
       val positionWarnings = new mutable.ListBuffer[String]()
-      new PositionPickler(pickler, treePkl.buf.addrOfTree, treePkl.treeAnnots)
+      val reference = ctx.settings.sourceroot.value
+      new PositionPickler(pickler, treePkl.buf.addrOfTree, treePkl.treeAnnots, reference)
         .picklePositions(ctx.compilationUnit.source, tree :: Nil, positionWarnings)
       positionWarnings.foreach(report.warning(_))
 

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

@@ -5,26 +5,23 @@ package semanticdb
 import core._
 import Phases._
 import ast.tpd._
+import ast.untpd.given
 import ast.Trees.mods
 import Contexts._
 import Symbols._
 import Flags._
 import Names.Name
 import StdNames.nme
+import NameOps._
 import util.Spans.Span
 import util.{SourceFile, SourcePosition}
-import scala.jdk.CollectionConverters._
-import collection.mutable
-import java.nio.file.Paths
-
-import dotty.tools.dotc.transform.SymUtils._
-
-import PartialFunction.condOpt
-
-import ast.untpd.given
-import NameOps._
+import transform.SymUtils._
 
+import scala.jdk.CollectionConverters._
+import scala.collection.mutable
 import scala.annotation.{ threadUnsafe => tu, tailrec }
+import scala.PartialFunction.condOpt
+
 
 /** Extract symbol references and uses to semanticdb files.
  *  See https://scalameta.org/docs/semanticdb/specification.html#symbol-1
@@ -590,37 +587,29 @@ object ExtractSemanticDB:
   import java.nio.file.Path
   import scala.collection.JavaConverters._
   import java.nio.file.Files
+  import java.nio.file.Paths
 
   val name: String = "extractSemanticDB"
 
   def write(source: SourceFile, occurrences: List[SymbolOccurrence], symbolInfos: List[SymbolInformation])(using Context): Unit =
     def absolutePath(path: Path): Path = path.toAbsolutePath.normalize
-    def commonPrefix[T](z: T)(i1: Iterable[T], i2: Iterable[T])(app: (T, T) => T): T =
-      (i1 lazyZip i2).takeWhile(p => p(0) == p(1)).map(_(0)).foldLeft(z)(app)
-    val sourcePath = absolutePath(source.file.jpath)
-    val sourceRoot =
-      // Here if `sourceRoot` and `sourcePath` do not share a common prefix then `relPath` will not be normalised,
-      // containing ../.. etc, which is problematic when appending to `/META-INF/semanticdb/` and will not be accepted
-      // by Files.createDirectories on JDK 11.
-      val sourceRoot0 = absolutePath(Paths.get(ctx.settings.sourceroot.value))
-      commonPrefix(sourcePath.getRoot)(sourcePath.asScala, sourceRoot0.asScala)(_ resolve _)
     val semanticdbTarget =
       val semanticdbTargetSetting = ctx.settings.semanticdbTarget.value
       absolutePath(
         if semanticdbTargetSetting.isEmpty then ctx.settings.outputDir.value.jpath
         else Paths.get(semanticdbTargetSetting)
       )
-    val relPath = sourceRoot.relativize(sourcePath)
+    val relPath = SourceFile.relativePath(source, ctx.settings.sourceroot.value)
     val outpath = semanticdbTarget
       .resolve("META-INF")
       .resolve("semanticdb")
       .resolve(relPath)
-      .resolveSibling(sourcePath.getFileName().toString() + ".semanticdb")
+      .resolveSibling(source.name + ".semanticdb")
     Files.createDirectories(outpath.getParent())
     val doc: TextDocument = TextDocument(
       schema = Schema.SEMANTICDB4,
       language = Language.SCALA,
-      uri = Tools.mkURIstring(relPath),
+      uri = Tools.mkURIstring(Paths.get(relPath)),
       text = "",
       md5 = internal.MD5.compute(String(source.content)),
       symbols = symbolInfos,

compiler/src/dotty/tools/dotc/transform/Pickler.scala

@@ -72,7 +72,8 @@ class Pickler extends Phase {
         Future {
           treePkl.compactify()
           if tree.span.exists then
-            new PositionPickler(pickler, treePkl.buf.addrOfTree, treePkl.treeAnnots)
+            val reference = ctx.settings.sourceroot.value
+            new PositionPickler(pickler, treePkl.buf.addrOfTree, treePkl.treeAnnots, reference)
               .picklePositions(unit.source, tree :: Nil, positionWarnings)
 
           if !ctx.settings.YdropComments.value then

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -335,7 +335,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
                && ctx.compilationUnit.source.exists
                && sym != defn.SourceFileAnnot
             then
-              val relativePath = util.SourceFile.relativePath(ctx.compilationUnit.source)
+              val reference = ctx.settings.sourceroot.value
+              val relativePath = util.SourceFile.relativePath(ctx.compilationUnit.source, reference)
               sym.addAnnotation(Annotation.makeSourceFile(relativePath))
           else (tree.rhs, sym.info) match
             case (rhs: LambdaTypeTree, bounds: TypeBounds) =>

compiler/src/dotty/tools/dotc/util/SourceFile.scala

@@ -210,21 +210,32 @@ object SourceFile {
     src._maybeInComplete = maybeIncomplete
     src
 
-  def relativePath(source: SourceFile)(using Context): String = {
-    def sourcerootPath =
-      java.nio.file.Paths.get(ctx.settings.sourceroot.value)
-      .toAbsolutePath
-      .normalize
+  /** Returns the relative path of `source` within the `reference` path
+   *
+   *  It returns the absolute path of `source` if it is not contained in `reference`.
+   */
+  def relativePath(source: SourceFile, reference: String): String = {
     val file = source.file
     val jpath = file.jpath
     if jpath eq null then
       file.path // repl and other custom tests use abstract files with no path
     else
-      val normalizedPath = jpath.normalize
-      // On Windows we can only relativize paths if root component matches
-      // (see implementation of sun.nio.fs.WindowsPath#relativize)
-      try sourcerootPath.relativize(normalizedPath).toString
-      catch case _: IllegalArgumentException => normalizedPath.toString
+      val sourcePath = jpath.toAbsolutePath.normalize
+      val refPath = java.nio.file.Paths.get(reference).toAbsolutePath.normalize
+
+      if sourcePath.startsWith(refPath) then
+        // On Windows we can only relativize paths if root component matches
+        // (see implementation of sun.nio.fs.WindowsPath#relativize)
+        //
+        //     try refPath.relativize(sourcePath).toString
+        //     catch case _: IllegalArgumentException => sourcePath.toString
+        //
+        // As we already check that the prefix matches, the special handling for
+        // Windows is not needed.
+
+        refPath.relativize(sourcePath).toString
+      else
+        sourcePath.toString
   }
 }
 

language-server/test/dotty/tools/languageserver/util/server/TestFile.scala

@@ -9,6 +9,6 @@ class TestFile(val file: String) extends AnyVal {
 }
 
 object TestFile {
-  lazy val testDir: Path = Paths.get("../out/ide-tests").toAbsolutePath
+  lazy val testDir: Path = Paths.get("../out/ide-tests").toAbsolutePath.normalize
   lazy val sourceDir: Path = testDir.resolve("src")
 }