Merge pull request #1017 from ahoppen/ahoppen/secondary-cursor-info-results

Report secondary cursor info results

Author: ahoppen

Sources/SKTestSupport/IndexedSingleSwiftFileWorkspace.swift

@@ -31,12 +31,15 @@ public struct IndexedSingleSwiftFileWorkspace {
   ///
   /// - Parameters:
   ///   - markedText: The contents of the source file including location markers.
+  ///   - allowBuildFailure: Whether to fail if the input source file fails to build or whether to continue the test
+  ///     even if the input source is invalid.
   ///   - workspaceDirectory: If specified, the temporary files will be put in this directory. If `nil` a temporary
   ///     scratch directory will be created based on `testName`.
   ///   - cleanUp: Whether to remove the temporary directory when the SourceKit-LSP server shuts down.
   public init(
     _ markedText: String,
     indexSystemModules: Bool = false,
+    allowBuildFailure: Bool = false,
     workspaceDirectory: URL? = nil,
     cleanUp: Bool = cleanScratchDirectories,
     testName: String = #function
@@ -83,7 +86,13 @@ public struct IndexedSingleSwiftFileWorkspace {
     )
 
     // Run swiftc to build the index store
-    try await Process.checkNonZeroExit(arguments: [swiftc.path] + compilerArguments)
+    do {
+      try await Process.checkNonZeroExit(arguments: [swiftc.path] + compilerArguments)
+    } catch {
+      if !allowBuildFailure {
+        throw error
+      }
+    }
 
     // Create the test client
     var options = SourceKitServer.Options.testDefault

Sources/SourceKitD/sourcekitd_uids.swift

@@ -79,6 +79,7 @@ public struct sourcekitd_keys {
   public let request: sourcekitd_uid_t
   public let results: sourcekitd_uid_t
   public let retrieve_refactor_actions: sourcekitd_uid_t
+  public let secondarySymbols: sourcekitd_uid_t
   public let semantic_tokens: sourcekitd_uid_t
   public let severity: sourcekitd_uid_t
   public let sourceEditKindActive: sourcekitd_uid_t
@@ -186,6 +187,7 @@ public struct sourcekitd_keys {
     request = api.uid_get_from_cstr("key.request")!
     results = api.uid_get_from_cstr("key.results")!
     retrieve_refactor_actions = api.uid_get_from_cstr("key.retrieve_refactor_actions")!
+    secondarySymbols = api.uid_get_from_cstr("key.secondary_symbols")!
     semantic_tokens = api.uid_get_from_cstr("key.semantic_tokens")!
     severity = api.uid_get_from_cstr("key.severity")!
     sourceEditKindActive = api.uid_get_from_cstr("source.edit.kind.active")!

Sources/SourceKitLSP/SourceKitServer.swift

@@ -1709,49 +1709,24 @@ extension SourceKitServer {
     return try await languageService.declaration(req)
   }
 
-  /// Returns the result of a `DefinitionRequest` by running a `SymbolInfoRequest`, inspecting
-  /// its result and doing index lookups, if necessary.
-  ///
-  /// In contrast to `definition`, this does not fall back to sending a `DefinitionRequest` to the
-  /// toolchain language server.
-  private func indexBasedDefinition(
-    _ req: DefinitionRequest,
-    workspace: Workspace,
+  /// Return the locations for jump to definition from the given `SymbolDetails`.
+  private func definitionLocations(
+    for symbol: SymbolDetails,
+    in uri: DocumentURI,
     languageService: ToolchainLanguageServer
   ) async throws -> [Location] {
-    let symbols = try await languageService.symbolInfo(
-      SymbolInfoRequest(
-        textDocument: req.textDocument,
-        position: req.position
-      )
-    )
-    guard let symbol = symbols.first else {
-      return []
-    }
-
-    if let bestLocalDeclaration = symbol.bestLocalDeclaration,
-      !(symbol.isDynamic ?? true),
-      symbol.usr?.hasPrefix("s:") ?? false /* Swift symbols have USRs starting with s: */
-    {
-      // If we have a known non-dynamic symbol within Swift, we don't need to do an index lookup.
-      // For non-Swift symbols, we need to perform an index lookup because the best local declaration will point to
-      // a header file but jump-to-definition should prefer the implementation (there's the declaration request to jump
-      // to the function's declaration).
-      return [bestLocalDeclaration]
-    }
-
     // If this symbol is a module then generate a textual interface
     if symbol.kind == .module, let name = symbol.name {
       let interfaceLocation = try await self.definitionInInterface(
-        req,
         moduleName: name,
         symbolUSR: nil,
+        originatorUri: uri,
         languageService: languageService
       )
       return [interfaceLocation]
     }
 
-    guard let index = await self.workspaceForDocument(uri: req.textDocument.uri)?.index else {
+    guard let index = await self.workspaceForDocument(uri: uri)?.index else {
       if let bestLocalDeclaration = symbol.bestLocalDeclaration {
         return [bestLocalDeclaration]
       } else {
@@ -1800,16 +1775,46 @@ extension SourceKitServer {
       if URL(fileURLWithPath: occurrence.location.path).pathExtension == "swiftinterface" {
         // If the location is in `.swiftinterface` file, use moduleName to return textual interface.
         return try await self.definitionInInterface(
-          req,
           moduleName: occurrence.location.moduleName,
           symbolUSR: occurrence.symbol.usr,
+          originatorUri: uri,
           languageService: languageService
         )
       }
       return indexToLSPLocation(occurrence.location)
     }
   }
 
+  /// Returns the result of a `DefinitionRequest` by running a `SymbolInfoRequest`, inspecting
+  /// its result and doing index lookups, if necessary.
+  ///
+  /// In contrast to `definition`, this does not fall back to sending a `DefinitionRequest` to the
+  /// toolchain language server.
+  private func indexBasedDefinition(
+    _ req: DefinitionRequest,
+    workspace: Workspace,
+    languageService: ToolchainLanguageServer
+  ) async throws -> [Location] {
+    let symbols = try await languageService.symbolInfo(
+      SymbolInfoRequest(
+        textDocument: req.textDocument,
+        position: req.position
+      )
+    )
+    return try await symbols.asyncMap { (symbol) -> [Location] in
+      if symbol.bestLocalDeclaration != nil && !(symbol.isDynamic ?? true)
+        && symbol.usr?.hasPrefix("s:") ?? false /* Swift symbols have USRs starting with s: */
+      {
+        // If we have a known non-dynamic symbol within Swift, we don't need to do an index lookup.
+        // For non-Swift symbols, we need to perform an index lookup because the best local declaration will point to
+        // a header file but jump-to-definition should prefer the implementation (there's the declaration request to jump
+        // to the function's declaration).
+        return [symbol.bestLocalDeclaration].compactMap { $0 }
+      }
+      return try await self.definitionLocations(for: symbol, in: req.textDocument.uri, languageService: languageService)
+    }.flatMap { $0 }
+  }
+
   func definition(
     _ req: DefinitionRequest,
     workspace: Workspace,
@@ -1830,13 +1835,22 @@ extension SourceKitServer {
     return .locations(indexBasedResponse)
   }
 
+  /// Generate the generated interface for the given module, write it to disk and return the location to which to jump
+  /// to get to the definition of `symbolUSR`.
+  ///
+  /// `originatorUri` is the URI of the file from which the definition request is performed. It is used to determine the
+  /// compiler arguments to generate the generated inteface.
   func definitionInInterface(
-    _ req: DefinitionRequest,
     moduleName: String,
     symbolUSR: String?,
+    originatorUri: DocumentURI,
     languageService: ToolchainLanguageServer
   ) async throws -> Location {
-    let openInterface = OpenInterfaceRequest(textDocument: req.textDocument, name: moduleName, symbolUSR: symbolUSR)
+    let openInterface = OpenInterfaceRequest(
+      textDocument: TextDocumentIdentifier(originatorUri),
+      name: moduleName,
+      symbolUSR: symbolUSR
+    )
     guard let interfaceDetails = try await languageService.openInterface(openInterface) else {
       throw ResponseError.unknown("Could not generate Swift Interface for \(moduleName)")
     }

Sources/SourceKitLSP/Swift/CursorInfo.swift

@@ -38,13 +38,49 @@ struct CursorInfo {
   init(
     _ symbolInfo: SymbolDetails,
     annotatedDeclaration: String?,
-    documentationXML: String?,
-    refactorActions: [SemanticRefactorCommand]? = nil
+    documentationXML: String?
   ) {
     self.symbolInfo = symbolInfo
     self.annotatedDeclaration = annotatedDeclaration
     self.documentationXML = documentationXML
-    self.refactorActions = refactorActions
+  }
+
+  init?(
+    _ dict: SKDResponseDictionary,
+    sourcekitd: some SourceKitD
+  ) {
+    let keys = sourcekitd.keys
+    guard let kind: sourcekitd_uid_t = dict[keys.kind] else {
+      // Nothing to report.
+      return nil
+    }
+
+    var location: Location? = nil
+    if let filepath: String = dict[keys.filepath],
+      let line: Int = dict[keys.line],
+      let column: Int = dict[keys.column]
+    {
+      let position = Position(
+        line: line - 1,
+        // FIXME: we need to convert the utf8/utf16 column, which may require reading the file!
+        utf16index: column - 1
+      )
+      location = Location(uri: DocumentURI(URL(fileURLWithPath: filepath)), range: Range(position))
+    }
+
+    self.init(
+      SymbolDetails(
+        name: dict[keys.name],
+        containerName: nil,
+        usr: dict[keys.usr],
+        bestLocalDeclaration: location,
+        kind: kind.asSymbolKind(sourcekitd.values),
+        isDynamic: dict[keys.isDynamic] ?? false,
+        receiverUsrs: dict[keys.receivers]?.compactMap { $0[keys.usr] as String? } ?? []
+      ),
+      annotatedDeclaration: dict[keys.annotated_decl],
+      documentationXML: dict[keys.doc_full_as_xml]
+    )
   }
 }
 
@@ -83,7 +119,7 @@ extension SwiftLanguageServer {
     _ uri: DocumentURI,
     _ range: Range<Position>,
     additionalParameters appendAdditionalParameters: ((SKDRequestDictionary) -> Void)? = nil
-  ) async throws -> CursorInfo? {
+  ) async throws -> (cursorInfo: [CursorInfo], refactorActions: [SemanticRefactorCommand]) {
     let snapshot = try documentManager.latestSnapshot(uri)
 
     guard let offsetRange = snapshot.utf8OffsetRange(of: range) else {
@@ -105,48 +141,19 @@ extension SwiftLanguageServer {
 
     let dict = try await self.sourcekitd.send(skreq, fileContents: snapshot.text)
 
-    guard let kind: sourcekitd_uid_t = dict[keys.kind] else {
-      // Nothing to report.
-      return nil
+    var cursorInfoResults: [CursorInfo] = []
+    if let cursorInfo = CursorInfo(dict, sourcekitd: sourcekitd) {
+      cursorInfoResults.append(cursorInfo)
     }
-
-    var location: Location? = nil
-    if let filepath: String = dict[keys.filepath],
-      let line: Int = dict[keys.line],
-      let column: Int = dict[keys.column]
-    {
-      let position = Position(
-        line: line - 1,
-        // FIXME: we need to convert the utf8/utf16 column, which may require reading the file!
-        utf16index: column - 1
-      )
-      location = Location(uri: DocumentURI(URL(fileURLWithPath: filepath)), range: Range(position))
-    }
-
-    let refactorActionsArray: SKDResponseArray? = dict[keys.refactor_actions]
-
-    let receiversArray: SKDResponseArray? = dict[keys.receivers]
-    let receiverUsrs = receiversArray?.compactMap { $0[keys.usr] as String? } ?? []
-
-    return CursorInfo(
-      SymbolDetails(
-        name: dict[keys.name],
-        containerName: nil,
-        usr: dict[keys.usr],
-        bestLocalDeclaration: location,
-        kind: kind.asSymbolKind(self.sourcekitd.values),
-        isDynamic: dict[keys.isDynamic] ?? false,
-        receiverUsrs: receiverUsrs
-      ),
-      annotatedDeclaration: dict[keys.annotated_decl],
-      documentationXML: dict[keys.doc_full_as_xml],
-      refactorActions: [SemanticRefactorCommand](
-        array: refactorActionsArray,
+    cursorInfoResults += dict[keys.secondarySymbols]?.compactMap { CursorInfo($0, sourcekitd: sourcekitd) } ?? []
+    let refactorActions =
+      [SemanticRefactorCommand](
+        array: dict[keys.refactor_actions],
         range: range,
         textDocument: TextDocumentIdentifier(uri),
         keys,
         self.sourcekitd.api
-      )
-    )
+      ) ?? []
+    return (cursorInfoResults, refactorActions)
   }
 }

Sources/SourceKitLSP/Swift/SwiftLanguageServer.swift

@@ -508,35 +508,45 @@ extension SwiftLanguageServer {
   public func hover(_ req: HoverRequest) async throws -> HoverResponse? {
     let uri = req.textDocument.uri
     let position = req.position
-    guard let cursorInfo = try await cursorInfo(uri, position..<position) else {
-      return nil
-    }
+    let cursorInfoResults = try await cursorInfo(uri, position..<position).cursorInfo
 
-    guard let name: String = cursorInfo.symbolInfo.name else {
-      // There is a cursor but we don't know how to deal with it.
-      return nil
-    }
+    let symbolDocumentations = cursorInfoResults.compactMap { (cursorInfo) -> String? in
+      guard let name: String = cursorInfo.symbolInfo.name else {
+        // There is a cursor but we don't know how to deal with it.
+        return nil
+      }
 
-    /// Prepend backslash to `*` and `_`, to prevent them
-    /// from being interpreted as markdown.
-    func escapeNameMarkdown(_ str: String) -> String {
-      return String(str.flatMap({ ($0 == "*" || $0 == "_") ? ["\\", $0] : [$0] }))
-    }
+      /// Prepend backslash to `*` and `_`, to prevent them
+      /// from being interpreted as markdown.
+      func escapeNameMarkdown(_ str: String) -> String {
+        return String(str.flatMap({ ($0 == "*" || $0 == "_") ? ["\\", $0] : [$0] }))
+      }
 
-    var result = escapeNameMarkdown(name)
-    if let doc = cursorInfo.documentationXML {
-      result += """
+      var result = escapeNameMarkdown(name)
+      if let doc = cursorInfo.documentationXML {
+        result += """
 
-        \(orLog("Convert XML to Markdown") { try xmlDocumentationToMarkdown(doc) } ?? doc)
-        """
-    } else if let annotated: String = cursorInfo.annotatedDeclaration {
-      result += """
+          \(orLog("Convert XML to Markdown") { try xmlDocumentationToMarkdown(doc) } ?? doc)
+          """
+      } else if let annotated: String = cursorInfo.annotatedDeclaration {
+        result += """
 
-        \(orLog("Convert XML to Markdown") { try xmlDocumentationToMarkdown(annotated) } ?? annotated)
-        """
+          \(orLog("Convert XML to Markdown") { try xmlDocumentationToMarkdown(annotated) } ?? annotated)
+          """
+      }
+      return result
+    }
+
+    if symbolDocumentations.isEmpty {
+      return nil
     }
 
-    return HoverResponse(contents: .markupContent(MarkupContent(kind: .markdown, value: result)), range: nil)
+    let joinedDocumentation = symbolDocumentations.joined(separator: "\n# Alternative result\n")
+
+    return HoverResponse(
+      contents: .markupContent(MarkupContent(kind: .markdown, value: joinedDocumentation)),
+      range: nil
+    )
   }
 
   public func documentColor(_ req: DocumentColorRequest) async throws -> [ColorInformation] {
@@ -668,13 +678,7 @@ extension SwiftLanguageServer {
       additionalParameters: additionalCursorInfoParameters
     )
 
-    guard let cursorInfoResponse else {
-      throw ResponseError.unknown("CursorInfo failed.")
-    }
-    guard let refactorActions = cursorInfoResponse.refactorActions else {
-      return []
-    }
-    let codeActions: [CodeAction] = refactorActions.compactMap {
+    return cursorInfoResponse.refactorActions.compactMap {
       do {
         let lspCommand = try $0.asCommand()
         return CodeAction(title: $0.title, kind: .refactor, command: lspCommand)
@@ -683,7 +687,6 @@ extension SwiftLanguageServer {
         return nil
       }
     }
-    return codeActions
   }
 
   func retrieveQuickFixCodeActions(_ params: CodeActionRequest) async throws -> [CodeAction] {

Sources/SourceKitLSP/Swift/SymbolInfo.swift

@@ -70,9 +70,6 @@ extension SwiftLanguageServer {
     let uri = req.textDocument.uri
     let snapshot = try documentManager.latestSnapshot(uri)
     let position = await self.adjustPositionToStartOfIdentifier(req.position, in: snapshot)
-    guard let cursorInfo = try await cursorInfo(uri, position..<position) else {
-      return []
-    }
-    return [cursorInfo.symbolInfo]
+    return try await cursorInfo(uri, position..<position).cursorInfo.map { $0.symbolInfo }
   }
 }