removed OpenGeneratedInterfaceRequest

replaced its usage by passing its members as parameters directly
removed from Messages.builtinRequests
removed from SwiftInterfaceTests

Author: AppAppWorks

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

@@ -10,40 +10,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-/// Request a generated interface of a module to display in the IDE.
-/// **(LSP Extension)**
-public struct OpenGeneratedInterfaceRequest: TextDocumentRequest, Hashable {
-  public static let method: String = "textDocument/openInterface"
-  public typealias Response = GeneratedInterfaceDetails?
-
-  /// The document whose compiler arguments should be used to generate the interface.
-  public var textDocument: TextDocumentIdentifier
-
-  /// The module to generate an index for.
-  public var moduleName: String
-
-  /// The module group name.
-  public var groupName: String?
-
-  /// The symbol USR to search for in the generated module interface.
-  public var symbolUSR: String?
-
-  public init(textDocument: TextDocumentIdentifier, name: String, groupName: String?, symbolUSR: String?) {
-    self.textDocument = textDocument
-    self.symbolUSR = symbolUSR
-    self.moduleName = name
-    self.groupName = groupName
-  }
-
-  /// Name of interface module name with group names appended
-  public var name: String {
-    if let groupName {
-      return "\(self.moduleName).\(groupName.replacing("/", with: "."))"
-    }
-    return self.moduleName
-  }
-}
-
 /// The textual output of a module interface.
 public struct GeneratedInterfaceDetails: ResponseType, Hashable {
 

Sources/SourceKitLSP/Clang/ClangLanguageService.swift

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

Sources/SourceKitLSP/LanguageService.swift

@@ -146,7 +146,12 @@ 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?
+  func openGeneratedInterface(
+    textDocument: TextDocumentIdentifier,
+    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/SourceKitLSPServer.swift

@@ -738,8 +738,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>:
@@ -1477,11 +1475,19 @@ extension SourceKitLSPServer {
   }
 
   func openGeneratedInterface(
-    _ req: OpenGeneratedInterfaceRequest,
+    textDocument: TextDocumentIdentifier,
+    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(
+      textDocument: textDocument,
+      moduleName: moduleName,
+      groupName: groupName,
+      symbolUSR: symbol
+    )
   }
 
   /// Find all symbols in the workspace that include a string in their name.
@@ -1885,13 +1891,12 @@ extension SourceKitLSPServer {
     originatorUri: DocumentURI,
     languageService: LanguageService
   ) async throws -> Location {
-    let openInterface = OpenGeneratedInterfaceRequest(
+    guard let interfaceDetails = try await languageService.openGeneratedInterface(
       textDocument: TextDocumentIdentifier(originatorUri),
-      name: moduleName,
+      moduleName: moduleName,
       groupName: groupName,
       symbolUSR: symbolUSR
-    )
-    guard let interfaceDetails = try await languageService.openGeneratedInterface(openInterface) else {
+    ) else {
       throw ResponseError.unknown("Could not generate Swift Interface for \(moduleName)")
     }
     let position = interfaceDetails.position ?? Position(line: 0, utf16index: 0)

Sources/SourceKitLSP/Swift/OpenInterface.swift

@@ -22,22 +22,33 @@ struct GeneratedInterfaceInfo {
 
 extension SwiftLanguageService {
   public func openGeneratedInterface(
-    _ request: OpenGeneratedInterfaceRequest
+    textDocument: TextDocumentIdentifier,
+    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(
+            textDocument: textDocument,
+            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 +57,6 @@ extension SwiftLanguageService {
         lineTable: LineTable(interfaceInfo.contents)
       )
       let result = await self.generatedInterfaceDetails(
-        request: request,
         uri: interfaceDocURI,
         snapshot: snapshot,
         symbol: symbol
@@ -67,25 +77,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,
+    textDocument: TextDocumentIdentifier,
+    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: textDocument.uri)?.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?

Tests/SourceKitLSPTests/SwiftInterfaceTests.swift

@@ -49,55 +49,6 @@ final class SwiftInterfaceTests: XCTestCase {
     )
   }
 
-  func testOpenInterface() async throws {
-    let project = try await SwiftPMTestProject(
-      files: [
-        "MyLibrary/MyLibrary.swift": """
-        public struct Lib {
-          public func foo() {}
-          public init() {}
-        }
-        """,
-        "Exec/main.swift": "import MyLibrary",
-      ],
-      manifest: """
-        let package = Package(
-          name: "MyLibrary",
-          targets: [
-            .target(name: "MyLibrary"),
-            .executableTarget(name: "Exec", dependencies: ["MyLibrary"])
-          ]
-        )
-        """,
-      enableBackgroundIndexing: true
-    )
-
-    let (mainUri, _) = try project.openDocument("main.swift")
-    let openInterface = OpenGeneratedInterfaceRequest(
-      textDocument: TextDocumentIdentifier(mainUri),
-      name: "MyLibrary",
-      groupName: nil,
-      symbolUSR: nil
-    )
-    let interfaceDetails = try unwrap(await project.testClient.send(openInterface))
-    XCTAssert(interfaceDetails.uri.pseudoPath.hasSuffix("/MyLibrary.swiftinterface"))
-    let fileContents = try XCTUnwrap(
-      interfaceDetails.uri.fileURL.flatMap({ try String(contentsOf: $0, encoding: .utf8) })
-    )
-    XCTAssertTrue(
-      fileContents.contains(
-        """
-        public struct Lib {
-
-            public func foo()
-
-            public init()
-        }
-        """
-      )
-    )
-  }
-
   func testDefinitionInSystemModuleInterface() async throws {
     let project = try await IndexedSingleSwiftFileTestProject(
       """