removed OpenGeneratedInterfaceRequest

deleted OpenInterfaceRequest.swift and moved GeneratedInterfaceDetails to LanguageService.swift
replaced usages by passing its members as parameters directly, refactored usage of TextDocumentIdentifier to DocumentURI
removed from Messages.builtinRequests
removed from SwiftInterfaceTests
removed from `LSP Extensions.md`

Author: AppAppWorks

Documentation/LSP Extensions.md

@@ -73,39 +73,99 @@ Added case
 identifier = 'identifier'
 ```
 
-## `textDocument/interface`
+## `WorkspaceFolder`
 
-New request that request a textual interface of a module to display in the IDE. Used internally within SourceKit-LSP
+Added field:
+
+```ts
+/**
+ * Build settings that should be used for this workspace.
+ *
+ * For arguments that have a single value (like the build configuration), this takes precedence over the global
+ * options set when launching sourcekit-lsp. For all other options, the values specified in the workspace-specific
+ * build setup are appended to the global options.
+ */
+var buildSetup?: WorkspaceBuildSetup
+```
 
-- params: `OpenInterfaceParams`
-- result: `InterfaceDetails?`
+with
 
 ```ts
-export interface OpenInterfaceRequest: TextDocumentRequest, Hashable {
+/**
+ * The configuration to build a workspace in.
+ */
+export enum BuildConfiguration {
+  case debug = 'debug'
+  case release = 'release'
+}
+
+/**
+ * The type of workspace; default workspace type selection logic can be overridden.
+ */
+export enum WorkspaceType {
+  buildServer = 'buildServer'
+  compilationDatabase = 'compilationDatabase'
+  swiftPM = 'swiftPM'
+}
+
+/// Build settings that should be used for a workspace.
+interface WorkspaceBuildSetup {
   /**
-   * The document whose compiler arguments should be used to generate the interface.
+   * The configuration that the workspace should be built in.
    */
-  textDocument: TextDocumentIdentifier
+  buildConfiguration?: BuildConfiguration
 
   /**
-   * The module to generate an index for.
+   * The default workspace type to use for this workspace.
    */
-  moduleName: string
+  defaultWorkspaceType?: WorkspaceType
 
   /**
-   * The module group name.
+   * The build directory for the workspace.
    */
-  groupName?: string
+  scratchPath?: DocumentURI
+
+  /**
+   * Arguments to be passed to any C compiler invocations.
+   */
+  cFlags?: string[]
+
+  /**
+   * Arguments to be passed to any C++ compiler invocations.
+   */
+  cxxFlags?: string[]
+
+  /**
+   * Arguments to be passed to any linker invocations.
+   */
+  linkerFlags?: string[]
 
   /**
-   * The symbol USR to search for in the generated module interface.
+   * Arguments to be passed to any Swift compiler invocations.
    */
-  symbolUSR?: string
+  swiftFlags?: string[]
 }
+```
+
+## `textDocument/completion`
+
+Added field:
+
+```ts
+/**
+ * Options to control code completion behavior in Swift
+ */
+sourcekitlspOptions?: SKCompletionOptions
+```
+
+with
 
-interface InterfaceDetails {
-  uri: DocumentURI
-  position?: Position
+```ts
+interface SKCompletionOptions {
+  /**
+   * The maximum number of completion results to return, or `null` for unlimited.
+   */
+  maxResults?: int
 }
 ```
 

Sources/LanguageServerProtocol/Messages.swift

@@ -58,7 +58,6 @@ public let builtinRequests: [_RequestType.Type] = [
   InlineValueRequest.self,
   LinkedEditingRangeRequest.self,
   MonikersRequest.self,
-  OpenGeneratedInterfaceRequest.self,
   PollIndexRequest.self,
   PrepareRenameRequest.self,
   ReferencesRequest.self,

Sources/LanguageServerProtocol/Requests/OpenInterfaceRequest.swift

@@ -623,7 +623,12 @@ extension ClangLanguageService {
     return try await forwardRequestToClangd(req)
   }
 
-  func openGeneratedInterface(_ request: OpenGeneratedInterfaceRequest) async throws -> GeneratedInterfaceDetails? {
+  func openGeneratedInterface(
+    document: DocumentURI,
+    moduleName: String,
+    groupName: String?,
+    symbolUSR symbol: String?
+  ) async throws -> GeneratedInterfaceDetails? {
     throw ResponseError.unknown("unsupported method")
   }
 

Sources/SourceKitLSP/Clang/ClangLanguageService.swift

@@ -76,6 +76,17 @@ public struct RenameLocation: Sendable {
   let usage: Usage
 }
 
+/// The textual output of a module interface.
+public struct GeneratedInterfaceDetails: ResponseType, Hashable {
+  public var uri: DocumentURI
+  public var position: Position?
+
+  public init(uri: DocumentURI, position: Position?) {
+    self.uri = uri
+    self.position = position
+  }
+}
+
 /// Provides language specific functionality to sourcekit-lsp from a specific toolchain.
 ///
 /// For example, we may have a language service that provides semantic functionality for c-family using a clangd server,
@@ -147,7 +158,19 @@ public protocol LanguageService: AnyObject, Sendable {
   func completion(_ req: CompletionRequest) async throws -> CompletionList
   func hover(_ req: HoverRequest) async throws -> HoverResponse?
   func symbolInfo(_ request: SymbolInfoRequest) async throws -> [SymbolDetails]
-  func openGeneratedInterface(_ request: OpenGeneratedInterfaceRequest) async throws -> GeneratedInterfaceDetails?
+
+  /// Request a generated interface of a module to display in the IDE.
+  ///
+  /// - Parameter document: The document whose compiler arguments should be used to generate the interface.
+  /// - Parameter moduleName: The module to generate an index for.
+  /// - Parameter groupName: The module group name.
+  /// - Parameter symbol: The symbol USR to search for in the generated module interface.
+  func openGeneratedInterface(
+    document: DocumentURI,
+    moduleName: String,
+    groupName: String?,
+    symbolUSR symbol: String?
+  ) async throws -> GeneratedInterfaceDetails?
 
   /// - Note: Only called as a fallback if the definition could not be found in the index.
   func definition(_ request: DefinitionRequest) async throws -> LocationsOrLocationLinksResponse?

Sources/SourceKitLSP/LanguageService.swift

@@ -743,8 +743,6 @@ extension SourceKitLSPServer: MessageHandler {
       initialized = true
     case let request as RequestAndReply<InlayHintRequest>:
       await self.handleRequest(for: request, requestHandler: self.inlayHint)
-    case let request as RequestAndReply<OpenGeneratedInterfaceRequest>:
-      await self.handleRequest(for: request, requestHandler: self.openGeneratedInterface)
     case let request as RequestAndReply<PollIndexRequest>:
       await request.reply { try await pollIndex(request.params) }
     case let request as RequestAndReply<PrepareRenameRequest>:
@@ -1434,11 +1432,19 @@ extension SourceKitLSPServer {
   }
 
   func openGeneratedInterface(
-    _ req: OpenGeneratedInterfaceRequest,
+    document: DocumentURI,
+    moduleName: String,
+    groupName: String?,
+    symbolUSR symbol: String?,
     workspace: Workspace,
     languageService: LanguageService
   ) async throws -> GeneratedInterfaceDetails? {
-    return try await languageService.openGeneratedInterface(req)
+    return try await languageService.openGeneratedInterface(
+      document: document,
+      moduleName: moduleName,
+      groupName: groupName,
+      symbolUSR: symbol
+    )
   }
 
   /// Find all symbols in the workspace that include a string in their name.
@@ -1842,13 +1848,14 @@ extension SourceKitLSPServer {
     originatorUri: DocumentURI,
     languageService: LanguageService
   ) async throws -> Location {
-    let openInterface = OpenGeneratedInterfaceRequest(
-      textDocument: TextDocumentIdentifier(originatorUri),
-      name: moduleName,
-      groupName: groupName,
-      symbolUSR: symbolUSR
-    )
-    guard let interfaceDetails = try await languageService.openGeneratedInterface(openInterface) else {
+    guard
+      let interfaceDetails = try await languageService.openGeneratedInterface(
+        document: originatorUri,
+        moduleName: moduleName,
+        groupName: groupName,
+        symbolUSR: symbolUSR
+      )
+    else {
       throw ResponseError.unknown("Could not generate Swift Interface for \(moduleName)")
     }
     let position = interfaceDetails.position ?? Position(line: 0, utf16index: 0)

Sources/SourceKitLSP/SourceKitLSPServer.swift

@@ -22,22 +22,34 @@ struct GeneratedInterfaceInfo {
 
 extension SwiftLanguageService {
   public func openGeneratedInterface(
-    _ request: OpenGeneratedInterfaceRequest
+    document: DocumentURI,
+    moduleName: String,
+    groupName: String?,
+    symbolUSR symbol: String?
   ) async throws -> GeneratedInterfaceDetails? {
-    let name = request.name
-    let symbol = request.symbolUSR
+    // Name of interface module name with group names appended
+    let name =
+      if let groupName {
+        "\(moduleName).\(groupName.replacing("/", with: "."))"
+      } else {
+        moduleName
+      }
     let interfaceFilePath = self.generatedInterfacesPath.appendingPathComponent("\(name).swiftinterface")
     let interfaceDocURI = DocumentURI(interfaceFilePath)
     // has interface already been generated
     if let snapshot = try? self.documentManager.latestSnapshot(interfaceDocURI) {
       return await self.generatedInterfaceDetails(
-        request: request,
         uri: interfaceDocURI,
         snapshot: snapshot,
         symbol: symbol
       )
     } else {
-      let interfaceInfo = try await self.generatedInterfaceInfo(request: request, interfaceURI: interfaceDocURI)
+      let interfaceInfo = try await self.generatedInterfaceInfo(
+        document: document,
+        moduleName: moduleName,
+        groupName: groupName,
+        interfaceURI: interfaceDocURI
+      )
       try interfaceInfo.contents.write(to: interfaceFilePath, atomically: true, encoding: String.Encoding.utf8)
       let snapshot = DocumentSnapshot(
         uri: interfaceDocURI,
@@ -46,7 +58,6 @@ extension SwiftLanguageService {
         lineTable: LineTable(interfaceInfo.contents)
       )
       let result = await self.generatedInterfaceDetails(
-        request: request,
         uri: interfaceDocURI,
         snapshot: snapshot,
         symbol: symbol
@@ -67,25 +78,26 @@ extension SwiftLanguageService {
   /// - Important: This opens a document with name `interfaceURI.pseudoPath` in sourcekitd. The caller is responsible
   ///   for ensuring that the document will eventually get closed in sourcekitd again.
   private func generatedInterfaceInfo(
-    request: OpenGeneratedInterfaceRequest,
+    document: DocumentURI,
+    moduleName: String,
+    groupName: String?,
     interfaceURI: DocumentURI
   ) async throws -> GeneratedInterfaceInfo {
     let keys = self.keys
     let skreq = sourcekitd.dictionary([
       keys.request: requests.editorOpenInterface,
-      keys.moduleName: request.moduleName,
-      keys.groupName: request.groupName,
+      keys.moduleName: moduleName,
+      keys.groupName: groupName,
       keys.name: interfaceURI.pseudoPath,
       keys.synthesizedExtension: 1,
-      keys.compilerArgs: await self.buildSettings(for: request.textDocument.uri)?.compilerArgs as [SKDRequestValue]?,
+      keys.compilerArgs: await self.buildSettings(for: document)?.compilerArgs as [SKDRequestValue]?,
     ])
 
     let dict = try await self.sourcekitd.send(skreq, fileContents: nil)
     return GeneratedInterfaceInfo(contents: dict[keys.sourceText] ?? "")
   }
 
   private func generatedInterfaceDetails(
-    request: OpenGeneratedInterfaceRequest,
     uri: DocumentURI,
     snapshot: DocumentSnapshot,
     symbol: String?