Merge pull request #41 from OmniSharp/fix/didchange-callback

david-driscoll · web-flow · commit d1ad86df1bf7 · 2017-10-26T17:08:09.000-04:00
Fix/didchange callback
diff --git a/src/JsonRpc/IRequestRouter.cs b/src/JsonRpc/IRequestRouter.cs
@@ -1,12 +1,12 @@
-﻿using System;
+using System;
 using System.Threading.Tasks;
 using OmniSharp.Extensions.JsonRpc.Server;
 
 namespace OmniSharp.Extensions.JsonRpc
 {
     public interface IRequestRouter
     {
-        void RouteNotification(Notification notification);
+        Task RouteNotification(Notification notification);
         Task<ErrorResponse> RouteRequest(Request request);
     }
 }
diff --git a/src/JsonRpc/InputHandler.cs b/src/JsonRpc/InputHandler.cs
@@ -190,10 +190,10 @@ private void HandleRequest(string request)
                     _scheduler.Add(
                         type,
                         item.Notification.Method,
-                        () => {
+                        async () => {
                             try
                             {
-                                _requestRouter.RouteNotification(item.Notification);
+                                await _requestRouter.RouteNotification(item.Notification);
                             }
                             catch (Exception e)
                             {
@@ -202,7 +202,6 @@ private void HandleRequest(string request)
                                 // If an exception happens... the whole system could be in a bad state, hence this throwing currently.
                                 throw;
                             }
-                            return Task.CompletedTask;
                         }
                     );
                 }
diff --git a/src/JsonRpc/ProcessScheduler.cs b/src/JsonRpc/ProcessScheduler.cs
@@ -1,4 +1,4 @@
-﻿using System;
+using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading;
@@ -128,7 +128,7 @@ public void Dispose()
         }
     }
 
-    static class Events
+    public static class Events
     {
         public static EventId UnhandledException = new EventId(1337_100);
         public static EventId UnhandledRequest = new EventId(1337_101);
diff --git a/src/JsonRpc/RequestRouter.cs b/src/JsonRpc/RequestRouter.cs
@@ -22,7 +22,7 @@ public IDisposable Add(IJsonRpcHandler handler)
             return _collection.Add(handler);
         }
 
-        public async void RouteNotification(Notification notification)
+        public async Task RouteNotification(Notification notification)
         {
             var handler = _collection.FirstOrDefault(x => x.Method == notification.Method);
 
diff --git a/src/Lsp/ClientCapabilityProvider.cs b/src/Lsp/ClientCapabilityProvider.cs
@@ -16,7 +16,7 @@ public ClientCapabilityProvider(IHandlerCollection collection)
             _collection = collection;
         }
 
-        public bool HasHandler<T>(Supports<T> capability)
+        public bool HasStaticHandler<T>(Supports<T> capability)
             where T : DynamicCapability, ConnectedCapability<IJsonRpcHandler>
         {
             if (!capability.IsSupported) return false;
@@ -26,13 +26,16 @@ public bool HasHandler<T>(Supports<T> capability)
             var handlerType = typeof(T).GetTypeInfo().ImplementedInterfaces
                 .Single(x => x.GetTypeInfo().IsGenericType && x.GetTypeInfo().GetGenericTypeDefinition() == typeof(ConnectedCapability<>))
                 .GetTypeInfo().GetGenericArguments()[0].GetTypeInfo();
-            return !capability.Value.DynamicRegistration && _collection.Any(z => z.HandlerType.GetTypeInfo().IsAssignableFrom(handlerType));
+            return !capability.Value.DynamicRegistration &&
+                _collection.Any(z =>
+                    z.HandlerType.GetTypeInfo().IsAssignableFrom(handlerType) ||
+                    z.Handler.GetType().GetTypeInfo().IsAssignableFrom(handlerType));
         }
 
-        public IOptionsGetter GetOptions<T>(Supports<T> capability)
+        public IOptionsGetter GetStaticOptions<T>(Supports<T> capability)
             where T : DynamicCapability, ConnectedCapability<IJsonRpcHandler>
         {
-            return !HasHandler(capability) ? Null : new OptionsGetter(_collection);
+            return !HasStaticHandler(capability) ? Null : new OptionsGetter(_collection);
         }
 
         private static readonly IOptionsGetter Null = new NullOptionsGetter();
