improvement: use pc for go to def when stale semanticdb

metals/src/main/scala/scala/meta/internal/metals/DefinitionProvider.scala

@@ -4,6 +4,7 @@ import java.{util => ju}
 
 import scala.concurrent.ExecutionContext
 import scala.concurrent.Future
+import scala.util.Try
 
 import scala.meta.inputs.Input
 import scala.meta.inputs.Position.Range
@@ -59,7 +60,6 @@ final class DefinitionProvider(
     scalaVersionSelector: ScalaVersionSelector,
     saveDefFileToDisk: Boolean,
     sourceMapper: SourceMapper,
-    warnings: () => Warnings,
 )(implicit ec: ExecutionContext, rc: ReportContext) {
 
   private val fallback = new FallbackDefinitionProvider(trees, index)
@@ -78,50 +78,62 @@ final class DefinitionProvider(
   val scaladocDefinitionProvider =
     new ScaladocDefinitionProvider(buffers, trees, destinationProvider)
 
+  private def isAmmonnite(path: AbsolutePath): Boolean =
+    path.isAmmoniteScript && buildTargets
+      .inverseSources(path)
+      .flatMap(buildTargets.targetData)
+      .exists(_.isAmmonite)
+
   def definition(
       path: AbsolutePath,
       params: TextDocumentPositionParams,
       token: CancelToken,
-  ): Future[DefinitionResult] = {
-    val fromSemanticdb =
-      semanticdbs().textDocument(path).documentIncludingStale
-    val fromSnapshot = fromSemanticdb match {
-      case Some(doc) =>
-        definitionFromSnapshot(path, params, doc)
-      case _ =>
-        DefinitionResult.empty
-    }
-    val fromCompilerOrSemanticdb =
-      fromSnapshot match {
-        case defn if defn.isEmpty && path.isScalaFilename =>
+  ): Future[DefinitionResult] =
+    for {
+      fromCompiler <-
+        if (path.isScalaFilename && !isAmmonnite(path))
           compilers().definition(params, token)
-        case defn @ DefinitionResult(_, symbol, _, _, querySymbol)
-            if symbol != querySymbol && path.isScalaFilename =>
-          compilers().definition(params, token).map { compilerDefn =>
-            if (compilerDefn.isEmpty || compilerDefn.querySymbol == querySymbol)
-              defn
-            else compilerDefn.copy(semanticdb = defn.semanticdb)
-          }
-        case defn =>
-          if (fromSemanticdb.isEmpty) {
-            warnings().noSemanticdb(path)
-          }
-          Future.successful(defn)
+        else Future.successful(DefinitionResult.empty)
+    } yield {
+      if (!fromCompiler.isEmpty) {
+        val pathToDef =
+          fromCompiler.locations.asScala.head.getUri.toAbsolutePath
+        fromCompiler.copy(semanticdb =
+          semanticdbs().textDocument(pathToDef).documentIncludingStale
+        )
+      } else {
+        val reportBuilder =
+          new DefinitionProviderReportBuilder(path, params, fromCompiler)
+        val fromSemanticDB =
+          semanticdbs()
+            .textDocument(path)
+            .documentIncludingStale
+            .map(definitionFromSnapshot(path, params, _))
+        fromSemanticDB.foreach(reportBuilder.withSemanticDBResult(_))
+        val result = fromSemanticDB match {
+          case Some(definition)
+              if !definition.isEmpty || definition.symbol.endsWith("/") =>
+            definition
+          case _ =>
+            val isScala3 =
+              ScalaVersions.isScala3Version(
+                scalaVersionSelector.scalaVersionForPath(path)
+              )
+
+            val fromScalaDoc =
+              scaladocDefinitionProvider.definition(path, params, isScala3)
+            fromScalaDoc.foreach(_ => reportBuilder.withFoundScaladocDef())
+            fromScalaDoc
+              .orElse(
+                fallback
+                  .search(path, params.getPosition(), isScala3, reportBuilder)
+              )
+              .getOrElse(fromCompiler)
+        }
+        reportBuilder.build().foreach(rc.unsanitized.create(_))
+        result
       }
-
-    fromCompilerOrSemanticdb.map { definition =>
-      if (definition.isEmpty && !definition.symbol.endsWith("/")) {
-        val isScala3 =
-          ScalaVersions.isScala3Version(
-            scalaVersionSelector.scalaVersionForPath(path)
-          )
-        scaladocDefinitionProvider
-          .definition(path, params, isScala3)
-          .orElse(fallback.search(path, params.getPosition(), isScala3))
-          .getOrElse(definition)
-      } else definition
     }
-  }
 
   def definition(
       path: AbsolutePath,
@@ -508,3 +520,89 @@ class DestinationProvider(
     }
   }
 }
+
+class DefinitionProviderReportBuilder(
+    path: AbsolutePath,
+    params: TextDocumentPositionParams,
+    compilerDefn: DefinitionResult,
+) {
+  private var semanticDBDefn: Option[DefinitionResult] = None
+
+  private var fallbackDefn: Option[DefinitionResult] = None
+  private var nonLocalGuesses: List[String] = List.empty
+
+  private var fundScaladocDef = false
+
+  private var error: Option[Throwable] = None
+
+  def withSemanticDBResult(result: DefinitionResult): this.type = {
+    semanticDBDefn = Some(result)
+    this
+  }
+
+  def withFallbackResult(result: DefinitionResult): this.type = {
+    fallbackDefn = Some(result)
+    this
+  }
+
+  def withError(e: Throwable): this.type = {
+    error = Some(e)
+    this
+  }
+
+  def withNonLocalGuesses(guesses: List[String]): this.type = {
+    nonLocalGuesses = guesses
+    this
+  }
+
+  def withFoundScaladocDef(): this.type = {
+    fundScaladocDef = true
+    this
+  }
+
+  def build(): Option[Report] =
+    Option.when(!fundScaladocDef) {
+      Report(
+        "empty-definition",
+        s"""|empty definition using pc, found symbol in pc: ${compilerDefn.querySymbol}
+            |${semanticDBDefn match {
+             case None =>
+               s"semanticdb not found"
+             case Some(defn) if defn.isEmpty =>
+               s"empty definition using semanticdb"
+             case Some(defn) =>
+               s"found definition using semanticdb; symbol ${defn.symbol}"
+           }}
+            |${fallbackDefn.map {
+             case defn if defn.isEmpty =>
+               s"""|empty definition using fallback
+                |non-local guesses:
+                |${nonLocalGuesses.mkString("\t -", "\n\t -", "")}
+                |"""
+             case defn =>
+               s"found definition using fallback; symbol ${defn.symbol}"
+           }}
+            |Document text:
+            |
+            |```scala
+            |${Try(path.readText).toOption.getOrElse("Failed to read text")}
+            |```
+            |""".stripMargin,
+        s"empty definition using pc, found symbol in pc: ${compilerDefn.querySymbol}",
+        path = Some(path.toURI),
+        id = querySymbol.orElse(
+          Some(s"${path.toURI}:${params.getPosition().getLine()}")
+        ),
+        error = error,
+      )
+    }
+
+  private def querySymbol: Option[String] =
+    compilerDefn.querySymbol match {
+      case "" =>
+        semanticDBDefn
+          .map(_.querySymbol)
+          .orElse(fallbackDefn.map(_.querySymbol))
+      case q => Some(q)
+    }
+}