Adopt LSPAnyCodable in RegistrationOptions

Author: krzyzanowskim

Sources/LanguageServerProtocol/SupportTypes/LSPAny.swift

@@ -171,5 +171,15 @@ extension Array: LSPAnyCodable where Element: LSPAnyCodable {
   }
 }
 
+extension String: LSPAnyCodable {
+  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
+    nil
+  }
+
+  public func encodeToLSPAny() -> LSPAny {
+    .string(self)
+  }
+}
+
 public typealias LSPObject = [String: LSPAny]
 public typealias LSPArray = [LSPAny]

Sources/LanguageServerProtocol/SupportTypes/RegistrationOptions.swift

@@ -14,17 +14,8 @@ import Foundation
 
 /// 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])
-}
+public protocol RegistrationOptions: Hashable, LSPAnyCodable {
 
-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.
@@ -37,22 +28,20 @@ public struct TextDocumentRegistrationOptions: RegistrationOptions, Hashable {
     self.documentSelector = documentSelector
   }
 
-  public init(fromLSPAny value: LSPAny) {
-    guard case let .dictionary(dict) = value else {
-      return
-    }
-
+  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
     var documentSelector: DocumentSelector?
-    if let value = dict["documentSelector"] {
+
+    if let value = dictionary["documentSelector"] {
       documentSelector = DocumentSelector(fromLSPArray: value)
     }
 
     self.documentSelector = documentSelector
   }
 
-  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
-    guard let documentSelector = documentSelector else { return }
-    dict["documentSelector"] = documentSelector.encodeToLSPAny()
+  public func encodeToLSPAny() -> LSPAny {
+    guard let documentSelector = documentSelector else { return .null }
+
+    return .dictionary(["documentSelector": documentSelector.encodeToLSPAny()])
   }
 }
 
@@ -72,18 +61,32 @@ public struct CompletionRegistrationOptions: RegistrationOptions, TextDocumentRe
     self.completionOptions = completionOptions
   }
 
-  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
-    textDocumentRegistrationOptions.encodeIntoLSPAny(dict: &dict)
+  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
+    guard let completionOptions = CompletionOptions(fromLSPDictionary: dictionary) else {
+      return nil
+    }
 
-    if let resolveProvider = completionOptions.resolveProvider {
-      dict["resolveProvider"] = .bool(resolveProvider)
+    self.completionOptions = completionOptions
+
+    guard let textDocumentRegistrationOptions = TextDocumentRegistrationOptions(fromLSPDictionary: dictionary) else {
+      return nil
     }
-    if let triggerCharacters = completionOptions.triggerCharacters {
-      dict["triggerCharacters"] = encode(strings: triggerCharacters)
+
+    self.textDocumentRegistrationOptions = textDocumentRegistrationOptions
+  }
+
+  public func encodeToLSPAny() -> LSPAny {
+    var dict: [String : LSPAny] = [:]
+
+    if case .dictionary(let dictionary) = completionOptions.encodeToLSPAny() {
+      dict.merge(dictionary) { (current, _) in current }
     }
-    if let allCommitCharacters = completionOptions.allCommitCharacters {
-      dict["allCommitCharacters"] = encode(strings: allCommitCharacters)
+
+    if case .dictionary(let dictionary) = textDocumentRegistrationOptions.encodeToLSPAny() {
+      dict.merge(dictionary) { (current, _) in current }
     }
+
+    return .dictionary(dict)
   }
 }
 
@@ -98,8 +101,19 @@ public struct FoldingRangeRegistrationOptions: RegistrationOptions, TextDocument
     self.foldingRangeOptions = foldingRangeOptions
   }
 
-  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
-    textDocumentRegistrationOptions.encodeIntoLSPAny(dict: &dict)
+  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
+    guard let textDocumentRegistrationOptions = TextDocumentRegistrationOptions(fromLSPDictionary: dictionary) else {
+      return nil
+    }
+
+    self.textDocumentRegistrationOptions = textDocumentRegistrationOptions
+
+    /// Currently empty in the spec.
+    self.foldingRangeOptions = FoldingRangeOptions()
+  }
+
+  public func encodeToLSPAny() -> LSPAny {
+    textDocumentRegistrationOptions.encodeToLSPAny()
     // foldingRangeOptions is currently empty.
   }
 }
@@ -119,108 +133,32 @@ public struct SemanticTokensRegistrationOptions: RegistrationOptions, TextDocume
     self.semanticTokenOptions = semanticTokenOptions
   }
 