diff --git a/src/Lsp/LanguageServer.cs b/src/Lsp/LanguageServer.cs
@@ -130,22 +130,22 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
             var ccp = new ClientCapabilityProvider(_collection);
 
             var serverCapabilities = new ServerCapabilities() {
-                CodeActionProvider = ccp.HasHandler(textDocumentCapabilities.CodeAction),
-                CodeLensProvider = ccp.GetOptions(textDocumentCapabilities.CodeLens).Get<ICodeLensOptions, CodeLensOptions>(CodeLensOptions.Of),
-                CompletionProvider = ccp.GetOptions(textDocumentCapabilities.Completion).Get<ICompletionOptions, CompletionOptions>(CompletionOptions.Of),
-                DefinitionProvider = ccp.HasHandler(textDocumentCapabilities.Definition),
-                DocumentFormattingProvider = ccp.HasHandler(textDocumentCapabilities.Formatting),
-                DocumentHighlightProvider = ccp.HasHandler(textDocumentCapabilities.DocumentHighlight),
-                DocumentLinkProvider = ccp.GetOptions(textDocumentCapabilities.DocumentLink).Get<IDocumentLinkOptions, DocumentLinkOptions>(DocumentLinkOptions.Of),
-                DocumentOnTypeFormattingProvider = ccp.GetOptions(textDocumentCapabilities.OnTypeFormatting).Get<IDocumentOnTypeFormattingOptions, DocumentOnTypeFormattingOptions>(DocumentOnTypeFormattingOptions.Of),
-                DocumentRangeFormattingProvider = ccp.HasHandler(textDocumentCapabilities.RangeFormatting),
-                DocumentSymbolProvider = ccp.HasHandler(textDocumentCapabilities.DocumentSymbol),
-                ExecuteCommandProvider = ccp.GetOptions(workspaceCapabilities.ExecuteCommand).Get<IExecuteCommandOptions, ExecuteCommandOptions>(ExecuteCommandOptions.Of),
-                HoverProvider = ccp.HasHandler(textDocumentCapabilities.Hover),
-                ReferencesProvider = ccp.HasHandler(textDocumentCapabilities.References),
-                RenameProvider = ccp.HasHandler(textDocumentCapabilities.Rename),
-                SignatureHelpProvider = ccp.GetOptions(textDocumentCapabilities.SignatureHelp).Get<ISignatureHelpOptions, SignatureHelpOptions>(SignatureHelpOptions.Of),
-                WorkspaceSymbolProvider = ccp.HasHandler(workspaceCapabilities.Symbol)
+                CodeActionProvider = ccp.HasStaticHandler(textDocumentCapabilities.CodeAction),
+                CodeLensProvider = ccp.GetStaticOptions(textDocumentCapabilities.CodeLens).Get<ICodeLensOptions, CodeLensOptions>(CodeLensOptions.Of),
+                CompletionProvider = ccp.GetStaticOptions(textDocumentCapabilities.Completion).Get<ICompletionOptions, CompletionOptions>(CompletionOptions.Of),
+                DefinitionProvider = ccp.HasStaticHandler(textDocumentCapabilities.Definition),
+                DocumentFormattingProvider = ccp.HasStaticHandler(textDocumentCapabilities.Formatting),
+                DocumentHighlightProvider = ccp.HasStaticHandler(textDocumentCapabilities.DocumentHighlight),
+                DocumentLinkProvider = ccp.GetStaticOptions(textDocumentCapabilities.DocumentLink).Get<IDocumentLinkOptions, DocumentLinkOptions>(DocumentLinkOptions.Of),
+                DocumentOnTypeFormattingProvider = ccp.GetStaticOptions(textDocumentCapabilities.OnTypeFormatting).Get<IDocumentOnTypeFormattingOptions, DocumentOnTypeFormattingOptions>(DocumentOnTypeFormattingOptions.Of),
+                DocumentRangeFormattingProvider = ccp.HasStaticHandler(textDocumentCapabilities.RangeFormatting),
+                DocumentSymbolProvider = ccp.HasStaticHandler(textDocumentCapabilities.DocumentSymbol),
+                ExecuteCommandProvider = ccp.GetStaticOptions(workspaceCapabilities.ExecuteCommand).Get<IExecuteCommandOptions, ExecuteCommandOptions>(ExecuteCommandOptions.Of),
+                HoverProvider = ccp.HasStaticHandler(textDocumentCapabilities.Hover),
+                ReferencesProvider = ccp.HasStaticHandler(textDocumentCapabilities.References),
+                RenameProvider = ccp.HasStaticHandler(textDocumentCapabilities.Rename),
+                SignatureHelpProvider = ccp.GetStaticOptions(textDocumentCapabilities.SignatureHelp).Get<ISignatureHelpOptions, SignatureHelpOptions>(SignatureHelpOptions.Of),
+                WorkspaceSymbolProvider = ccp.HasStaticHandler(workspaceCapabilities.Symbol)
             };
 
             var textSyncHandlers = _collection
