Added support for lsp version 3.14.0

Author: david-driscoll

language-server-protocol.sha.txt

@@ -1,2 +1,4 @@
 -- This is the last commit we caught up with https://github.com/Microsoft/language-server-protocol/commits/gh-pages
-9e2713d5f1618b8d5e05a91a4e2c637aa51e1ee0
+lastSha: 1a69f1270d59cccd7b85e0697450950abd5a0221
+
+https://github.com/Microsoft/language-server-protocol/compare/<lastSha>..<newSha>

src/Client/LspErrorCodes.cs

@@ -44,5 +44,10 @@ public static class LspErrorCodes
         ///     Request was cancelled.
         /// </summary>
         public const int RequestCancelled = -32800;
+
+        /// <summary>
+        ///     Request was cancelled.
+        /// </summary>
+        public const int ContentModified = -32801;
     }
 }

src/JsonRpc/AsyncRequestHandler.cs

@@ -0,0 +1,27 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace OmniSharp.Extensions.Embedded.MediatR
+{
+    /// <summary>
+    /// Wrapper class for a handler that asynchronously handles a request and does not return a response
+    /// </summary>
+    /// <typeparam name="TRequest">The type of request being handled</typeparam>
+    public abstract class AsyncRequestHandler<TRequest> : IRequestHandler<TRequest>
+        where TRequest : IRequest
+    {
+        async Task<Unit> IRequestHandler<TRequest, Unit>.Handle(TRequest request, CancellationToken cancellationToken)
+        {
+            await Handle(request, cancellationToken).ConfigureAwait(false);
+            return Unit.Value;
+        }
+
+        /// <summary>
+        /// Override in a derived class for the handler logic
+        /// </summary>
+        /// <param name="request">Request</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Response</returns>
+        protected abstract Task Handle(TRequest request, CancellationToken cancellationToken);
+    }
+}

src/JsonRpc/IBaseRequest.cs

@@ -0,0 +1,7 @@
+namespace OmniSharp.Extensions.Embedded.MediatR
+{
+    /// <summary>
+    /// Allows for generic type constraints of objects implementing IRequest or IRequest{TResponse}
+    /// </summary>
+    public interface IBaseRequest { }
+}

src/JsonRpc/ReflectionRequestHandlers.cs renamed to src/JsonRpc/MediatRHandlers.cs

@@ -0,0 +1,25 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace OmniSharp.Extensions.Embedded.MediatR
+{
+    /// <summary>
+    /// Wrapper class for a synchronous notification handler
+    /// </summary>
+    /// <typeparam name="TNotification">The notification type</typeparam>
+    public abstract class NotificationHandler<TNotification> : INotificationHandler<TNotification>
+        where TNotification : INotification
+    {
+        Task INotificationHandler<TNotification>.Handle(TNotification notification, CancellationToken cancellationToken)
+        {
+            Handle(notification);
+            return Unit.Task;
+        }
+
+        /// <summary>
+        /// Override in a derived class for the handler logic
+        /// </summary>
+        /// <param name="notification">Notification</param>
+        protected abstract void Handle(TNotification notification);
+    }
+}

src/JsonRpc/NotificationHandler.cs

@@ -0,0 +1,24 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace OmniSharp.Extensions.Embedded.MediatR
+{
+    /// <summary>
+    /// Wrapper class for a handler that synchronously handles a request and returns a response
+    /// </summary>
+    /// <typeparam name="TRequest">The type of request being handled</typeparam>
+    /// <typeparam name="TResponse">The type of response from the handler</typeparam>
+    public abstract class RequestHandler<TRequest, TResponse> : IRequestHandler<TRequest, TResponse>
+        where TRequest : IRequest<TResponse>
+    {
+        Task<TResponse> IRequestHandler<TRequest, TResponse>.Handle(TRequest request, CancellationToken cancellationToken)
+            => Task.FromResult(Handle(request));
+
+        /// <summary>
+        /// Override in a derived class for the handler logic
+        /// </summary>
+        /// <param name="request">Request</param>
+        /// <returns>Response</returns>
+        protected abstract TResponse Handle(TRequest request);
+    }
+}

src/JsonRpc/RequestHandler.cs

@@ -0,0 +1,11 @@
+using System.Threading.Tasks;
+
+namespace OmniSharp.Extensions.Embedded.MediatR
+{
+    /// <summary>
+    /// Represents an async continuation for the next task to execute in the pipeline
+    /// </summary>
+    /// <typeparam name="TResponse">Response type</typeparam>
+    /// <returns>Awaitable task returning a <typeparamref name="TResponse"/></returns>
+    public delegate Task<TResponse> RequestHandlerDelegate<TResponse>();
+}

src/JsonRpc/RequestHandlerDelegate.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace OmniSharp.Extensions.Embedded.MediatR
+{
+    public static class ServiceFactoryExtensions
+    {
+        public static T GetInstance<T>(this ServiceFactory factory)
+            => (T) factory(typeof(T));
+
+        public static IEnumerable<T> GetInstances<T>(this ServiceFactory factory)
+            => (IEnumerable<T>) factory(typeof(IEnumerable<T>));
+    }
+}

src/JsonRpc/ServiceFactoryExtensions.cs

@@ -0,0 +1,6 @@
+using OmniSharp.Extensions.LanguageServer.Protocol.Server;
+
+namespace OmniSharp.Extensions.LanguageServer.Protocol.Client.Capabilities
+{
+    public class DeclarationCapability : LinkSupportCapability, ConnectedCapability<IDeclarationHandler> { }
+}