convert client to interface-based only

Author: baronfel

src/Client.fs

@@ -1,49 +1,43 @@
 namespace Ionide.LanguageServerProtocol
 
 open Ionide.LanguageServerProtocol.Types
+open System
+open System.Threading
+open System.Threading.Tasks
 
-
-[<AbstractClass>]
-type LspClient() =
+[<Interface>]
+type ILspClient =
 
   /// The show message notification is sent from a server to a client to ask the client to display
   /// a particular message in the user interface.
-  abstract member WindowShowMessage: ShowMessageParams -> Async<unit>
-
-  default __.WindowShowMessage(_) = ignoreNotification
+  abstract member ``window/showMessage``: EventHandler<ShowMessageParams>
 
   /// The show message request is sent from a server to a client to ask the client to display
   /// a particular message in the user interface. In addition to the show message notification the
   /// request allows to pass actions and to wait for an answer from the client.
-  abstract member WindowShowMessageRequest: ShowMessageRequestParams -> AsyncLspResult<MessageActionItem option>
-
-  default __.WindowShowMessageRequest(_) = notImplemented
+  abstract member ``window/showMessageRequest``:
+    ShowMessageRequestParams * CancellationToken -> Task<MessageActionItem option>
 
   /// The log message notification is sent from the server to the client to ask the client to log
   ///a particular message.
-  abstract member WindowLogMessage: LogMessageParams -> Async<unit>
+  abstract member ``window/logMessage``: EventHandler<LogMessageParams>
 
-  default __.WindowLogMessage(_) = ignoreNotification
 
   /// The telemetry notification is sent from the server to the client to ask the client to log
   /// a telemetry event.
-  abstract member TelemetryEvent: Newtonsoft.Json.Linq.JToken -> Async<unit>
+  abstract member ``telemetry/event``: EventHandler<LSPAny>
 
-  default __.TelemetryEvent(_) = ignoreNotification
 
   /// The `client/registerCapability` request is sent from the server to the client to register for a new
   /// capability on the client side. Not all clients need to support dynamic capability registration.
   /// A client opts in via the dynamicRegistration property on the specific client capabilities. A client
   /// can even provide dynamic registration for capability A but not for capability B.
-  abstract member ClientRegisterCapability: RegistrationParams -> AsyncLspResult<unit>
+  abstract member ``client/registerCapability``: RegistrationParams * CancellationToken -> Task<unit>
 
-  default __.ClientRegisterCapability(_) = notImplemented
 
   /// The `client/unregisterCapability` request is sent from the server to the client to unregister a previously
   /// registered capability.
-  abstract member ClientUnregisterCapability: UnregistrationParams -> AsyncLspResult<unit>
-
-  default __.ClientUnregisterCapability(_) = notImplemented
+  abstract member ``client/unregisterCapability``: UnregistrationParams * CancellationToken -> Task<unit>
 
   /// Many tools support more than one root folder per workspace. Examples for this are VS Code’s multi-root
   /// support, Atom’s project folder support or Sublime’s project support. If a client workspace consists of
@@ -56,42 +50,37 @@ type LspClient() =
   /// The workspace/workspaceFolders request is sent from the server to the client to fetch the current open
   /// list of workspace folders. Returns null in the response if only a single file is open in the tool.
   /// Returns an empty array if a workspace is open but no folders are configured.
-  abstract member WorkspaceWorkspaceFolders: unit -> AsyncLspResult<WorkspaceFolder [] option>
+  abstract member ``workspace/workspaceFolders``: unit * CancellationToken -> Task<WorkspaceFolder array option>
 
-  default __.WorkspaceWorkspaceFolders() = notImplemented
 
   /// The workspace/configuration request is sent from the server to the client to fetch configuration
   /// settings from the client.
   ///
   /// The request can fetch n configuration settings in one roundtrip. The order of the returned configuration
   /// settings correspond to the order of the passed ConfigurationItems (e.g. the first item in the response
   /// is the result for the first configuration item in the params).
-  abstract member WorkspaceConfiguration: ConfigurationParams -> AsyncLspResult<Newtonsoft.Json.Linq.JToken []>
+  abstract member ``workspace/configuration``: ConfigurationParams * CancellationToken -> Task<LSPAny array>
 
-  default __.WorkspaceConfiguration(_) = notImplemented
 
-  abstract member WorkspaceApplyEdit: ApplyWorkspaceEditParams -> AsyncLspResult<ApplyWorkspaceEditResponse>
-  default __.WorkspaceApplyEdit(_) = notImplemented
+  /// The workspace/applyEdit request is sent from the server to the client to modify resource on the client side.
+  abstract member ``workspace/applyEdit``:
+    ApplyWorkspaceEditParams * CancellationToken -> Task<ApplyWorkspaceEditResponse>
 
   /// The workspace/semanticTokens/refresh request is sent from the server to the client.
   /// Servers can use it to ask clients to refresh the editors for which this server provides semantic tokens.
   /// As a result the client should ask the server to recompute the semantic tokens for these editors.
   /// This is useful if a server detects a project wide configuration change which requires a re-calculation
   /// of all semantic tokens. Note that the client still has the freedom to delay the re-calculation of
   /// the semantic tokens if for example an editor is currently not visible.
-  abstract member WorkspaceSemanticTokensRefresh: unit -> Async<unit>
-
-  default __.WorkspaceSemanticTokensRefresh() = ignoreNotification
+  abstract member ``workspace/semanticTokens/refresh``: unit * CancellationToken -> Task<unit>
 
   /// The `workspace/inlayHint/refresh` request is sent from the server to the client.
   /// Servers can use it to ask clients to refresh the inlay hints currently shown in editors.
   /// As a result the client should ask the server to recompute the inlay hints for these editors.
   /// This is useful if a server detects a configuration change which requires a re-calculation
   /// of all inlay hints. Note that the client still has the freedom to delay the re-calculation of the inlay hints
   /// if for example an editor is currently not visible.
-  abstract member WorkspaceInlayHintRefresh: unit -> Async<unit>
-
-  default __.WorkspaceInlayHintRefresh() = ignoreNotification
+  abstract member ``workspace/inlayHint/refresh``: unit * CancellationToken -> Task<unit>
 
   /// Diagnostics notification are sent from the server to the client to signal results of validation runs.
   ///
@@ -107,6 +96,4 @@ type LspClient() =
   /// client. If the computed set is empty it has to push the empty array to clear former diagnostics.
   /// Newly pushed diagnostics always replace previously pushed diagnostics. There is no merging that happens
   /// on the client side.
-  abstract member TextDocumentPublishDiagnostics: PublishDiagnosticsParams -> Async<unit>
-
-  default __.TextDocumentPublishDiagnostics(_) = ignoreNotification
+  abstract member ``textDocument/publishDiagnostics``: EventHandler<PublishDiagnosticsParams>

src/Server.fs

@@ -7,7 +7,7 @@ open System.Threading
 open System.Threading.Tasks
 
 [<Interface>]
-type LspServer =
+type ILspServer =
   inherit System.IDisposable
 
   abstract member Dispose: unit -> unit