@@ -168,16 +168,21 @@ async Task<InitializeResult> IRequestHandler<InitializeParams, InitializeResult>
             }
             else
             {
-                if (ccp.HasHandler(textDocumentCapabilities.Synchronization))
+                if (ccp.HasStaticHandler(textDocumentCapabilities.Synchronization))
                 {
                     // TODO: Merge options
-                    serverCapabilities.TextDocumentSync = textSyncHandlers.FirstOrDefault()?.Options ?? new TextDocumentSyncOptions() {
-                        Change = TextDocumentSyncKind.None,
-                        OpenClose = false,
-                        Save = new SaveOptions() { IncludeText = false },
-                        WillSave = false,
-                        WillSaveWaitUntil = false
-                    };
+                    serverCapabilities.TextDocumentSync =
+                        textSyncHandlers.FirstOrDefault()?.Options ?? new TextDocumentSyncOptions() {
+                            Change = TextDocumentSyncKind.None,
+                            OpenClose = false,
+                            Save = new SaveOptions() { IncludeText = false },
+                            WillSave = false,
+                            WillSaveWaitUntil = false
+                        };
+                }
+                else
+                {
+                    serverCapabilities.TextDocumentSync = TextDocumentSyncKind.None;
                 }
             }
 
diff --git a/src/Lsp/LspRequestRouter.cs b/src/Lsp/LspRequestRouter.cs
@@ -57,35 +57,48 @@ private ILspHandlerDescriptor FindDescriptor(string method, JToken @params)
             if (typeof(ITextDocumentIdentifierParams).GetTypeInfo().IsAssignableFrom(descriptor.Params))
             {
                 var textDocumentIdentifierParams = @params.ToObject(descriptor.Params) as ITextDocumentIdentifierParams;
-                var textDocumentSyncHandlers = _collection
-                    .Select(x => x.Handler is ITextDocumentSyncHandler r ? r : null)
-                    .Where(x => x != null)
-                    .Distinct();
-                var attributes = textDocumentSyncHandlers
-                    .Select(x => x.GetTextDocumentAttributes(textDocumentIdentifierParams.TextDocument.Uri))
-                    .Where(x => x != null)
-                    .Distinct()
-                    .ToList();
+                var attributes = GetTextDocumentAttributes(textDocumentIdentifierParams.TextDocument.Uri);
 
                 _logger.LogTrace("Found attributes {Count}, {Attributes}", attributes.Count, attributes.Select(x => $"{x.LanguageId}:{x.Scheme}:{x.Uri}"));
 
                 return GetHandler(method, attributes);
             }
-            else if (typeof(DidOpenTextDocumentParams).GetTypeInfo().IsAssignableFrom(descriptor.Params))
+            else if (@params?.ToObject(descriptor.Params) is DidOpenTextDocumentParams openTextDocumentParams)
             {
-                var openTextDocumentParams = @params.ToObject(descriptor.Params) as DidOpenTextDocumentParams;
                 var attributes = new TextDocumentAttributes(openTextDocumentParams.TextDocument.Uri, openTextDocumentParams.TextDocument.LanguageId);
 
                 _logger.LogTrace("Created attribute {Attribute}", $"{attributes.LanguageId}:{attributes.Scheme}:{attributes.Uri}");
 
                 return GetHandler(method, attributes);
             }
+            else if (@params?.ToObject(descriptor.Params) is DidChangeTextDocumentParams didChangeDocumentParams)
+            {
+                // TODO: Do something with document version here?
+                var attributes = GetTextDocumentAttributes(didChangeDocumentParams.TextDocument.Uri);
+
+                _logger.LogTrace("Found attributes {Count}, {Attributes}", attributes.Count, attributes.Select(x => $"{x.LanguageId}:{x.Scheme}:{x.Uri}"));
+
+                return GetHandler(method, attributes);
+            }
 
             // TODO: How to split these
             // Do they fork and join?
             return descriptor;
         }
 
