Register openInterface with registerToolchainTextDocumentRequest

and  change `InterfaceDetails` to be optional.

Author: bwhiteley

Sources/LanguageServerProtocol/Requests/OpenInterfaceRequest.swift

@@ -14,7 +14,7 @@
 /// **(LSP Extension)**
 public struct OpenInterfaceRequest: TextDocumentRequest, Hashable {
   public static let method: String = "textDocument/openInterface"
-  public typealias Response = InterfaceDetails
+  public typealias Response = InterfaceDetails?
 
   /// The document whose compiler arguments should be used to generate the interface.
   public var textDocument: TextDocumentIdentifier

Sources/SourceKitLSP/SourceKitServer.swift

@@ -184,6 +184,7 @@ public final class SourceKitServer: LanguageServer {
     registerToolchainTextDocumentRequest(SourceKitServer.completion,
                                          CompletionList(isIncomplete: false, items: []))
     registerToolchainTextDocumentRequest(SourceKitServer.hover, nil)
+    registerToolchainTextDocumentRequest(SourceKitServer.openInterface, nil)
     registerToolchainTextDocumentRequest(SourceKitServer.declaration, .locations([]))
     registerToolchainTextDocumentRequest(SourceKitServer.definition, .locations([]))
     registerToolchainTextDocumentRequest(SourceKitServer.references, [])
@@ -985,6 +986,14 @@ extension SourceKitServer {
   ) {
     languageService.hover(req)
   }
+  
+  func openInterface(
+    _ req: Request<OpenInterfaceRequest>,
+    workspace: Workspace,
+    languageService: ToolchainLanguageServer
+  ) {
+    languageService.openInterface(req)
+  }
 
   /// Find all symbols in the workspace that include a string in their name.
   /// - returns: An array of SymbolOccurrences that match the string.
@@ -1279,9 +1288,11 @@ extension SourceKitServer {
         let request = Request(openInterface, id: req.id, clientID: ObjectIdentifier(self),
                               cancellation: req.cancellationToken, reply: { (result: Result<OpenInterfaceRequest.Response, ResponseError>) in
           switch result {
-          case .success(let interfaceDetails):
+          case .success(let interfaceDetails?):
             let loc = Location(uri: interfaceDetails.uri, range: Range(Position(line: 0, utf16index: 0)))
             req.reply(.locations([loc]))
+          case .success(nil):
+            req.reply(.failure(.unknown("Could not generate Swift Interface for \(name)")))
           case .failure(let error):
             req.reply(.failure(error))
           }

Tests/SourceKitLSPTests/SwiftInterfaceTests.swift

@@ -87,41 +87,20 @@ final class SwiftInterfaceTests: XCTestCase {
     try ws.buildAndIndex()
     let importedModule = ws.testLoc("lib:import")
     try ws.openDocument(importedModule.url, language: .swift)
-    let workspace = try XCTUnwrap(ws.testServer.server?.queue.sync {
-      try XCTUnwrap(ws.testServer.server?.workspaceForDocument(uri: importedModule.docUri))
-    })
-    let swiftLangServer = try XCTUnwrap(ws.testServer.server?._languageService(for: importedModule.docUri, .swift, in: workspace))
-    let expectation = expectation(description: "open interface request")
     let openInterface = OpenInterfaceRequest(textDocument: importedModule.docIdentifier, name: "lib")
-    let request = Request(openInterface, id: .number(1), clientID: ObjectIdentifier(swiftLangServer),
-                          cancellation: CancellationToken(), reply: { (result: Result<OpenInterfaceRequest.Response, ResponseError>) in
-      do {
-        let interfaceDetails = try result.get()
-        XCTAssertTrue(interfaceDetails.uri.pseudoPath.hasSuffix("/lib.swiftinterface"))
-        let fileContents = try XCTUnwrap(interfaceDetails.uri.fileURL.flatMap({ try String(contentsOf: $0, encoding: .utf8) }))
-        XCTAssertTrue(fileContents.contains("""
+    let interfaceDetails = try XCTUnwrap(ws.sk.sendSync(openInterface))
+    XCTAssertTrue(interfaceDetails.uri.pseudoPath.hasSuffix("/lib.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()
           }
           """))
-      } catch {
-        XCTFail(error.localizedDescription)
-      }
-      expectation.fulfill()
-    })
-    
-    // Send an arbitrary request through the front door first or SourceKitServer won't be properly initialized.
-    _ = try ws.sk.sendSync(HoverRequest(
-      textDocument: importedModule.docIdentifier,
-      position: importedModule.position))
-    swiftLangServer.openInterface(request)
-    
-    waitForExpectations(timeout: 15)
   }
-
+  
   func testSwiftInterfaceAcrossModules() throws {
     guard let ws = try staticSourceKitSwiftPMWorkspace(name: "SwiftPMPackage") else { return }
     try ws.buildAndIndex()