feature: go to implementations for dependency sources

metals-bench/src/main/scala/bench/MetalsBench.scala

@@ -99,6 +99,20 @@ class MetalsBench {
     }
   }
 
+  @Benchmark
+  @BenchmarkMode(Array(Mode.SingleShotTime))
+  def typeHierarchyIndex(): Unit = {
+    scalaDependencySources.inputs.foreach { input =>
+      implicit val rc: ReportContext = EmptyReportContext
+      new ScalaToplevelMtags(
+        input,
+        includeInnerClasses = true,
+        includeMembers = false,
+        dialects.Scala213,
+      ).index()
+    }
+  }
+
   @Benchmark
   @BenchmarkMode(Array(Mode.SingleShotTime))
   def scalaTokenize(): Unit = {

metals/src/main/resources/db/migration/V5__Jar_type_hierarchy.sql

@@ -0,0 +1,14 @@
+-- Type hierarchy information, e.g. symbol: "a/MyException#", extended_name: "Exception"
+create table type_hierarchy(
+  symbol varchar not null,
+  parent_name varchar not null,
+  path varchar not null,
+  jar int,
+  is_resolved bit,
+  foreign key (jar) references indexed_jar (id) on delete cascade
+);
+
+create index type_hierarchy_jar on type_hierarchy(jar);
+
+alter table indexed_jar
+add type_hierarchy_indexed bit

metals/src/main/scala/scala/meta/internal/implementation/GlobalClassTable.scala

@@ -5,6 +5,7 @@ import scala.collection.concurrent.TrieMap
 import scala.collection.mutable
 
 import scala.meta.internal.metals.BuildTargets
+import scala.meta.internal.metals.Compilers
 import scala.meta.internal.semanticdb.SymbolInformation
 import scala.meta.internal.symtab.GlobalSymbolTable
 import scala.meta.io.AbsolutePath
@@ -26,11 +27,16 @@ final class GlobalClassTable(
   def globalContextFor(
       source: AbsolutePath,
       implementationsInPath: ImplementationCache,
+      compilers: Compilers,
+      implementationsInDependencySources: Map[String, Set[ClassLocation]],
   ): Option[InheritanceContext] = {
     for {
       symtab <- globalSymbolTableFor(source)
     } yield {
-      calculateIndex(symtab, implementationsInPath)
+      calculateIndex(symtab, implementationsInPath).toGlobal(
+        compilers,
+        implementationsInDependencySources,
+      )
     }
   }
 

metals/src/main/scala/scala/meta/internal/implementation/ImplementationProvider.scala

@@ -1,5 +1,6 @@
 package scala.meta.internal.implementation
 
+import java.nio.charset.StandardCharsets
 import java.nio.file.Path
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.ConcurrentLinkedQueue
@@ -9,17 +10,24 @@ import scala.concurrent.ExecutionContext
 import scala.concurrent.Future
 import scala.util.control.NonFatal
 
+import scala.meta.internal.io.FileIO
 import scala.meta.internal.metals.Buffers
 import scala.meta.internal.metals.BuildTargets
+import scala.meta.internal.metals.Compilers
 import scala.meta.internal.metals.DefinitionProvider
 import scala.meta.internal.metals.MetalsEnrichments._
 import scala.meta.internal.metals.ReportContext
 import scala.meta.internal.metals.ScalaVersionSelector
+import scala.meta.internal.metals.ScalaVersions
 import scala.meta.internal.metals.SemanticdbFeatureProvider
 import scala.meta.internal.mtags.GlobalSymbolIndex
+import scala.meta.internal.mtags.IndexingResult
 import scala.meta.internal.mtags.Mtags
+import scala.meta.internal.mtags.OverriddenSymbol
+import scala.meta.internal.mtags.ResolvedOverriddenSymbol
 import scala.meta.internal.mtags.Semanticdbs
 import scala.meta.internal.mtags.SymbolDefinition
+import scala.meta.internal.mtags.UnresolvedOverriddenSymbol
 import scala.meta.internal.mtags.{Symbol => MSymbol}
 import scala.meta.internal.parsing.Trees
 import scala.meta.internal.semanticdb.ClassSignature
@@ -46,13 +54,16 @@ final class ImplementationProvider(
     definitionProvider: DefinitionProvider,
     trees: Trees,
     scalaVersionSelector: ScalaVersionSelector,
+    compilers: Compilers,
 )(implicit ec: ExecutionContext, rc: ReportContext)
     extends SemanticdbFeatureProvider {
   import ImplementationProvider._
 
   private val globalTable = new GlobalClassTable(buildTargets)
   private val implementationsInPath =
     new ConcurrentHashMap[Path, Map[String, Set[ClassLocation]]]
+  private val implementationsInDependencySources =
+    new ConcurrentHashMap[String, Set[ClassLocation]]
 
   override def reset(): Unit = {
     implementationsInPath.clear()
@@ -70,6 +81,44 @@ final class ImplementationProvider(
       )
   }
 
+  def addTypeHierarchy(results: List[IndexingResult]): Unit = for {
+    IndexingResult(path, _, overrides) <- results
+    (overridesSymbol, overriddenSymbols) <- overrides
+    overridden <- overriddenSymbols
+  } addTypeHierarchyElement(path, overridesSymbol, overridden)
+
+  def addTypeHierarchyElements(
+      elements: List[(AbsolutePath, String, OverriddenSymbol)]
+  ): Unit = elements.foreach { case (path, overridesSymbol, overridden) =>
+    addTypeHierarchyElement(path, overridesSymbol, overridden)
+  }
+
+  private def addTypeHierarchyElement(
+      path: AbsolutePath,
+      overridesSymbol: String,
+      overridden: OverriddenSymbol,
+  ): Unit = {
+    def createUpdate(
+        newSymbol: ClassLocation
+    ): (String, Set[ClassLocation]) => Set[ClassLocation] = {
+      case (_, null) => Set(newSymbol)
+      case (_, previous) => previous + newSymbol
+    }
+    overridden match {
+      case ResolvedOverriddenSymbol(symbol) =>
+        val update = createUpdate(
+          ClassLocation(overridesSymbol, Some(path.toNIO))
+        )
+        implementationsInDependencySources.compute(symbol, update(_, _))
+      case UnresolvedOverriddenSymbol(name) =>
+        val update =
+          createUpdate(
+            ClassLocation(overridesSymbol, Some(path.toNIO))
+          )
+        implementationsInDependencySources.compute(name, update(_, _))
+    }
+  }
+
   private def computeInheritance(
       documents: TextDocuments
   ): Map[String, Set[ClassLocation]] = {
@@ -129,29 +178,29 @@ final class ImplementationProvider(
           dealiasClass(sym, symbolSearch)
         else sym
 
-      val definitionDocument =
-        if (currentDocument.definesSymbol(dealiased)) {
-          Some(currentDocument)
-        } else {
-          findSemanticDbForSymbol(dealiased)
-        }
+      val isWorkspaceSymbol =
+        (source.isWorkspaceSource(workspace) &&
+          currentDocument.definesSymbol(dealiased)) ||
+          findSymbolDefinition(dealiased).exists(
+            _.path.isWorkspaceSource(workspace)
+          )
 
-      val inheritanceContext = definitionDocument match {
-        // symbol is not in workspace, we only search classpath for it
-        case None =>
-          globalTable.globalContextFor(
-            source,
+      val inheritanceContext = if (!isWorkspaceSymbol) {
+        // symbol is not in workspace, we search both workspace and dependencies for it
+        globalTable.globalContextFor(
+          source,
+          implementationsInPath.asScala.toMap,
+          compilers,
+          implementationsInDependencySources.asScala.toMap,
+        )
+      } else {
+        // symbol in workspace we search the workspace for it only
+        Some(
+          InheritanceContext.fromDefinitions(
+            symbolSearch,
             implementationsInPath.asScala.toMap,
           )
-        // symbol is in workspace,
-        // we might need to search different places for related symbols
-        case Some(_) =>
-          Some(
-            InheritanceContext.fromDefinitions(
-              symbolSearch,
-              implementationsInPath.asScala.toMap,
-            )
-          )
+        )
       }
       symbolLocationsFromContext(
         dealiased,
@@ -296,12 +345,7 @@ final class ImplementationProvider(
           file <- files
           locations = locationsByFile(file)
           implPath = AbsolutePath(file)
-          implDocument <- findSemanticdb(implPath).toIterable
-          distance = buffer.tokenEditDistance(
-            implPath,
-            implDocument.text,
-            trees,
-          )
+          implDocument <- findSemanticdb(implPath, handleJars = true)
           implLocation <- locations
           implSymbol <- findImplementationSymbol(
             parentSymbol,
@@ -318,7 +362,17 @@ final class ImplementationProvider(
             source,
           )
           range <- implOccurrence.range
-          revised <- distance.toRevised(range.toLsp)
+          revised <-
+            if (implPath.isJarFileSystem) {
+              Some(range.toLsp)
+            } else {
+              val distance = buffer.tokenEditDistance(
+                implPath,
+                implDocument.text,
+                trees,
+              )
+              distance.toRevised(range.toLsp)
+            }
         } { allLocations.add(new Location(file.toUri.toString, revised)) }
       }
 
@@ -327,55 +381,96 @@ final class ImplementationProvider(
       classContext <- inheritanceContext.toIterable
       parentSymbol <- classContext.findSymbol(symbol).toIterable
       symbolClass <- classFromSymbol(parentSymbol, classContext.findSymbol)
-      locationsByFile = findImplementation(
-        symbolClass.symbol,
-        classContext,
-        source.toNIO,
-      )
-      files <- locationsByFile.keySet.grouped(
-        Math.max(locationsByFile.size / cores, 1)
-      )
-    } yield findImplementationLocations(files, locationsByFile, parentSymbol)
+    } yield {
+      for {
+        locationsByFile <- findImplementation(
+          symbolClass.symbol,
+          classContext,
+          source.toNIO,
+        )
+        files = locationsByFile.keySet.grouped(
+          Math.max(locationsByFile.size / cores, 1)
+        )
+        collected <-
+          Future.sequence(
+            files.map(
+              findImplementationLocations(_, locationsByFile, parentSymbol)
+            )
+          )
+      } yield collected
+    }
     Future.sequence(splitJobs).map { _ =>
       allLocations.asScala.toSeq
     }
   }
 
-  private def findSemanticdb(fileSource: AbsolutePath): Option[TextDocument] = {
+  private def findSemanticdb(
+      fileSource: AbsolutePath,
+      handleJars: Boolean = false,
+  ): Option[TextDocument] = {
     if (fileSource.isJarFileSystem)
-      None
+      if (!handleJars) None
+      else Some(semanticdbForJarFile(fileSource))
     else
       semanticdbs
         .textDocument(fileSource)
         .documentIncludingStale
   }
 
+  private def semanticdbForJarFile(fileSource: AbsolutePath) = {
+    val dialect = ScalaVersions.dialectForDependencyJar(fileSource.filename)
+    FileIO.slurp(fileSource, StandardCharsets.UTF_8)
+    val textDocument = Mtags.index(fileSource, dialect)
+    textDocument
+  }
+
   private def findImplementation(
       symbol: String,
       classContext: InheritanceContext,
       file: Path,
-  ): Map[Path, Set[ClassLocation]] = {
-
-    def loop(symbol: String, currentPath: Option[Path]): Set[ClassLocation] = {
+  ): Future[Map[Path, Set[ClassLocation]]] = {
+    val visited = mutable.Set.empty[String]
+
+    def loop(
+        symbol: String,
+        currentPath: Option[Path],
+    ): Future[Set[ClassLocation]] = {
+      visited.add(symbol)
+      scribe.debug(s"searching for implementations for symbol $symbol")
       val directImplementations =
-        classContext.getLocations(symbol).filterNot { loc =>
-          // we are not interested in local symbols from outside the workspace
-          (loc.symbol.isLocal && loc.file.isEmpty) ||
-          // for local symbols, inheritance should only be picked up in the same file
-          // otherwise there can be a name collision between files
-          // local1' is from file A, local2 extends local1''
-          // but both local2 and local1'' are from file B
-          // clearly, local2 shouldn't be considered for local1'
-          (symbol.isLocal && loc.symbol.isLocal && loc.file != currentPath)
-        }
-      directImplementations ++ directImplementations
-        .flatMap { loc => loop(loc.symbol, loc.file) }
+        classContext
+          .getLocations(symbol)
+          .map(_.filterNot { loc =>
+            // we are not interested in local symbols from outside the workspace
+            (loc.symbol.isLocal && loc.file.isEmpty) ||
+            // for local symbols, inheritance should only be picked up in the same file
+            // otherwise there can be a name collision between files
+            // local1' is from file A, local2 extends local1''
+            // but both local2 and local1'' are from file B
+            // clearly, local2 shouldn't be considered for local1'
+            (symbol.isLocal && loc.symbol.isLocal && loc.file != currentPath)
+          })
+      directImplementations.flatMap { directImplementations =>
+        Future
+          .sequence(
+            directImplementations
+              .withFilter(loc =>
+                (!visited(
+                  loc.symbol
+                ) && loc.symbol.desc.isType) || loc.symbol.isLocal
+              )
+              .map { loc =>
+                loop(loc.symbol, loc.file)
+              }
+          )
+          .map(rec => directImplementations ++ rec.flatten)
+      }
     }
 
-    loop(symbol, Some(file)).groupBy(_.file).collect {
+    loop(symbol, Some(file)).map(_.groupBy(_.file).collect {
       case (Some(path), locs) =>
         path -> locs
-    }
+    })
   }
 
   private def findSymbolInformation(