+        private List<TextDocumentAttributes> GetTextDocumentAttributes(Uri uri)
+        {
+            var textDocumentSyncHandlers = _collection
+                .Select(x => x.Handler is ITextDocumentSyncHandler r ? r : null)
+                .Where(x => x != null)
+                .Distinct();
+            return textDocumentSyncHandlers
+                .Select(x => x.GetTextDocumentAttributes(uri))
+                .Where(x => x != null)
+                .Distinct()
+                .ToList();
+        }
+
         private ILspHandlerDescriptor GetHandler(string method, IEnumerable<TextDocumentAttributes> attributes)
         {
             return attributes
@@ -105,29 +118,37 @@ private ILspHandlerDescriptor GetHandler(string method, TextDocumentAttributes a
                 _logger.LogTrace("Document Selector {DocumentSelector}", registrationOptions.DocumentSelector.ToString());
                 if (registrationOptions.DocumentSelector == null || registrationOptions.DocumentSelector.IsMatch(attributes))
                 {
+                    _logger.LogTrace("Handler Selected: {Handler} via {DocumentSelector} (targeting {HandlerInterface})", handler.Handler.GetType().FullName, registrationOptions.DocumentSelector.ToString(), handler.HandlerType.GetType().FullName);
                     return handler;
                 }
             }
             return null;
         }
 
-        public async void RouteNotification(Notification notification)
+        public async Task RouteNotification(Notification notification)
         {
             var handler = FindDescriptor(notification.Method, notification.Params);
             if (handler is null) { return; }
 
-            Task result;
-            if (handler.Params is null)
+            try
             {
-                result = ReflectionRequestHandlers.HandleNotification(handler);
+                Task result;
+                if (handler.Params is null)
+                {
+                    result = ReflectionRequestHandlers.HandleNotification(handler);
+                }
+                else
+                {
+                    var @params = notification.Params.ToObject(handler.Params);
+                    result = ReflectionRequestHandlers.HandleNotification(handler, @params);
+                }
+
+                await result;
             }
-            else
+            catch (Exception e)
             {
-                var @params = notification.Params.ToObject(handler.Params);
-                result = ReflectionRequestHandlers.HandleNotification(handler, @params);
+                _logger.LogCritical(Events.UnhandledRequest, e, "Failed to handle request {Method}", notification.Method);
             }
-
-            await result;
         }
 
         public async Task<ErrorResponse> RouteRequest(Request request)
@@ -184,6 +205,11 @@ public async Task<ErrorResponse> RouteRequest(Request request)
             {
                 return new RequestCancelled();
             }
+            catch (Exception e)
+            {
+                _logger.LogCritical(Events.UnhandledRequest, e, "Failed to handle notification {Method}", request.Method);
+                return new InternalError(id);
+            }
             finally
             {
                 _requests.TryRemove(id, out var _);
diff --git a/src/Lsp/Models/DidChangeTextDocumentParams.cs b/src/Lsp/Models/DidChangeTextDocumentParams.cs
@@ -1,4 +1,4 @@
-﻿using Newtonsoft.Json;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Serialization;
 
 namespace OmniSharp.Extensions.LanguageServer.Models
@@ -18,4 +18,4 @@ public class DidChangeTextDocumentParams
         /// </summary>
         public Container<TextDocumentContentChangeEvent> ContentChanges { get; set; }
     }
-}
+}
diff --git a/test/JsonRpc.Tests/InputHandlerTests.cs b/test/JsonRpc.Tests/InputHandlerTests.cs
@@ -206,7 +206,7 @@ public void ShouldHandleError()
         }
 
         [Fact]
-        public void ShouldHandleNotification()
+        public async Task ShouldHandleNotification()
         {
             var inputStream = new MemoryStream(Encoding.ASCII.GetBytes("Content-Length: 2\r\n\r\n{}"));
             var outputHandler = Substitute.For<IOutputHandler>();
@@ -234,7 +234,7 @@ public void ShouldHandleNotification()
                         });
                 }))
             {
-                incomingRequestRouter.Received().RouteNotification(notification);
+               await incomingRequestRouter.Received().RouteNotification(notification);
             }
         }
 
diff --git a/test/JsonRpc.Tests/MediatorTestsNotificationHandler.cs b/test/JsonRpc.Tests/MediatorTestsNotificationHandler.cs
@@ -1,4 +1,4 @@
-﻿using System;
+using System;
 using System.Reflection;
 using System.Threading.Tasks;
 using NSubstitute;
