Cache container names in CheckedIndex

It is important that we cache this because we might find a lot of symbols in the same container for eg. workspace symbols (eg. consider many symbols in the same C++ namespace). If we didn't cache this value, then we would need to perform a `primaryDefinitionOrDeclarationOccurrence` lookup for all of these containers, which is expensive.

For example, searching for `only` in SourceKit-LSP’s codebase used to not return results in more than 20s (after which I gave up) and now returns >8000 results in <2s.

rdar://141412138

Author: ahoppen

Sources/SemanticIndex/CheckedIndex.swift

@@ -60,6 +60,33 @@ package final class CheckedIndex {
   private var checker: IndexOutOfDateChecker
   private let index: IndexStoreDB
 
+  /// Maps the USR of a symbol’s container the name of that container as well as the name of all containers the
+  /// container might itself be contained in.
+  ///
+  /// It is important that we cache this because we might find a lot of symbols in the same container for eg. workspace
+  /// symbols (eg. consider many symbols in the same C++ namespace). If we didn't cache this value, then we would need
+  /// to perform a `primaryDefinitionOrDeclarationOccurrence` lookup for all of these containers, which is expensive.
+  ///
+  /// Since we don't expect `CheckedIndex` to be outlive a single request it is acceptable to cache these results
+  /// without having any invalidation logic (similar to how we don't invalide results cached in
+  /// `IndexOutOfDateChecker`).
+  ///
+  /// ### Examples
+  /// If we have
+  /// ```swift
+  /// struct Foo {}
+  /// ``` then
+  /// `containerNamesCache[<usr of Foo>]` will be `["Foo"]`.
+  ///
+  /// If we have
+  /// ```swift
+  /// struct Bar {
+  ///   struct Foo {}
+  /// }
+  /// ```, then
+  /// `containerNamesCache[<usr of Foo>]` will be `["Bar", "Foo"]`.
+  private var containerNamesCache: [String: [String]] = [:]
+
   fileprivate init(index: IndexStoreDB, checkLevel: IndexCheckLevel) {
     self.index = index
     self.checker = IndexOutOfDateChecker(checkLevel: checkLevel)
@@ -183,6 +210,68 @@ package final class CheckedIndex {
     }
     return result
   }
+
+  /// The names of all containers the symbol is contained in, from outermost to innermost.
+  ///
+  /// ### Examples
+  /// In the following, the container names of `test` are `["Foo"]`.
+  /// ```swift
+  /// struct Foo {
+  ///   func test() {}
+  /// }
+  /// ```
+  ///
+  /// In the following, the container names of `test` are `["Bar", "Foo"]`.
+  /// ```swift
+  /// struct Bar {
+  ///   struct Foo {
+  ///     func test() {}
+  ///   }
+  /// }
+  /// ```
+  package func containerNames(of symbol: SymbolOccurrence) -> [String] {
+    // The container name of accessors is the container of the surrounding variable.
+    let accessorOf = symbol.relations.filter { $0.roles.contains(.accessorOf) }
+    if let primaryVariable = accessorOf.sorted().first {
+      if accessorOf.count > 1 {
+        logger.fault("Expected an occurrence to an accessor of at most one symbol, not multiple")
+      }
+      if let primaryVariable = primaryDefinitionOrDeclarationOccurrence(ofUSR: primaryVariable.symbol.usr) {
+        return containerNames(of: primaryVariable)
+      }
+    }
+
+    let containers = symbol.relations.filter { $0.roles.contains(.childOf) }
+    if containers.count > 1 {
+      logger.fault("Expected an occurrence to a child of at most one symbol, not multiple")
+    }
+    let container = containers.filter {
+      switch $0.symbol.kind {
+      case .module, .namespace, .enum, .struct, .class, .protocol, .extension, .union:
+        return true
+      case .unknown, .namespaceAlias, .macro, .typealias, .function, .variable, .field, .enumConstant,
+        .instanceMethod, .classMethod, .staticMethod, .instanceProperty, .classProperty, .staticProperty, .constructor,
+        .destructor, .conversionFunction, .parameter, .using, .concept, .commentTag:
+        return false
+      }
+    }.sorted().first
+
+    if let container {
+      if let cached = containerNamesCache[container.symbol.usr] {
+        return cached
+      }
+      let result: [String]
+      if let containerDefinition = primaryDefinitionOrDeclarationOccurrence(ofUSR: container.symbol.usr) {
+        result = self.containerNames(of: containerDefinition) + [container.symbol.name]
+      } else {
+        result = [container.symbol.name]
+      }
+      containerNamesCache[container.symbol.usr] = result
+      return result
+    } else {
+      return []
+    }
+  }
 }
 
 /// A wrapper around `IndexStoreDB` that allows the retrieval of a `CheckedIndex` with a specified check level or the

Sources/SourceKitLSP/SourceKitLSPServer.swift

@@ -2395,48 +2395,11 @@ private let maxWorkspaceSymbolResults = 4096
 package typealias Diagnostic = LanguageServerProtocol.Diagnostic
 
 fileprivate extension CheckedIndex {
-  func containerNames(of symbol: SymbolOccurrence) -> [String] {
-    // The container name of accessors is the container of the surrounding variable.
-    let accessorOf = symbol.relations.filter { $0.roles.contains(.accessorOf) }
-    if let primaryVariable = accessorOf.sorted().first {
-      if accessorOf.count > 1 {
-        logger.fault("Expected an occurrence to an accessor of at most one symbol, not multiple")
-      }
-      if let primaryVariable = primaryDefinitionOrDeclarationOccurrence(ofUSR: primaryVariable.symbol.usr) {
-        return containerNames(of: primaryVariable)
-      }
-    }
-
-    let containers = symbol.relations.filter { $0.roles.contains(.childOf) }
-    if containers.count > 1 {
-      logger.fault("Expected an occurrence to a child of at most one symbol, not multiple")
-    }
-    let container = containers.filter {
-      switch $0.symbol.kind {
-      case .module, .namespace, .enum, .struct, .class, .protocol, .extension, .union:
-        return true
-      case .unknown, .namespaceAlias, .macro, .typealias, .function, .variable, .field, .enumConstant,
-        .instanceMethod, .classMethod, .staticMethod, .instanceProperty, .classProperty, .staticProperty, .constructor,
-        .destructor, .conversionFunction, .parameter, .using, .concept, .commentTag:
-        return false
-      }
-    }.sorted().first
-
-    if let container {
-      if let containerDefinition = primaryDefinitionOrDeclarationOccurrence(ofUSR: container.symbol.usr) {
-        return self.containerNames(of: containerDefinition) + [container.symbol.name]
-      }
-      return [container.symbol.name]
-    } else {
-      return []
-    }
-  }
-
   /// Take the name of containers into account to form a fully-qualified name for the given symbol.
   /// This means that we will form names of nested types and type-qualify methods.
   func fullyQualifiedName(of symbolOccurrence: SymbolOccurrence) -> String {
     let symbol = symbolOccurrence.symbol
-    let containerNames = containerNames(of: symbolOccurrence)
+    let containerNames = self.containerNames(of: symbolOccurrence)
     guard let containerName = containerNames.last else {
       // No containers, so nothing to do.
       return symbol.name