Added ability to add many handlers

Author: david-driscoll

src/Lsp/Abstractions/IHandlerCollection.cs

@@ -6,9 +6,7 @@ namespace OmniSharp.Extensions.LanguageServer.Abstractions
 {
     interface IHandlerCollection : IEnumerable<ILspHandlerDescriptor>
     {
-        IDisposable Add(IJsonRpcHandler handler);
-
-        IEnumerable<ILspHandlerDescriptor> Get(string method);
-        IEnumerable<ILspHandlerDescriptor> Get(IJsonRpcHandler handler);
+        IDisposable Add(params IJsonRpcHandler[] handlers);
+        IDisposable Add(IEnumerable<IJsonRpcHandler> handlers);
     }
-}
+}

src/Lsp/HandlerCollection.cs

@@ -22,49 +22,45 @@ IEnumerator IEnumerable.GetEnumerator()
             return GetEnumerator();
         }
 
-        public IDisposable Add(IJsonRpcHandler handler)
+        public IDisposable Add(params IJsonRpcHandler[] handlers)
         {
-            //var type = handler.GetType();
+            return Add(handlers.AsEnumerable());
+        }
 
-            var handlers = new List<HandlerDescriptor>();
-            foreach (var implementedInterface in handler.GetType().GetTypeInfo()
-                .ImplementedInterfaces
-                .Where(x => !string.IsNullOrWhiteSpace(LspHelper.GetMethodName(x))))
+        public IDisposable Add(IEnumerable<IJsonRpcHandler> handlers)
+        {
+            var descriptors = new List<HandlerDescriptor>();
+            foreach (var handler in handlers)
             {
-                var @interface = GetHandlerInterface(implementedInterface);
-                if (@interface == null) continue;
-                var registration = UnwrapGenericType(typeof(IRegistration<>), implementedInterface);
-                var capability = UnwrapGenericType(typeof(ICapability<>), implementedInterface);
-
-                Type @params = null;
-                if (@interface.GetTypeInfo().IsGenericType)
+                foreach (var implementedInterface in handler.GetType().GetTypeInfo()
+                    .ImplementedInterfaces
+                    .Where(x => !string.IsNullOrWhiteSpace(LspHelper.GetMethodName(x))))
                 {
-                    @params = @interface.GetTypeInfo().GetGenericArguments()[0];
-                }
+                    var @interface = GetHandlerInterface(implementedInterface);
+                    var registration = UnwrapGenericType(typeof(IRegistration<>), implementedInterface);
+                    var capability = UnwrapGenericType(typeof(ICapability<>), implementedInterface);
 
-                var h = new HandlerDescriptor(
-                    LspHelper.GetMethodName(implementedInterface),
-                    handler,
-                    @interface,
-                    @params,
-                    registration,
-                    capability,
-                    () => _handlers.RemoveWhere(instance => instance.Handler == handler));
+                    Type @params = null;
+                    if (@interface.GetTypeInfo().IsGenericType)
+                    {
+                        @params = @interface.GetTypeInfo().GetGenericArguments()[0];
+                    }
 
-                _handlers.Add(h);
-            }
+                    var h = new HandlerDescriptor(
+                        LspHelper.GetMethodName(implementedInterface),
+                        handler,
+                        @interface,
+                        @params,
+                        registration,
+                        capability,
+                        () => _handlers.RemoveWhere(instance => instance.Handler == handler));
 
-            return new ImutableDisposable(handlers);
-        }
-
-        public IEnumerable<ILspHandlerDescriptor> Get(IJsonRpcHandler handler)
-        {
-            return _handlers.Where(instance => instance.Handler == handler);
-        }
+                    descriptors.Add(h);
+                    _handlers.Add(h);
+                }
+            }
 
-        public IEnumerable<ILspHandlerDescriptor> Get(string method)
-        {
-            return _handlers.Where(instance => instance.Method == method);
+            return new ImutableDisposable(descriptors);
         }
 
         private static readonly Type[] HandlerTypes = { typeof(INotificationHandler), typeof(INotificationHandler<>), typeof(IRequestHandler<>), typeof(IRequestHandler<,>), };

src/Lsp/LanguageServer.cs

@@ -67,19 +67,31 @@ IRequestProcessIdentifier requestProcessIdentifier
 
         public IDisposable AddHandler(IJsonRpcHandler handler)
         {
-            var handlerDisposable = _collection.Add(handler);
+            return AddHandler(handler);
+        }
+
+        public IDisposable AddHandlers(params IJsonRpcHandler[] handlers)
+        {
+            return AddHandlers(handlers.AsEnumerable());
+        }
+
+        public IDisposable AddHandlers(IEnumerable<IJsonRpcHandler> handlers)
+        {
+            var handlerDisposable = _collection.Add(handlers);
 
             return new ImutableDisposable(
                 handlerDisposable,
-                new Disposable(() => {
-                    var handlers = _collection
-                        .Where(x => x.Handler == handler)
+                new Disposable(() =>
+                {
+                    var foundItems = handlers
+                    .SelectMany(handler => _collection
+                        .Where(x => handler == x.Handler)
                         .Where(x => x.AllowsDynamicRegistration)
                         .Select(x => x.Registration)
-                        .Where(x => x != null)
-                        .ToArray();
+                        .Where(x => x != null))
+                    .ToArray();
 
-                    Task.Run(() => this.UnregisterCapability(new UnregistrationParams() { Unregisterations = handlers }));
+                    Task.Run(() => this.UnregisterCapability(new UnregistrationParams() { Unregisterations = foundItems }));
                 }));
         }
 
@@ -117,7 +129,8 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
                 }
             }
 
-            var serverCapabilities = new ServerCapabilities() {
+            var serverCapabilities = new ServerCapabilities()
+            {
                 CodeActionProvider = HasHandler<ICodeActionHandler>(),
                 CodeLensProvider = GetOptions<ICodeLensOptions, CodeLensOptions>(CodeLensOptions.Of),
                 CompletionProvider = GetOptions<ICompletionOptions, CompletionOptions>(CompletionOptions.Of),
@@ -147,7 +160,8 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
             }
             else
             {
-                serverCapabilities.TextDocumentSync = textSyncHandler?.Options ?? new TextDocumentSyncOptions() {
+                serverCapabilities.TextDocumentSync = textSyncHandler?.Options ?? new TextDocumentSyncOptions()
+                {
                     Change = TextDocumentSyncKind.None,
                     OpenClose = false,
                     Save = new SaveOptions() { IncludeText = false },