A couple of improvements for generated interfaces

- Rename methods to highlight that we’re talking about generated interfaces here, not `.swiftinterface` files
- Don’t open the generated interface in `documentManager`. Opening documents in `documentManager` should only be done by the `textDocument/didOpen` notification from the LSP client. Otherwise we might indefinitely keep the document in the document manager
- After getting the generated interface from sourcekitd, close the document in sourcekitd again. We don’t provide semantic functionality in the generated interface yet, so we can’t interact with the generated interface path. Before, we left it open in sourcekitd indefinitely.
- A couple of code simplifications.

Fixes swiftlang#878
rdar://116705653

Author: ahoppen

Sources/LanguageServerProtocol/Messages.swift

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

Sources/LanguageServerProtocol/Requests/OpenInterfaceRequest.swift

@@ -10,11 +10,11 @@
 //
 //===----------------------------------------------------------------------===//
 
-/// Request a textual interface of a module to display in the IDE.
+/// Request a generated interface of a module to display in the IDE.
 /// **(LSP Extension)**
-public struct OpenInterfaceRequest: TextDocumentRequest, Hashable {
+public struct OpenGeneratedInterfaceRequest: TextDocumentRequest, Hashable {
   public static let method: String = "textDocument/openInterface"
-  public typealias Response = InterfaceDetails?
+  public typealias Response = GeneratedInterfaceDetails?
 
   /// The document whose compiler arguments should be used to generate the interface.
   public var textDocument: TextDocumentIdentifier
@@ -45,7 +45,7 @@ public struct OpenInterfaceRequest: TextDocumentRequest, Hashable {
 }
 
 /// The textual output of a module interface.
-public struct InterfaceDetails: ResponseType, Hashable {
+public struct GeneratedInterfaceDetails: ResponseType, Hashable {
 
   public var uri: DocumentURI
   public var position: Position?

Sources/SourceKitLSP/Clang/ClangLanguageService.swift

@@ -578,7 +578,7 @@ extension ClangLanguageService {
     return try await forwardRequestToClangd(req)
   }
 
-  func openInterface(_ request: OpenInterfaceRequest) async throws -> InterfaceDetails? {
+  func openGeneratedInterface(_ request: OpenGeneratedInterfaceRequest) async throws -> GeneratedInterfaceDetails? {
     throw ResponseError.unknown("unsupported method")
   }
 

Sources/SourceKitLSP/LanguageService.swift

@@ -146,7 +146,7 @@ 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 openInterface(_ request: OpenInterfaceRequest) async throws -> InterfaceDetails?
+  func openGeneratedInterface(_ request: OpenGeneratedInterfaceRequest) 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

@@ -711,8 +711,8 @@ extension SourceKitLSPServer: MessageHandler {
       await self.handleRequest(for: request, requestHandler: self.completion)
     case let request as RequestAndReply<HoverRequest>:
       await self.handleRequest(for: request, requestHandler: self.hover)
-    case let request as RequestAndReply<OpenInterfaceRequest>:
-      await self.handleRequest(for: request, requestHandler: self.openInterface)
+    case let request as RequestAndReply<OpenGeneratedInterfaceRequest>:
+      await self.handleRequest(for: request, requestHandler: self.openGeneratedInterface)
     case let request as RequestAndReply<DeclarationRequest>:
       await self.handleRequest(for: request, requestHandler: self.declaration)
     case let request as RequestAndReply<DefinitionRequest>:
@@ -1466,12 +1466,12 @@ extension SourceKitLSPServer {
     return try await languageService.hover(req)
   }
 
-  func openInterface(
-    _ req: OpenInterfaceRequest,
+  func openGeneratedInterface(
+    _ req: OpenGeneratedInterfaceRequest,
     workspace: Workspace,
     languageService: LanguageService
-  ) async throws -> InterfaceDetails? {
-    return try await languageService.openInterface(req)
+  ) async throws -> GeneratedInterfaceDetails? {
+    return try await languageService.openGeneratedInterface(req)
   }
 
   /// Find all symbols in the workspace that include a string in their name.
@@ -1808,13 +1808,13 @@ extension SourceKitLSPServer {
     originatorUri: DocumentURI,
     languageService: LanguageService
   ) async throws -> Location {
-    let openInterface = OpenInterfaceRequest(
+    let openInterface = OpenGeneratedInterfaceRequest(
       textDocument: TextDocumentIdentifier(originatorUri),
       name: moduleName,
       groupName: groupName,
       symbolUSR: symbolUSR
     )
-    guard let interfaceDetails = try await languageService.openInterface(openInterface) else {
+    guard let interfaceDetails = try await languageService.openGeneratedInterface(openInterface) 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

@@ -16,82 +16,83 @@ import LanguageServerProtocol
 import SKSupport
 import SourceKitD
 
-struct InterfaceInfo {
+struct GeneratedInterfaceInfo {
   var contents: String
 }
 
 extension SwiftLanguageService {
-  public func openInterface(_ request: OpenInterfaceRequest) async throws -> InterfaceDetails? {
-    let uri = request.textDocument.uri
-    let moduleName = request.moduleName
+  public func openGeneratedInterface(
+    _ request: OpenGeneratedInterfaceRequest
+  ) async throws -> GeneratedInterfaceDetails? {
     let name = request.name
     let symbol = request.symbolUSR
     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.interfaceDetails(request: request, uri: interfaceDocURI, snapshot: snapshot, symbol: symbol)
+      return await self.generatedInterfaceDetails(
+        request: request,
+        uri: interfaceDocURI,
+        snapshot: snapshot,
+        symbol: symbol
+      )
     } else {
-      // generate interface
-      let interfaceInfo = try await self.openInterface(
+      let interfaceInfo = try await self.generatedInterfaceInfo(request: request, interfaceURI: interfaceDocURI)
+      try interfaceInfo.contents.write(to: interfaceFilePath, atomically: true, encoding: String.Encoding.utf8)
+      let snapshot = DocumentSnapshot(
+        uri: interfaceDocURI,
+        language: .swift,
+        version: 0,
+        lineTable: LineTable(interfaceInfo.contents)
+      )
+      let result = await self.generatedInterfaceDetails(
         request: request,
-        uri: uri,
-        name: moduleName,
-        interfaceURI: interfaceDocURI
+        uri: interfaceDocURI,
+        snapshot: snapshot,
+        symbol: symbol
       )
-      do {
-        // write to file
-        try interfaceInfo.contents.write(to: interfaceFilePath, atomically: true, encoding: String.Encoding.utf8)
-        // store snapshot
-        let snapshot = try self.documentManager.open(
-          interfaceDocURI,
-          language: .swift,
-          version: 0,
-          text: interfaceInfo.contents
-        )
-        return await self.interfaceDetails(request: request, uri: interfaceDocURI, snapshot: snapshot, symbol: symbol)
-      } catch {
-        throw ResponseError.unknown(error.localizedDescription)
+      _ = await orLog("Closing generated interface") {
+        try await self.sourcekitd.send(closeDocumentSourcekitdRequest(uri: interfaceDocURI), fileContents: nil)
       }
+      return result
     }
   }
 
   /// Open the Swift interface for a module.
   ///
   /// - Parameters:
-  ///   - request: The OpenInterfaceRequest.
-  ///   - uri: The document whose compiler arguments should be used to generate the interface.
-  ///   - name: The name of the module whose interface should be generated.
+  ///   - request: The OpenGeneratedInterfaceRequest.
   ///   - interfaceURI: The file where the generated interface should be written.
-  private func openInterface(
-    request: OpenInterfaceRequest,
-    uri: DocumentURI,
-    name: String,
+  ///
+  /// - 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,
     interfaceURI: DocumentURI
-  ) async throws -> InterfaceInfo {
+  ) async throws -> GeneratedInterfaceInfo {
     let keys = self.keys
     let skreq = sourcekitd.dictionary([
       keys.request: requests.editorOpenInterface,
-      keys.moduleName: name,
+      keys.moduleName: request.moduleName,
       keys.groupName: request.groupName,
       keys.name: interfaceURI.pseudoPath,
       keys.synthesizedExtension: 1,
-      keys.compilerArgs: await self.buildSettings(for: uri)?.compilerArgs as [SKDRequestValue]?,
+      keys.compilerArgs: await self.buildSettings(for: request.textDocument.uri)?.compilerArgs as [SKDRequestValue]?,
     ])
 
     let dict = try await self.sourcekitd.send(skreq, fileContents: nil)
-    return InterfaceInfo(contents: dict[keys.sourceText] ?? "")
+    return GeneratedInterfaceInfo(contents: dict[keys.sourceText] ?? "")
   }
 
-  private func interfaceDetails(
-    request: OpenInterfaceRequest,
+  private func generatedInterfaceDetails(
+    request: OpenGeneratedInterfaceRequest,
     uri: DocumentURI,
     snapshot: DocumentSnapshot,
     symbol: String?
-  ) async -> InterfaceDetails {
+  ) async -> GeneratedInterfaceDetails {
     do {
       guard let symbol = symbol else {
-        return InterfaceDetails(uri: uri, position: nil)
+        return GeneratedInterfaceDetails(uri: uri, position: nil)
       }
       let keys = self.keys
       let skreq = sourcekitd.dictionary([
@@ -102,12 +103,12 @@ extension SwiftLanguageService {
 
       let dict = try await self.sourcekitd.send(skreq, fileContents: snapshot.text)
       if let offset: Int = dict[keys.offset] {
-        return InterfaceDetails(uri: uri, position: snapshot.positionOf(utf8Offset: offset))
+        return GeneratedInterfaceDetails(uri: uri, position: snapshot.positionOf(utf8Offset: offset))
       } else {
-        return InterfaceDetails(uri: uri, position: nil)
+        return GeneratedInterfaceDetails(uri: uri, position: nil)
       }
     } catch {
-      return InterfaceDetails(uri: uri, position: nil)
+      return GeneratedInterfaceDetails(uri: uri, position: nil)
     }
   }
 }

Sources/SourceKitLSP/Swift/SwiftLanguageService.swift

@@ -391,7 +391,7 @@ extension SwiftLanguageService {
     ])
   }
 
-  private func closeDocumentSourcekitdRequest(uri: DocumentURI) -> SKDRequestDictionary {
+  func closeDocumentSourcekitdRequest(uri: DocumentURI) -> SKDRequestDictionary {
     return sourcekitd.dictionary([
       keys.request: requests.editorClose,
       keys.name: uri.pseudoPath,

Tests/SourceKitLSPTests/SwiftInterfaceTests.swift

@@ -73,7 +73,7 @@ final class SwiftInterfaceTests: XCTestCase {
     )
 
     let (mainUri, _) = try project.openDocument("main.swift")
-    let openInterface = OpenInterfaceRequest(
+    let openInterface = OpenGeneratedInterfaceRequest(
       textDocument: TextDocumentIdentifier(mainUri),
       name: "MyLibrary",
       groupName: nil,