-  public init?(fromLSPAny value: LSPAny) {
-    guard case let .dictionary(dict) = value else {
+  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
+    guard let textDocumentRegistrationOptions = TextDocumentRegistrationOptions(fromLSPDictionary: dictionary) else {
       return nil
     }
 
-    textDocumentRegistrationOptions = TextDocumentRegistrationOptions(fromLSPAny: value)
-
-    var range: ValueOrBool<SemanticTokensOptions.SemanticTokensRangeOptions>?
-    if let rangeLSPAny = dict["range"] {
-      switch rangeLSPAny {
-      case let .bool(value):
-        range = .bool(value)
-      case .dictionary:
-        range = .value(SemanticTokensOptions.SemanticTokensRangeOptions())
-      default:
-        break
-      }
-    }
-
-    var full: ValueOrBool<SemanticTokensOptions.SemanticTokensFullOptions>?
-    if let fullLSPAny = dict["full"] {
-      switch fullLSPAny {
-      case let .bool(value):
-        full = .bool(value)
-      case let .dictionary(optionsDict):
-        var delta: Bool?
-        if let value = optionsDict["delta"],
-           case let .bool(deltaValue) = value
-        {
-          delta = deltaValue
-        }
-
-        full = .value(SemanticTokensOptions.SemanticTokensFullOptions(delta: delta))
-      default:
-        break
-      }
-    }
+    self.textDocumentRegistrationOptions = textDocumentRegistrationOptions
 
-    guard case let .dictionary(legendDict) = dict["legend"] else {
+    guard let semanticTokenOptions = SemanticTokensOptions(fromLSPDictionary: dictionary) else {
       return nil
     }
 
-    var tokenTypes: [String] = []
-    if case let .array(types) = legendDict["tokenTypes"] {
-      tokenTypes = types.compactMap {
-        if case let .string(string) = $0 {
-          return string
-        }
-        return nil
-      }
-    }
-
-    var tokenModifiers: [String] = []
-    if case let .array(types) = legendDict["tokenModifiers"] {
-      tokenModifiers = types.compactMap {
-        if case let .string(string) = $0 {
-          return string
-        }
-        return nil
-      }
-    }
-
-    let legend = SemanticTokensLegend(
-      tokenTypes: tokenTypes,
-      tokenModifiers: tokenModifiers
-    )
-
-    semanticTokenOptions = SemanticTokensOptions(
-      legend: legend,
-      range: range,
-      full: full
-    )
+    self.semanticTokenOptions = semanticTokenOptions
   }
 
-  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
-    textDocumentRegistrationOptions.encodeIntoLSPAny(dict: &dict)
-    let legend = semanticTokenOptions.legend
-    dict["legend"] = .dictionary([
-      "tokenTypes": encode(strings: legend.tokenTypes),
-      "tokenModifiers": encode(strings: legend.tokenModifiers),
-    ])
-    if let range = semanticTokenOptions.range {
-      let encodedRange: LSPAny
-      switch range {
-      case .bool(let value): encodedRange = .bool(value)
-      case .value(_): encodedRange = .dictionary([:])
-      }
-      dict["range"] = encodedRange
+  public func encodeToLSPAny() -> LSPAny {
+    var dict: [String: LSPAny] = [:]
+
+    if case .dictionary(let dictionary) = textDocumentRegistrationOptions.encodeToLSPAny() {
+      dict.merge(dictionary) { (current, _) in current }
     }
-    if let full = semanticTokenOptions.full {
-      let encodedFull: LSPAny
-      switch full {
-      case .bool(let value): encodedFull = .bool(value)
-      case .value(let fullOptions):
-        var encodedOptions: [String: LSPAny] = [:]
-        if let delta = fullOptions.delta {
-          encodedOptions["delta"] = .bool(delta)
-        }
-        encodedFull = .dictionary(encodedOptions)
-      }
-      dict["full"] = encodedFull
+
+    if case .dictionary(let dictionary) = semanticTokenOptions.encodeToLSPAny() {
+      dict.merge(dictionary) { (current, _) in current }
     }
+
+    return .dictionary(dict)
   }
 }
 
@@ -236,11 +174,32 @@ public struct InlayHintRegistrationOptions: RegistrationOptions, TextDocumentReg
     self.inlayHintOptions = inlayHintOptions
   }
 
-  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
-    textDocumentRegistrationOptions.encodeIntoLSPAny(dict: &dict)
+  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
+    self.inlayHintOptions = InlayHintOptions()
+
+    if case .bool(let resolveProvider) = dictionary["resolveProvider"] {
+      self.inlayHintOptions.resolveProvider = resolveProvider
+    }
+
+    guard let textDocumentRegistrationOptions = TextDocumentRegistrationOptions(fromLSPDictionary: dictionary) else {
+      return nil
+    }
+
+    self.textDocumentRegistrationOptions = textDocumentRegistrationOptions
+  }
+
+  public func encodeToLSPAny() -> LSPAny {
+    var dict: [String : LSPAny] = [:]
+
     if let resolveProvider = inlayHintOptions.resolveProvider {
       dict["resolveProvider"] = .bool(resolveProvider)
     }
+
+    if case .dictionary(let dictionary) = textDocumentRegistrationOptions.encodeToLSPAny() {
+      dict.merge(dictionary) { (current, _) in current }
+    }
+
+    return .dictionary(dict)
   }
 }
 