@@ -23,10 +23,10 @@ public async Task ExecutesHandler()
 
             var notification = new Notification("exit", null);
 
-            mediator.RouteNotification(notification);
+            await mediator.RouteNotification(notification);
 
             await exitHandler.Received(1).Handle();
         }
 
     }
-}
+}
diff --git a/test/JsonRpc.Tests/MediatorTestsNotificationHandlerOfT.cs b/test/JsonRpc.Tests/MediatorTestsNotificationHandlerOfT.cs
@@ -1,4 +1,4 @@
-﻿using System;
+using System;
 using System.Reflection;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
@@ -33,10 +33,10 @@ public async Task ExecutesHandler()
             var @params = new CancelParams() { Id = Guid.NewGuid() };
             var notification = new Notification("$/cancelRequest", JObject.Parse(JsonConvert.SerializeObject(@params)));
 
-            mediator.RouteNotification(notification);
+            await mediator.RouteNotification(notification);
 
             await cancelRequestHandler.Received(1).Handle(Arg.Any<CancelParams>());
         }
 
     }
-}
+}
diff --git a/test/Lsp.Tests/ClientCapabilityProviderTests.cs b/test/Lsp.Tests/ClientCapabilityProviderTests.cs
@@ -111,7 +111,7 @@ private static bool HasHandler(ClientCapabilityProvider provider, Type type)
         private static bool GenericHasHandler<T>(ClientCapabilityProvider provider, Supports<T> supports)
             where T : DynamicCapability, ConnectedCapability<IJsonRpcHandler>
         {
-            return provider.HasHandler(supports);
+            return provider.HasStaticHandler(supports);
         }
 
         private static IEnumerable<object[]> GetItems<T>(IEnumerable<T> types, Func<T, IEnumerable<object>> func)
diff --git a/test/Lsp.Tests/LspRequestRouterTests.cs b/test/Lsp.Tests/LspRequestRouterTests.cs
@@ -30,7 +30,7 @@ public LspRequestRouterTests(ITestOutputHelper testOutputHelper)
         }
 
         [Fact]
-        public void ShouldRouteToCorrect_Notification()
+        public async Task ShouldRouteToCorrect_Notification()
         {
             var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"));
             textDocumentSyncHandler.Handle(Arg.Any<DidSaveTextDocumentParams>()).Returns(Task.CompletedTask);
@@ -44,13 +44,13 @@ public void ShouldRouteToCorrect_Notification()
 
             var request = new Notification("textDocument/didSave", JObject.Parse(JsonConvert.SerializeObject(@params)));
 
-            mediator.RouteNotification(request);
+            await mediator.RouteNotification(request);
 
-            textDocumentSyncHandler.Received(1).Handle(Arg.Any<DidSaveTextDocumentParams>());
+            await textDocumentSyncHandler.Received(1).Handle(Arg.Any<DidSaveTextDocumentParams>());
         }
 
         [Fact]
-        public void ShouldRouteToCorrect_Notification_WithManyHandlers()
+        public async Task ShouldRouteToCorrect_Notification_WithManyHandlers()
         {
             var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs"));
             var textDocumentSyncHandler2 = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cake"));
@@ -66,10 +66,10 @@ public void ShouldRouteToCorrect_Notification_WithManyHandlers()
 
             var request = new Notification("textDocument/didSave", JObject.Parse(JsonConvert.SerializeObject(@params)));
 
-            mediator.RouteNotification(request);
+            await mediator.RouteNotification(request);
 
-            textDocumentSyncHandler.Received(0).Handle(Arg.Any<DidSaveTextDocumentParams>());
-            textDocumentSyncHandler2.Received(1).Handle(Arg.Any<DidSaveTextDocumentParams>());
+            await textDocumentSyncHandler.Received(0).Handle(Arg.Any<DidSaveTextDocumentParams>());
+            await textDocumentSyncHandler2.Received(1).Handle(Arg.Any<DidSaveTextDocumentParams>());
         }
 
         [Fact]
