Added new method to allow adding a handler with a given method name (avoiding have to hav have the method attribute on everything)

Author: david-driscoll

src/JsonRpc/HandlerCollection.cs

@@ -51,6 +51,11 @@ private void Remove(IJsonRpcHandler handler)
         }
 
         public IDisposable Add(IJsonRpcHandler handler)
+        {
+            return Add(GetMethodName(handler.GetType()), handler);
+        }
+
+        public IDisposable Add(string method, IJsonRpcHandler handler)
         {
             var type = handler.GetType();
             var @interface = GetHandlerInterface(type);
@@ -61,12 +66,17 @@ public IDisposable Add(IJsonRpcHandler handler)
                 @params = @interface.GetTypeInfo().GetGenericArguments()[0];
             }
 
-            var h = new HandlerInstance(GetMethodName(type), handler, @interface, @params, () => Remove(handler));
+            var h = new HandlerInstance(method, handler, @interface, @params, () => Remove(handler));
             _handlers.Add(h);
             return h;
         }
 
-        private static readonly Type[] HandlerTypes = { typeof(INotificationHandler), typeof(INotificationHandler<>), typeof(IRequestHandler<>), typeof(IRequestHandler<,>), };
+        private static readonly Type[] HandlerTypes = {
+            typeof(INotificationHandler),
+            typeof(INotificationHandler<>),
+            typeof(IRequestHandler<>),
+            typeof(IRequestHandler<,>),
+        };
 
         private string GetMethodName(Type type)
         {

src/Lsp/Abstractions/IHandlerCollection.cs

@@ -1,11 +1,12 @@
-using System;
+using System;
 using System.Collections.Generic;
 using OmniSharp.Extensions.JsonRpc;
 
 namespace OmniSharp.Extensions.LanguageServer.Abstractions
 {
     public interface IHandlerCollection : IEnumerable<ILspHandlerDescriptor>
     {
+        IDisposable Add(string method, IJsonRpcHandler handler);
         IDisposable Add(params IJsonRpcHandler[] handlers);
         IDisposable Add(IEnumerable<IJsonRpcHandler> handlers);
     }

src/Lsp/HandlerCollection.cs

@@ -23,6 +23,13 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
+        public IDisposable Add(string method, IJsonRpcHandler handler)
+        {
+            var descriptor = GetDescriptor(method, handler.GetType(), handler);
+            _handlers.Add(descriptor);
+            return descriptor;
+        }
+
         public IDisposable Add(IEnumerable<IJsonRpcHandler> handlers)
         {
             return Add(handlers.ToArray());
@@ -33,40 +40,12 @@ public IDisposable Add(params IJsonRpcHandler[] handlers)
             var descriptors = new HashSet<HandlerDescriptor>();
             foreach (var handler in handlers)
             {
-                foreach (var implementedInterface in handler.GetType().GetTypeInfo()
+                foreach (var (method, implementedInterface) in handler.GetType().GetTypeInfo()
                     .ImplementedInterfaces
-                    .Where(x => !string.IsNullOrWhiteSpace(LspHelper.GetMethodName(x))))
+                    .Select(x => (method: LspHelper.GetMethodName(x), implementedInterface: x))
+                    .Where(x => !string.IsNullOrWhiteSpace(x.method)))
                 {
-                    var @interface = HandlerTypeHelpers.GetHandlerInterface(implementedInterface);
-                    var registration = UnwrapGenericType(typeof(IRegistration<>), implementedInterface);
-                    var capability = UnwrapGenericType(typeof(ICapability<>), implementedInterface);
-
-                    Type @params = null;
-                    if (@interface.GetTypeInfo().IsGenericType)
-                    {
-                        @params = @interface.GetTypeInfo().GetGenericArguments()[0];
-                    }
-
-                    var key = "default";
-                    if (handler is IRegistration<TextDocumentRegistrationOptions>)
-                    {
-                        if (GetTextDocumentRegistrationOptionsMethod
-                            .MakeGenericMethod(registration)
-                            .Invoke(handler, new object[] { handler }) is TextDocumentRegistrationOptions options)
-                            key = options.DocumentSelector;
-                    }
-
-                    var h = new HandlerDescriptor(
-                        LspHelper.GetMethodName(implementedInterface),
-                        key,
-                        handler,
-                        @interface,
-                        @params,
-                        registration,
-                        capability,
-                        () => _handlers.RemoveWhere(instance => instance.Handler == handler));
-
-                    descriptors.Add(h);
+                    descriptors.Add(GetDescriptor(method, implementedInterface, handler));
                 }
             }
 
@@ -78,6 +57,38 @@ public IDisposable Add(params IJsonRpcHandler[] handlers)
             return new ImmutableDisposable(descriptors);
         }
 
+        private HandlerDescriptor GetDescriptor(string method, Type implementedType, IJsonRpcHandler handler)
+        {
+            var @interface = HandlerTypeHelpers.GetHandlerInterface(implementedType);
+            var registration = UnwrapGenericType(typeof(IRegistration<>), implementedType);
+            var capability = UnwrapGenericType(typeof(ICapability<>), implementedType);
+
+            Type @params = null;
+            if (@interface.GetTypeInfo().IsGenericType)
+            {
+                @params = @interface.GetTypeInfo().GetGenericArguments()[0];
+            }
+
+            var key = "default";
+            if (handler is IRegistration<TextDocumentRegistrationOptions>)
+            {
+                if (GetTextDocumentRegistrationOptionsMethod
+                    .MakeGenericMethod(registration)
+                    .Invoke(handler, new object[] { handler }) is TextDocumentRegistrationOptions options)
+                    key = options.DocumentSelector;
+            }
+
+            return new HandlerDescriptor(
+                method,
+                key,
+                handler,
+                @interface,
+                @params,
+                registration,
+                capability,
+                () => _handlers.RemoveWhere(instance => instance.Handler == handler));
+        }
+
         private static readonly MethodInfo GetTextDocumentRegistrationOptionsMethod = typeof(HandlerCollection).GetTypeInfo()
             .GetMethod(nameof(GetTextDocumentRegistrationOptions), BindingFlags.Static | BindingFlags.NonPublic);
 

src/Lsp/ILanguageServer.cs

@@ -7,6 +7,7 @@ namespace OmniSharp.Extensions.LanguageServer
 {
     public interface ILanguageServer : IResponseRouter
     {
+        IDisposable AddHandler(string method, IJsonRpcHandler handler);
         IDisposable AddHandler(IJsonRpcHandler handler);
         IDisposable AddHandlers(IEnumerable<IJsonRpcHandler> handlers);
         IDisposable AddHandlers(params IJsonRpcHandler[] handlers);

src/Lsp/LanguageServer.cs

@@ -59,6 +59,26 @@ internal LanguageServer(Stream input, IOutputHandler output, LspReciever recieve
         public InitializeParams Client { get; private set; }
         public InitializeResult Server { get; private set; }
 
+        public IDisposable AddHandler(string method, IJsonRpcHandler handler)
+        {
+            var handlerDisposable = _collection.Add(method, handler);
+
+            return new ImmutableDisposable(
+                handlerDisposable,
+                new Disposable(() => {
+                    var foundItems = _collection
+                        .Where(x => handler == x.Handler)
+                        .Where(x => x.AllowsDynamicRegistration)
+                        .Select(x => x.Registration)
+                        .Where(x => x != null)
+                        .ToArray();
+
+                    Task.Run(() => this.UnregisterCapability(new UnregistrationParams() {
+                        Unregisterations = foundItems
+                    }));
+                }));
+        }
+
         public IDisposable AddHandler(IJsonRpcHandler handler)
         {
             return AddHandlers(handler);

test/Lsp.Tests/HandlerResolverTests.cs

@@ -168,5 +168,19 @@ public void Should_Contain_AllDefinedMethods_OnLanguageServer_WithDifferentKeys(
             handler._handlers.Should().Contain(x => x.Method == key2);
             handler._handlers.Count.Should().Be(count);
         }
+
+        [Theory]
+        [InlineData("somemethod", typeof(IRequestHandler<object, object>))]
+        public void Should_AllowSpecificHandlers_ToBeAdded(string method, Type handlerType)
+        {
+            var handler = new HandlerCollection();
+            var sub = (IJsonRpcHandler)Substitute.For(new Type[] { handlerType }, new object[0]);
+            var sub2= (IJsonRpcHandler)Substitute.For(new Type[] { handlerType }, new object[0]);
+            handler.Add(method, sub);
+            handler.Add(method, sub2);
+            handler._handlers.Should().Contain(x => x.Method == method);
+            handler._handlers.Should().Contain(x => x.Method == method);
+            handler._handlers.Count.Should().Be(1);
+        }
     }
 }