@@ -257,9 +216,29 @@ public struct DiagnosticRegistrationOptions: RegistrationOptions, TextDocumentRe
     self.diagnosticOptions = diagnosticOptions
   }
 
-  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
-    textDocumentRegistrationOptions.encodeIntoLSPAny(dict: &dict)
-    diagnosticOptions.encodeIntoLSPAny(dict: &dict)
+  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
+    guard let textDocumentRegistrationOptions = TextDocumentRegistrationOptions(fromLSPDictionary: dictionary) else {
+      return nil
+    }
+
+    self.textDocumentRegistrationOptions = textDocumentRegistrationOptions
+
+    guard let diagnosticOptions = DiagnosticOptions(fromLSPDictionary: dictionary) else {
+      return nil
+    }
+    self.diagnosticOptions = diagnosticOptions
+  }
+
+  public func encodeToLSPAny() -> LSPAny {
+    var dict: [String : LSPAny] = [:]
+    if case .dictionary(let dictionary) = textDocumentRegistrationOptions.encodeToLSPAny() {
+      dict.merge(dictionary) { (current, _) in current }
+    }
+
+    if case .dictionary(let dictionary) = diagnosticOptions.encodeToLSPAny() {
+      dict.merge(dictionary) { (current, _) in current }
+    }
+    return .dictionary(dict)
   }
 }
 
@@ -272,8 +251,18 @@ public struct DidChangeWatchedFilesRegistrationOptions: RegistrationOptions {
     self.watchers = watchers
   }
 
-  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
-    dict["watchers"] = watchers.encodeToLSPAny()
+  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
+    guard let watchersArray = dictionary["watchers"],
+          let watchers = [FileSystemWatcher](fromLSPArray: watchersArray)
+    else {
+      return nil
+    }
+
+    self.watchers = watchers
+  }
+
+  public func encodeToLSPAny() -> LSPAny {
+    .dictionary(["watchers": watchers.encodeToLSPAny()])
   }
 }
 
@@ -286,7 +275,17 @@ public struct ExecuteCommandRegistrationOptions: RegistrationOptions {
     self.commands = commands
   }
 
-  public func encodeIntoLSPAny(dict: inout [String: LSPAny]) {
-    dict["commands"] = encode(strings: commands)
+  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
+    guard let commandsArray = dictionary["commands"],
+          let commands = [String](fromLSPArray: commandsArray)
+    else {
+      return nil
+    }
+
+    self.commands = commands
+  }
+
+  public func encodeToLSPAny() -> LSPAny {
+    .dictionary(["commands": commands.encodeToLSPAny()])
   }
 }

Sources/LanguageServerProtocol/SupportTypes/SemanticTokens.swift

@@ -11,7 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 /// The legend for a server's encoding of semantic tokens.
-public struct SemanticTokensLegend: Codable, Hashable {
+public struct SemanticTokensLegend: Codable, Hashable, LSPAnyCodable {
   /// The token types for a server.
   ///
   /// Token types are looked up by indexing into this array, e.g. a `tokenType`
@@ -31,6 +31,29 @@ public struct SemanticTokensLegend: Codable, Hashable {
     self.tokenTypes = tokenTypes
     self.tokenModifiers = tokenModifiers
   }
+
+  public init?(fromLSPDictionary dictionary: [String : LSPAny]) {
+    self.tokenTypes = []
+    if let tokenTypesAny = dictionary["tokenTypes"],
+       let tokenTypes = [String](fromLSPArray: tokenTypesAny)
+    {
+      self.tokenTypes = tokenTypes
+    }
+
+    self.tokenModifiers = []
+    if let tokenModifiersAny = dictionary["tokenModifiers"],
+       let tokenModifiers = [String](fromLSPArray: tokenModifiersAny)
+    {
+      self.tokenModifiers = tokenModifiers
+    }
+  }
+
+  public func encodeToLSPAny() -> LSPAny {
+    .dictionary([
+      "tokenTypes": tokenTypes.encodeToLSPAny(),
+      "tokenModifiers": tokenModifiers.encodeToLSPAny()
+    ])
+  }
 }
 
 /// The encoding format for semantic tokens. Currently only `relative` is supported.