diff --git a/vscode-testextension/src/extension.ts b/vscode-testextension/src/extension.ts

Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,12 @@`
`1`		`-using System;`
	`1`	`+using System;`
`2`	`2`	`using System.Threading.Tasks;`
`3`	`3`	`using OmniSharp.Extensions.JsonRpc.Server;`
`4`	`4`
`5`	`5`	`namespace OmniSharp.Extensions.JsonRpc`
`6`	`6`	`{`
`7`	`7`	`public interface IRequestRouter`
`8`	`8`	`{`
`9`		`- void RouteNotification(Notification notification);`
	`9`	`+ Task RouteNotification(Notification notification);`
`10`	`10`	`Task<ErrorResponse> RouteRequest(Request request);`
`11`	`11`	`}`
`12`	`12`	`}`
Original file line number	Diff line number	Diff line change
`@@ -190,10 +190,10 @@ private void HandleRequest(string request)`
`190`	`190`	`_scheduler.Add(`
`191`	`191`	`type,`
`192`	`192`	`item.Notification.Method,`
`193`		`- () => {`
	`193`	`+ async () => {`
`194`	`194`	`try`
`195`	`195`	`{`
`196`		`- _requestRouter.RouteNotification(item.Notification);`
	`196`	`+ await _requestRouter.RouteNotification(item.Notification);`
`197`	`197`	`}`
`198`	`198`	`catch (Exception e)`
`199`	`199`	`{`
`@@ -202,7 +202,6 @@ private void HandleRequest(string request)`
`202`	`202`	`// If an exception happens... the whole system could be in a bad state, hence this throwing currently.`
`203`	`203`	`throw;`
`204`	`204`	`}`
`205`		`- return Task.CompletedTask;`
`206`	`205`	`}`
`207`	`206`	`);`
`208`	`207`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-using System;`
	`1`	`+using System;`
`2`	`2`	`using System.Collections.Concurrent;`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using System.Threading;`
`@@ -128,7 +128,7 @@ public void Dispose()`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
`131`		`- static class Events`
	`131`	`+ public static class Events`
`132`	`132`	`{`
`133`	`133`	`public static EventId UnhandledException = new EventId(1337_100);`
`134`	`134`	`public static EventId UnhandledRequest = new EventId(1337_101);`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ public IDisposable Add(IJsonRpcHandler handler)`
`22`	`22`	`return _collection.Add(handler);`
`23`	`23`	`}`
`24`	`24`
`25`		`- public async void RouteNotification(Notification notification)`
	`25`	`+ public async Task RouteNotification(Notification notification)`
`26`	`26`	`{`
`27`	`27`	`var handler = _collection.FirstOrDefault(x => x.Method == notification.Method);`
`28`	`28`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public ClientCapabilityProvider(IHandlerCollection collection)`
`16`	`16`	`_collection = collection;`
`17`	`17`	`}`
`18`	`18`
`19`		`- public bool HasHandler<T>(Supports<T> capability)`
	`19`	`+ public bool HasStaticHandler<T>(Supports<T> capability)`
`20`	`20`	`where T : DynamicCapability, ConnectedCapability<IJsonRpcHandler>`
`21`	`21`	`{`
`22`	`22`	`if (!capability.IsSupported) return false;`
`@@ -26,13 +26,16 @@ public bool HasHandler<T>(Supports<T> capability)`
`26`	`26`	`var handlerType = typeof(T).GetTypeInfo().ImplementedInterfaces`
`27`	`27`	`.Single(x => x.GetTypeInfo().IsGenericType && x.GetTypeInfo().GetGenericTypeDefinition() == typeof(ConnectedCapability<>))`
`28`	`28`	`.GetTypeInfo().GetGenericArguments()[0].GetTypeInfo();`
`29`		`- return !capability.Value.DynamicRegistration && _collection.Any(z => z.HandlerType.GetTypeInfo().IsAssignableFrom(handlerType));`
	`29`	`+ return !capability.Value.DynamicRegistration &&`
	`30`	`+ _collection.Any(z =>`
	`31`	`+ z.HandlerType.GetTypeInfo().IsAssignableFrom(handlerType) \|\|`
	`32`	`+ z.Handler.GetType().GetTypeInfo().IsAssignableFrom(handlerType));`
`30`	`33`	`}`
`31`	`34`
`32`		`- public IOptionsGetter GetOptions<T>(Supports<T> capability)`
	`35`	`+ public IOptionsGetter GetStaticOptions<T>(Supports<T> capability)`
`33`	`36`	`where T : DynamicCapability, ConnectedCapability<IJsonRpcHandler>`
`34`	`37`	`{`
`35`		`- return !HasHandler(capability) ? Null : new OptionsGetter(_collection);`
	`38`	`+ return !HasStaticHandler(capability) ? Null : new OptionsGetter(_collection);`
`36`	`39`	`}`
`37`	`40`
`38`	`41`	`private static readonly IOptionsGetter Null = new NullOptionsGetter();`
Original file line number	Diff line number	Diff line change
`@@ -206,7 +206,7 @@ public void ShouldHandleError()`
`206`	`206`	`}`
`207`	`207`
`208`	`208`	`[Fact]`
`209`		`- public void ShouldHandleNotification()`
	`209`	`+ public async Task ShouldHandleNotification()`
`210`	`210`	`{`
`211`	`211`	`var inputStream = new MemoryStream(Encoding.ASCII.GetBytes("Content-Length: 2\r\n\r\n{}"));`
`212`	`212`	`var outputHandler = Substitute.For<IOutputHandler>();`
`@@ -234,7 +234,7 @@ public void ShouldHandleNotification()`
`234`	`234`	`});`
`235`	`235`	`}))`
`236`	`236`	`{`
`237`		`- incomingRequestRouter.Received().RouteNotification(notification);`
	`237`	`+ await incomingRequestRouter.Received().RouteNotification(notification);`
`238`	`238`	`}`
`239`	`239`	`}`
`240`	`240`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ private static bool HasHandler(ClientCapabilityProvider provider, Type type)`
`111`	`111`	`private static bool GenericHasHandler<T>(ClientCapabilityProvider provider, Supports<T> supports)`
`112`	`112`	`where T : DynamicCapability, ConnectedCapability<IJsonRpcHandler>`
`113`	`113`	`{`
`114`		`- return provider.HasHandler(supports);`
	`114`	`+ return provider.HasStaticHandler(supports);`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`private static IEnumerable<object[]> GetItems<T>(IEnumerable<T> types, Func<T, IEnumerable<object>> func)`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public LspRequestRouterTests(ITestOutputHelper testOutputHelper)`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`[Fact]`
`33`		`- public void ShouldRouteToCorrect_Notification()`
	`33`	`+ public async Task ShouldRouteToCorrect_Notification()`
`34`	`34`	`{`
`35`	`35`	`var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("*/.cs"));`
`36`	`36`	`textDocumentSyncHandler.Handle(Arg.Any<DidSaveTextDocumentParams>()).Returns(Task.CompletedTask);`
`@@ -44,13 +44,13 @@ public void ShouldRouteToCorrect_Notification()`
`44`	`44`
`45`	`45`	`var request = new Notification("textDocument/didSave", JObject.Parse(JsonConvert.SerializeObject(@params)));`
`46`	`46`
`47`		`- mediator.RouteNotification(request);`
	`47`	`+ await mediator.RouteNotification(request);`
`48`	`48`
`49`		`- textDocumentSyncHandler.Received(1).Handle(Arg.Any<DidSaveTextDocumentParams>());`
	`49`	`+ await textDocumentSyncHandler.Received(1).Handle(Arg.Any<DidSaveTextDocumentParams>());`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`[Fact]`
`53`		`- public void ShouldRouteToCorrect_Notification_WithManyHandlers()`
	`53`	`+ public async Task ShouldRouteToCorrect_Notification_WithManyHandlers()`
`54`	`54`	`{`
`55`	`55`	`var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("*/.cs"));`
`56`	`56`	`var textDocumentSyncHandler2 = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("*/.cake"));`
`@@ -66,10 +66,10 @@ public void ShouldRouteToCorrect_Notification_WithManyHandlers()`
`66`	`66`
`67`	`67`	`var request = new Notification("textDocument/didSave", JObject.Parse(JsonConvert.SerializeObject(@params)));`
`68`	`68`
`69`		`- mediator.RouteNotification(request);`
	`69`	`+ await mediator.RouteNotification(request);`
`70`	`70`
`71`		`- textDocumentSyncHandler.Received(0).Handle(Arg.Any<DidSaveTextDocumentParams>());`
`72`		`- textDocumentSyncHandler2.Received(1).Handle(Arg.Any<DidSaveTextDocumentParams>());`
	`71`	`+ await textDocumentSyncHandler.Received(0).Handle(Arg.Any<DidSaveTextDocumentParams>());`
	`72`	`+ await textDocumentSyncHandler2.Received(1).Handle(Arg.Any<DidSaveTextDocumentParams>());`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`[Fact]`