Dynamically register completion options for supporting clients

Sources/LanguageServerProtocol/Requests/RegisterCapabilityRequest.swift

@@ -27,15 +27,15 @@ public struct RegisterCapabilityRequest: RequestType, Hashable {
   public typealias Response = VoidResponse
 
   /// Capability registrations.
-  public var registrations: [Registration]
+  public var registrations: [CapabilityRegistration]
 
-  public init(registrations: [Registration]) {
+  public init(registrations: [CapabilityRegistration]) {
     self.registrations = registrations
   }
 }
 
 /// General parameters to register a capability.
-public struct Registration: Codable, Hashable {
+public struct CapabilityRegistration: Codable, Hashable {
   /// The id used to register the capability which may be used to unregister support.
   public var id: String
 
@@ -51,8 +51,8 @@ public struct Registration: Codable, Hashable {
     self.registerOptions = registerOptions
   }
 
-  /// Create a new `Registration` with a randomly generated id. Save the generated
-  /// id if you wish to unregister the given registration.
+  /// Create a new `CapabilityRegistration` with a randomly generated id. Save
+  /// the generated id if you wish to unregister the given registration.
   public init(method: String, registerOptions: LSPAny?) {
     self.id = UUID().uuidString
     self.method = method

Sources/LanguageServerProtocol/SupportTypes/RegistrationOptions.swift

@@ -12,12 +12,23 @@
 
 import Foundation
 
-/// An event describing a file change.
-public protocol RegistrationOptions: Codable, LSPAnyCodable, Hashable {
+/// Protocol for capability registration options, which must be encodable to
+/// `LSPAny` so they can be included in a `Registration`.
+public protocol RegistrationOptions: Hashable {
+  func encodeIntoLSPAny(dict: inout [String: LSPAny])
+}
+
+fileprivate func encode(strings: [String]) -> LSPAny {
+  var values = [LSPAny]()
+  values.reserveCapacity(strings.count)
+  for str in strings {
+    values.append(.string(str))
+  }
+  return .array(values)
 }
 
 /// General text document registration options.
-public struct TextDocumentRegistrationOptions: RegistrationOptions {
+public struct TextDocumentRegistrationOptions: RegistrationOptions, Hashable {
   /// A document selector to identify the scope of the registration. If not set,
   /// the document selector provided on the client side will be used.
   public var documentSelector: DocumentSelector?
@@ -26,21 +37,40 @@ public struct TextDocumentRegistrationOptions: RegistrationOptions {
     self.documentSelector = documentSelector
   }
 
-  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
-    guard let selectorValue = dictionary[CodingKeys.documentSelector.stringValue] else {
-      self.documentSelector = nil
-      return
-    }
-    guard case .dictionary(let selectorDictionary) = selectorValue else { return nil }
-    guard let documentSelector = DocumentSelector(fromLSPDictionary: selectorDictionary) else {
-      return nil
-    }
-    self.documentSelector = documentSelector
+  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
+    guard let documentSelector = documentSelector else { return }
+    dict["documentSelector"] = documentSelector.encodeToLSPAny()
+  }
+}
+
+/// Protocol for a type which structurally represents`TextDocumentRegistrationOptions`.
+public protocol TextDocumentRegistrationOptionsProtocol {
+  var textDocumentRegistrationOptions: TextDocumentRegistrationOptions {get}
+}
+
+/// Code completiion registration options.
+public struct CompletionRegistrationOptions: RegistrationOptions, TextDocumentRegistrationOptionsProtocol, Hashable {
+  public var textDocumentRegistrationOptions: TextDocumentRegistrationOptions
+  public var completionOptions: CompletionOptions
+
+  public init(documentSelector: DocumentSelector? = nil, completionOptions: CompletionOptions) {
+    self.textDocumentRegistrationOptions =
+        TextDocumentRegistrationOptions(documentSelector: documentSelector)
+    self.completionOptions = completionOptions
   }
 
-  public func encodeToLSPAny() -> LSPAny {
-    guard let documentSelector = documentSelector else { return .dictionary([:]) }
-    return .dictionary([CodingKeys.documentSelector.stringValue: documentSelector.encodeToLSPAny()])
+  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
+    textDocumentRegistrationOptions.encodeIntoLSPAny(dict: &dict)
+
+    if let resolveProvider = completionOptions.resolveProvider {
+      dict["resolveProvider"] = .bool(resolveProvider)
+    }
+    if let triggerCharacters = completionOptions.triggerCharacters {
+      dict["triggerCharacters"] = encode(strings: triggerCharacters)
+    }
+    if let allCommitCharacters = completionOptions.allCommitCharacters {
+      dict["allCommitCharacters"] = encode(strings: allCommitCharacters)
+    }
   }
 }
 
@@ -53,14 +83,8 @@ public struct DidChangeWatchedFilesRegistrationOptions: RegistrationOptions {
     self.watchers = watchers
   }
 
-  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
-    guard let watchersLSPAny = dictionary[CodingKeys.watchers.stringValue] else { return nil }
-    guard let watchers = [FileSystemWatcher].init(fromLSPArray: watchersLSPAny) else { return nil }
-    self.watchers = watchers
-  }
-
-  public func encodeToLSPAny() -> LSPAny {
-    return .dictionary([CodingKeys.watchers.stringValue: watchers.encodeToLSPAny()])
+  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
+    dict["watchers"] = watchers.encodeToLSPAny()
   }
 }
 
@@ -73,25 +97,7 @@ public struct ExecuteCommandRegistrationOptions: RegistrationOptions {
     self.commands = commands
   }
 
-  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
-    guard case .array(let commandsArray) = dictionary[CodingKeys.commands.stringValue] else {
-      return nil
-    }
-    var values = [String]()
-    values.reserveCapacity(commandsArray.count)
-    for lspAny in commandsArray {
-      guard case .string(let value) = lspAny else { return nil }
-      values.append(value)
-    }
-    self.commands = values
-  }
-
-  public func encodeToLSPAny() -> LSPAny {
-    var values = [LSPAny]()
-    values.reserveCapacity(commands.count)
-    for command in commands {
-      values.append(.string(command))
-    }
-    return .dictionary([CodingKeys.commands.stringValue: .array(values)])
+  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
+    dict["commands"] = encode(strings: commands)
   }
 }

Sources/LanguageServerProtocol/SupportTypes/ServerCapabilities.swift

@@ -243,16 +243,23 @@ public enum TextDocumentSyncKind: Int, Codable, Hashable {
 }
 
 public struct CompletionOptions: Codable, Hashable {
-
   /// Whether to use `textDocument/resolveCompletion`
   public var resolveProvider: Bool?
 
   /// The characters that should trigger automatic completion.
-  public var triggerCharacters: [String]
+  public var triggerCharacters: [String]?
 
-  public init(resolveProvider: Bool? = false, triggerCharacters: [String]) {
+  /// The list of all possible characters that commit a completion.
+  public var allCommitCharacters: [String]?
+
+  public init(
+    resolveProvider: Bool? = false,
+    triggerCharacters: [String]? = nil,
+    allCommitCharacters: [String]? = nil
+  ) {
     self.resolveProvider = resolveProvider
     self.triggerCharacters = triggerCharacters
+    self.allCommitCharacters = allCommitCharacters
   }
 }
 

Sources/SKTestSupport/SKSwiftPMTestWorkspace.swift

@@ -90,7 +90,7 @@ public final class SKSwiftPMTestWorkspace {
     let server = testServer.server!
     server.workspace = Workspace(
       rootUri: DocumentURI(sources.rootDirectory),
-      clientCapabilities: ClientCapabilities(),
+      capabilityRegistry: CapabilityRegistry(clientCapabilities: ClientCapabilities()),
       toolchainRegistry: ToolchainRegistry.shared,
       buildSetup: buildSetup,
       underlyingBuildSystem: swiftpm,

Sources/SKTestSupport/SKTibsTestWorkspace.swift

@@ -69,7 +69,7 @@ public final class SKTibsTestWorkspace {
 
     testServer.server!.workspace = Workspace(
       rootUri: DocumentURI(sources.rootDirectory),
-      clientCapabilities: clientCapabilities,
+      capabilityRegistry: CapabilityRegistry(clientCapabilities: clientCapabilities),
       toolchainRegistry: ToolchainRegistry.shared,
       buildSetup: BuildSetup(configuration: .debug, path: buildPath, flags: BuildFlags()),
       underlyingBuildSystem: buildSystem,

Sources/SourceKitLSP/CMakeLists.txt

@@ -6,6 +6,7 @@ if(CMAKE_VERSION VERSION_LESS 3.16)
 endif()
 
 add_library(SourceKitLSP
+  CapabilityRegistry.swift
   DocumentManager.swift
   IndexStoreDB+MainFilesProvider.swift
   SourceKitIndexDelegate.swift

Sources/SourceKitLSP/CapabilityRegistry.swift

@@ -0,0 +1,103 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2021 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import LanguageServerProtocol
+
+/// Handler responsible for registering a capability with the client.
+public typealias ClientRegistrationHandler = (CapabilityRegistration) -> Void
+
+/// A class which tracks the client's capabilities as well as our dynamic
+/// capability registrations in order to avoid registering conflicting
+/// capabilities.
+public final class CapabilityRegistry {
+  /// Registered completion options.
+  private var completion: [CapabilityRegistration: CompletionRegistrationOptions] = [:]
+
+  public let clientCapabilities: ClientCapabilities
+
+  public init(clientCapabilities: ClientCapabilities) {
+    self.clientCapabilities = clientCapabilities
+  }
+
+  public var clientHasDynamicCompletionRegistration: Bool {
+    clientCapabilities.textDocument?.completion?.dynamicRegistration == true
+  }
+
+  /// Dynamically register completion capabilities if the client supports it and
+  /// we haven't yet registered any completion capabilities for the given
+  /// languages.
+  public func registerCompletionIfNeeded(
+    options: CompletionOptions,
+    for languages: [Language],
+    registerOnClient: ClientRegistrationHandler
+  ) {
+    guard clientHasDynamicCompletionRegistration && !hasCompletionRegistrations(for: languages) else {
+      return
+    }
+    let registrationOptions = CompletionRegistrationOptions(
+      documentSelector: self.documentSelector(for: languages),
+      completionOptions: options)
+    let registration = CapabilityRegistration(
+        method: CompletionRequest.method,
+      registerOptions: self.encode(registrationOptions))
+
+    self.completion[registration] = registrationOptions
+
+    registerOnClient(registration)
+  }
+
+  /// Unregister a previously registered registration, e.g. if no longer needed
+  /// or if registration fails.
+  public func remove(registration: CapabilityRegistration) {
+    if registration.method == CompletionRequest.method {
+      completion.removeValue(forKey: registration)
+    }
+  }
+
+  private func hasCompletionRegistrations(for languages: [Language]) -> Bool {
+    return self.hasAnyRegistrations(for: languages, in: self.completion)
+  }
+
+  private func documentSelector(for langauges: [Language]) -> DocumentSelector {
+    return DocumentSelector(langauges.map { DocumentFilter(language: $0.rawValue) })
+  }
+
+  private func encode<T: RegistrationOptions>(_ options: T) -> LSPAny {
+    var dict = [String: LSPAny]()
+    options.encodeIntoLSPAny(dict: &dict)
+    return .dictionary(dict)
+  }
+
+  /// Check if we have any text document registration in `registrations` scoped to
+  /// one or more of the given `languages`.
+  private func hasAnyRegistrations(
+    for languages: [Language],
+    in registrations: [CapabilityRegistration: TextDocumentRegistrationOptionsProtocol]
+  ) -> Bool {
+    var languageIds: Set<String> = []
+    for language in languages {
+      languageIds.insert(language.rawValue)
+    }
+
+    for registration in registrations {
+      let options = registration.value.textDocumentRegistrationOptions
+      guard let filters = options.documentSelector else { continue }
+      for filter in filters {
+        guard let filterLanguage = filter.language else { continue }
+        if languageIds.contains(filterLanguage) {
+          return true
+        }
+      }
+    }
+    return false
+  }
+}