From 747e1bb8552b334e69217646867768c9594a43d4 Mon Sep 17 00:00:00 2001 From: David Driscoll Date: Wed, 18 Oct 2017 14:53:48 -0400 Subject: [PATCH 1/4] Updated capabilities to indiciate which handler they are tied too, this helps update the HasHandler logic. In addition extracted HasHandler out into a unit testable class. --- .../Client/CodeActionCapability.cs | 7 +- .../Capabilities/Client/CodeLensCapability.cs | 7 +- .../Client/CompletionCapability.cs | 6 +- .../Client/ConnectedCapability.cs | 8 ++ .../Client/DefinitionCapability.cs | 6 +- .../Client/DocumentFormattingCapability.cs | 6 +- .../Client/DocumentHighlightCapability.cs | 6 +- .../Client/DocumentLinkCapability.cs | 6 +- .../DocumentOnTypeFormattingCapability.cs | 6 +- .../DocumentRangeFormattingCapability.cs | 6 +- .../Client/DocumentSymbolCapability.cs | 6 +- .../Client/ExecuteCommandCapability.cs | 6 +- .../Capabilities/Client/HoverCapability.cs | 6 +- .../Client/ReferencesCapability.cs | 6 +- .../Capabilities/Client/RenameCapability.cs | 6 +- .../Client/SignatureHelpCapability.cs | 6 +- .../Client/WorkspaceSymbolCapability.cs | 6 +- src/Lsp/ClientCapabilityProvider.cs | 73 ++++++++++ src/Lsp/HandlerCollection.cs | 6 +- src/Lsp/HandlerDescriptor.cs | 12 +- src/Lsp/LanguageServer.cs | 100 ++++++-------- src/Lsp/Lsp.csproj | 5 + ...rTestsRequestHandlerOfTRequestTResponse.cs | 37 ----- test/Lsp.Tests/TestLoggerFactory.cs | 126 ++++++++++++++++++ .../TextDocumentSyncHandlerExtensions.cs | 44 ++++++ 25 files changed, 371 insertions(+), 138 deletions(-) create mode 100644 src/Lsp/Capabilities/Client/ConnectedCapability.cs create mode 100644 src/Lsp/ClientCapabilityProvider.cs create mode 100644 test/Lsp.Tests/TextDocumentSyncHandlerExtensions.cs diff --git a/src/Lsp/Capabilities/Client/CodeActionCapability.cs b/src/Lsp/Capabilities/Client/CodeActionCapability.cs index 1a1665ec8..dbb01f2cc 100644 --- a/src/Lsp/Capabilities/Client/CodeActionCapability.cs +++ b/src/Lsp/Capabilities/Client/CodeActionCapability.cs @@ -1,4 +1,7 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Abstractions; +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class CodeActionCapability : DynamicCapability { } + public class CodeActionCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/CodeLensCapability.cs b/src/Lsp/Capabilities/Client/CodeLensCapability.cs index bb8248bcb..881153dd1 100644 --- a/src/Lsp/Capabilities/Client/CodeLensCapability.cs +++ b/src/Lsp/Capabilities/Client/CodeLensCapability.cs @@ -1,4 +1,7 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Capabilities.Server; +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class CodeLensCapability : DynamicCapability { } + public class CodeLensCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/CompletionCapability.cs b/src/Lsp/Capabilities/Client/CompletionCapability.cs index eee3874c9..95cd2296e 100644 --- a/src/Lsp/Capabilities/Client/CompletionCapability.cs +++ b/src/Lsp/Capabilities/Client/CompletionCapability.cs @@ -1,6 +1,8 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class CompletionCapability : DynamicCapability + public class CompletionCapability : DynamicCapability, ConnectedCapability { /// /// The client supports the following `CompletionItem` specific diff --git a/src/Lsp/Capabilities/Client/ConnectedCapability.cs b/src/Lsp/Capabilities/Client/ConnectedCapability.cs new file mode 100644 index 000000000..d0da8dccc --- /dev/null +++ b/src/Lsp/Capabilities/Client/ConnectedCapability.cs @@ -0,0 +1,8 @@ +using OmniSharp.Extensions.JsonRpc; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +{ + internal interface ConnectedCapability + where T : IJsonRpcHandler + { } +} diff --git a/src/Lsp/Capabilities/Client/DefinitionCapability.cs b/src/Lsp/Capabilities/Client/DefinitionCapability.cs index 5b3424c46..ad4337b2e 100644 --- a/src/Lsp/Capabilities/Client/DefinitionCapability.cs +++ b/src/Lsp/Capabilities/Client/DefinitionCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class DefinitionCapability : DynamicCapability { } + public class DefinitionCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/DocumentFormattingCapability.cs b/src/Lsp/Capabilities/Client/DocumentFormattingCapability.cs index a00372353..1b6b4828a 100644 --- a/src/Lsp/Capabilities/Client/DocumentFormattingCapability.cs +++ b/src/Lsp/Capabilities/Client/DocumentFormattingCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class DocumentFormattingCapability : DynamicCapability { } + public class DocumentFormattingCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/DocumentHighlightCapability.cs b/src/Lsp/Capabilities/Client/DocumentHighlightCapability.cs index 8c708b892..8f6e9ec7c 100644 --- a/src/Lsp/Capabilities/Client/DocumentHighlightCapability.cs +++ b/src/Lsp/Capabilities/Client/DocumentHighlightCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class DocumentHighlightCapability : DynamicCapability { } + public class DocumentHighlightCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/DocumentLinkCapability.cs b/src/Lsp/Capabilities/Client/DocumentLinkCapability.cs index d535cb122..4544edc96 100644 --- a/src/Lsp/Capabilities/Client/DocumentLinkCapability.cs +++ b/src/Lsp/Capabilities/Client/DocumentLinkCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class DocumentLinkCapability : DynamicCapability { } + public class DocumentLinkCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/DocumentOnTypeFormattingCapability.cs b/src/Lsp/Capabilities/Client/DocumentOnTypeFormattingCapability.cs index 7102b5bc8..95b98912e 100644 --- a/src/Lsp/Capabilities/Client/DocumentOnTypeFormattingCapability.cs +++ b/src/Lsp/Capabilities/Client/DocumentOnTypeFormattingCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class DocumentOnTypeFormattingCapability : DynamicCapability { } + public class DocumentOnTypeFormattingCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/DocumentRangeFormattingCapability.cs b/src/Lsp/Capabilities/Client/DocumentRangeFormattingCapability.cs index fb093fedd..0919735ab 100644 --- a/src/Lsp/Capabilities/Client/DocumentRangeFormattingCapability.cs +++ b/src/Lsp/Capabilities/Client/DocumentRangeFormattingCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol.Document; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class DocumentRangeFormattingCapability : DynamicCapability { } + public class DocumentRangeFormattingCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/DocumentSymbolCapability.cs b/src/Lsp/Capabilities/Client/DocumentSymbolCapability.cs index 73902270e..ac747e53a 100644 --- a/src/Lsp/Capabilities/Client/DocumentSymbolCapability.cs +++ b/src/Lsp/Capabilities/Client/DocumentSymbolCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class DocumentSymbolCapability : DynamicCapability { } + public class DocumentSymbolCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/ExecuteCommandCapability.cs b/src/Lsp/Capabilities/Client/ExecuteCommandCapability.cs index dea993933..c798b34a6 100644 --- a/src/Lsp/Capabilities/Client/ExecuteCommandCapability.cs +++ b/src/Lsp/Capabilities/Client/ExecuteCommandCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class ExecuteCommandCapability : DynamicCapability { } + public class ExecuteCommandCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/HoverCapability.cs b/src/Lsp/Capabilities/Client/HoverCapability.cs index d8ce78271..de996d043 100644 --- a/src/Lsp/Capabilities/Client/HoverCapability.cs +++ b/src/Lsp/Capabilities/Client/HoverCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class HoverCapability : DynamicCapability { } + public class HoverCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/ReferencesCapability.cs b/src/Lsp/Capabilities/Client/ReferencesCapability.cs index cb7a66c39..17d34f7c8 100644 --- a/src/Lsp/Capabilities/Client/ReferencesCapability.cs +++ b/src/Lsp/Capabilities/Client/ReferencesCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class ReferencesCapability : DynamicCapability { } + public class ReferencesCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/RenameCapability.cs b/src/Lsp/Capabilities/Client/RenameCapability.cs index 06665c192..8f7395e38 100644 --- a/src/Lsp/Capabilities/Client/RenameCapability.cs +++ b/src/Lsp/Capabilities/Client/RenameCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class RenameCapability : DynamicCapability { } + public class RenameCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/SignatureHelpCapability.cs b/src/Lsp/Capabilities/Client/SignatureHelpCapability.cs index 9635d37ce..c181ee674 100644 --- a/src/Lsp/Capabilities/Client/SignatureHelpCapability.cs +++ b/src/Lsp/Capabilities/Client/SignatureHelpCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class SignatureHelpCapability : DynamicCapability { } + public class SignatureHelpCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/Capabilities/Client/WorkspaceSymbolCapability.cs b/src/Lsp/Capabilities/Client/WorkspaceSymbolCapability.cs index 605e0bb81..56ed3a3f5 100644 --- a/src/Lsp/Capabilities/Client/WorkspaceSymbolCapability.cs +++ b/src/Lsp/Capabilities/Client/WorkspaceSymbolCapability.cs @@ -1,4 +1,6 @@ -namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client +using OmniSharp.Extensions.LanguageServer.Protocol; + +namespace OmniSharp.Extensions.LanguageServer.Capabilities.Client { - public class WorkspaceSymbolCapability : DynamicCapability { } + public class WorkspaceSymbolCapability : DynamicCapability, ConnectedCapability { } } diff --git a/src/Lsp/ClientCapabilityProvider.cs b/src/Lsp/ClientCapabilityProvider.cs new file mode 100644 index 000000000..e131135d2 --- /dev/null +++ b/src/Lsp/ClientCapabilityProvider.cs @@ -0,0 +1,73 @@ +using System; +using System.Linq; +using System.Reflection; +using OmniSharp.Extensions.JsonRpc; +using OmniSharp.Extensions.LanguageServer.Abstractions; +using OmniSharp.Extensions.LanguageServer.Capabilities.Client; + +namespace OmniSharp.Extensions.LanguageServer +{ + internal class ClientCapabilityProvider + { + private readonly IHandlerCollection _collection; + + public ClientCapabilityProvider(IHandlerCollection collection) + { + _collection = collection; + } + + public bool HasHandler(Supports capability) + where T : DynamicCapability, ConnectedCapability + { + if (!capability.IsSupported) return false; + if (capability.Value == null) return false; + if (capability.Value.DynamicRegistration) return false; + + 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)); + } + + public IOptionsGetter GetOptions(Supports capability) + where T : DynamicCapability, ConnectedCapability + { + return !HasHandler(capability) ? Null : new OptionsGetter(_collection); + } + + private static readonly IOptionsGetter Null = new NullOptionsGetter(); + + public interface IOptionsGetter + { + TOptions Get(Func action) + where TOptions : class; + } + + private class NullOptionsGetter : IOptionsGetter + { + public TOptions Get(Func action) + where TOptions : class + { + return null; + } + } + + private class OptionsGetter : IOptionsGetter + { + private readonly IHandlerCollection _collection; + + public OptionsGetter(IHandlerCollection collection) + { + _collection = collection; + } + + public TOptions Get(Func action) + where TOptions : class + { + return _collection + .Select(x => x.Registration?.RegisterOptions is TInterface cl ? action(cl) : null) + .FirstOrDefault(x => x != null); + } + } + } +} diff --git a/src/Lsp/HandlerCollection.cs b/src/Lsp/HandlerCollection.cs index 5203f58cd..f35beb99a 100644 --- a/src/Lsp/HandlerCollection.cs +++ b/src/Lsp/HandlerCollection.cs @@ -50,10 +50,10 @@ public IDisposable Add(params IJsonRpcHandler[] handlers) var key = "default"; if (handler is IRegistration) { - var options = GetTextDocumentRegistrationOptionsMethod + if (GetTextDocumentRegistrationOptionsMethod .MakeGenericMethod(registration) - .Invoke(handler, new object[] { handler }) as TextDocumentRegistrationOptions; - key = options.DocumentSelector; + .Invoke(handler, new object[] { handler }) is TextDocumentRegistrationOptions options) + key = options.DocumentSelector; } var h = new HandlerDescriptor( diff --git a/src/Lsp/HandlerDescriptor.cs b/src/Lsp/HandlerDescriptor.cs index 8d3059924..3f94846ab 100644 --- a/src/Lsp/HandlerDescriptor.cs +++ b/src/Lsp/HandlerDescriptor.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Reflection; using OmniSharp.Extensions.JsonRpc; using OmniSharp.Extensions.LanguageServer.Abstractions; @@ -59,17 +59,17 @@ public Registration Registration public void SetCapability(object instance) { + if (instance is DynamicCapability dc) + { + AllowsDynamicRegistration = dc.DynamicRegistration; + } + // TODO: Cache this GetType() .GetTypeInfo() .GetMethod(nameof(SetCapability), BindingFlags.NonPublic | BindingFlags.Static) .MakeGenericMethod(CapabilityType) .Invoke(this, new[] { Handler, instance }); - - if (instance is DynamicCapability dc) - { - AllowsDynamicRegistration = dc.DynamicRegistration; - } } public string Method { get; } diff --git a/src/Lsp/LanguageServer.cs b/src/Lsp/LanguageServer.cs index 96723b0cd..e51164afe 100644 --- a/src/Lsp/LanguageServer.cs +++ b/src/Lsp/LanguageServer.cs @@ -5,6 +5,7 @@ using System.Reflection; using System.Threading; using System.Threading.Tasks; +using FluentAssertions; using OmniSharp.Extensions.LanguageServer.Protocol; using Newtonsoft.Json.Linq; using OmniSharp.Extensions.JsonRpc; @@ -75,8 +76,7 @@ public IDisposable AddHandlers(params IJsonRpcHandler[] handlers) return new ImmutableDisposable( handlerDisposable, - new Disposable(() => - { + new Disposable(() => { var foundItems = handlers .SelectMany(handler => _collection .Where(x => handler == x.Handler) @@ -85,8 +85,7 @@ public IDisposable AddHandlers(params IJsonRpcHandler[] handlers) .Where(x => x != null)) .ToArray(); - Task.Run(() => this.UnregisterCapability(new UnregistrationParams() - { + Task.Run(() => this.UnregisterCapability(new UnregistrationParams() { Unregisterations = foundItems })); })); @@ -129,39 +128,49 @@ async Task IRequestHandler var textDocumentCapabilities = Client.Capabilities.TextDocument; var workspaceCapabilities = Client.Capabilities.Workspace; - var serverCapabilities = new ServerCapabilities() - { - CodeActionProvider = HasHandler(textDocumentCapabilities.CodeAction), - CodeLensProvider = GetOptions(textDocumentCapabilities.CodeLens, CodeLensOptions.Of), - CompletionProvider = GetOptions(textDocumentCapabilities.Completion, CompletionOptions.Of), - DefinitionProvider = HasHandler(textDocumentCapabilities.Definition), - DocumentFormattingProvider = HasHandler(textDocumentCapabilities.Formatting), - DocumentHighlightProvider = HasHandler(textDocumentCapabilities.DocumentHighlight), - DocumentLinkProvider = GetOptions(textDocumentCapabilities.DocumentLink, DocumentLinkOptions.Of), - DocumentOnTypeFormattingProvider = GetOptions(textDocumentCapabilities.OnTypeFormatting, DocumentOnTypeFormattingOptions.Of), - DocumentRangeFormattingProvider = HasHandler(textDocumentCapabilities.RangeFormatting), - DocumentSymbolProvider = HasHandler(textDocumentCapabilities.DocumentSymbol), - ExecuteCommandProvider = GetOptions(workspaceCapabilities.ExecuteCommand, ExecuteCommandOptions.Of), - HoverProvider = HasHandler(textDocumentCapabilities.Hover), - ReferencesProvider = HasHandler(textDocumentCapabilities.References), - RenameProvider = HasHandler(textDocumentCapabilities.Rename), - SignatureHelpProvider = GetOptions(textDocumentCapabilities.SignatureHelp, SignatureHelpOptions.Of), - WorkspaceSymbolProvider = HasHandler(workspaceCapabilities.Symbol) + var ccp = new ClientCapabilityProvider(_collection); + + var serverCapabilities = new ServerCapabilities() { + CodeActionProvider = ccp.HasHandler(textDocumentCapabilities.CodeAction), + CodeLensProvider = ccp.GetOptions(textDocumentCapabilities.CodeLens).Get(CodeLensOptions.Of), + CompletionProvider = ccp.GetOptions(textDocumentCapabilities.Completion).Get(CompletionOptions.Of), + DefinitionProvider = ccp.HasHandler(textDocumentCapabilities.Definition), + DocumentFormattingProvider = ccp.HasHandler(textDocumentCapabilities.Formatting), + DocumentHighlightProvider = ccp.HasHandler(textDocumentCapabilities.DocumentHighlight), + DocumentLinkProvider = ccp.GetOptions(textDocumentCapabilities.DocumentLink).Get(DocumentLinkOptions.Of), + DocumentOnTypeFormattingProvider = ccp.GetOptions(textDocumentCapabilities.OnTypeFormatting).Get(DocumentOnTypeFormattingOptions.Of), + DocumentRangeFormattingProvider = ccp.HasHandler(textDocumentCapabilities.RangeFormatting), + DocumentSymbolProvider = ccp.HasHandler(textDocumentCapabilities.DocumentSymbol), + ExecuteCommandProvider = ccp.GetOptions(workspaceCapabilities.ExecuteCommand).Get(ExecuteCommandOptions.Of), + HoverProvider = ccp.HasHandler(textDocumentCapabilities.Hover), + ReferencesProvider = ccp.HasHandler(textDocumentCapabilities.References), + RenameProvider = ccp.HasHandler(textDocumentCapabilities.Rename), + SignatureHelpProvider = ccp.GetOptions(textDocumentCapabilities.SignatureHelp).Get(SignatureHelpOptions.Of), + WorkspaceSymbolProvider = ccp.HasHandler(workspaceCapabilities.Symbol) }; - var textSyncHandler = _collection + var textSyncHandlers = _collection .Select(x => x.Handler) .OfType() - .FirstOrDefault(); + .ToArray(); if (_clientVersion == ClientVersion.Lsp2) { - serverCapabilities.TextDocumentSync = textSyncHandler?.Options.Change ?? TextDocumentSyncKind.None; + if (textSyncHandlers.Any()) + { + serverCapabilities.TextDocumentSync = textSyncHandlers + .Where(x => x.Options.Change != TextDocumentSyncKind.None) + .Min(z => z.Options.Change); + } + else + { + serverCapabilities.TextDocumentSync = TextDocumentSyncKind.None; + } } else { - serverCapabilities.TextDocumentSync = textSyncHandler?.Options ?? new TextDocumentSyncOptions() - { + // TODO: Merge options + serverCapabilities.TextDocumentSync = textSyncHandlers.FirstOrDefault()?.Options ?? new TextDocumentSyncOptions() { Change = TextDocumentSyncKind.None, OpenClose = false, Save = new SaveOptions() { IncludeText = false }, @@ -201,34 +210,6 @@ public Task Handle() return Task.CompletedTask; } - private bool HasHandler(DynamicCapability capability) - { - return capability.DynamicRegistration ? false : _collection.Any(z => z.Handler is T); - } - - private bool HasHandler(Supports capability) - { - if (!capability.IsSupported) return false; - return HasHandler(capability.Value); - } - - private T GetOptions(DynamicCapability capability, Func action) - where T : class - { - if (capability.DynamicRegistration) return null; - - return _collection - .Select(x => x.Registration?.RegisterOptions is O cl ? action(cl) : null) - .FirstOrDefault(x => x != null); - } - - private T GetOptions(Supports capability, Func action) - where T : class - { - if (!capability.IsSupported) return null; - return GetOptions(capability.Value, action); - } - private void ProcessCapabilties(object instance) { var values = instance @@ -250,11 +231,10 @@ private void ProcessCapabilties(object instance) private async Task DynamicallyRegisterHandlers() { - var registrations = new List(); - foreach (var handler in _collection.Where(x => x.AllowsDynamicRegistration)) - { - registrations.Add(handler.Registration); - } + var registrations = _collection + .Where(x => x.AllowsDynamicRegistration) + .Select(handler => handler.Registration) + .ToList(); if (registrations.Count == 0) return; // No dynamic registrations supported by client. diff --git a/src/Lsp/Lsp.csproj b/src/Lsp/Lsp.csproj index 93a8bbcef..f3370a6e6 100644 --- a/src/Lsp/Lsp.csproj +++ b/src/Lsp/Lsp.csproj @@ -10,4 +10,9 @@ + + + ..\..\..\..\Users\ddriscoll\.nuget\packages\fluentassertions\4.19.4\lib\net45\FluentAssertions.dll + + diff --git a/test/Lsp.Tests/MediatorTestsRequestHandlerOfTRequestTResponse.cs b/test/Lsp.Tests/MediatorTestsRequestHandlerOfTRequestTResponse.cs index b092eb131..5df0280b0 100644 --- a/test/Lsp.Tests/MediatorTestsRequestHandlerOfTRequestTResponse.cs +++ b/test/Lsp.Tests/MediatorTestsRequestHandlerOfTRequestTResponse.cs @@ -12,51 +12,14 @@ using NSubstitute; using OmniSharp.Extensions.JsonRpc.Server; using OmniSharp.Extensions.LanguageServer; -using OmniSharp.Extensions.LanguageServer.Abstractions; using OmniSharp.Extensions.LanguageServer.Messages; using OmniSharp.Extensions.LanguageServer.Models; -using OmniSharp.Extensions.LanguageServer.Protocol.Document; using Xunit; using Xunit.Sdk; using HandlerCollection = OmniSharp.Extensions.LanguageServer.HandlerCollection; namespace Lsp.Tests { - static class TextDocumentSyncHandlerExtensions - { - public static ITextDocumentSyncHandler With(DocumentSelector documentSelector) - { - return Substitute.For().With(documentSelector); - } - - public static ITextDocumentSyncHandler With(this ITextDocumentSyncHandler handler, DocumentSelector documentSelector) - { - ((IDidChangeTextDocumentHandler)handler).GetRegistrationOptions().Returns(new TextDocumentChangeRegistrationOptions() { DocumentSelector = documentSelector }); - ((IDidOpenTextDocumentHandler)handler).GetRegistrationOptions().Returns(new TextDocumentRegistrationOptions() { DocumentSelector = documentSelector }); - ((IDidCloseTextDocumentHandler)handler).GetRegistrationOptions().Returns(new TextDocumentRegistrationOptions() { DocumentSelector = documentSelector }); - ((IDidSaveTextDocumentHandler)handler).GetRegistrationOptions().Returns(new TextDocumentSaveRegistrationOptions() { DocumentSelector = documentSelector }); - - handler - .GetTextDocumentAttributes(Arg.Is(x => documentSelector.IsMatch(new TextDocumentAttributes(x, "")))) - .Returns(c => new TextDocumentAttributes(c.Arg(), "")); - - return handler; - } - - private static void For(this ITextDocumentSyncHandler handler, DocumentSelector documentSelector) - where T : class, IRegistration - { - var me = handler as T; - me.GetRegistrationOptions().Returns(GetOptions(me, documentSelector)); - } - - private static TextDocumentRegistrationOptions GetOptions(IRegistration handler, DocumentSelector documentSelector) - where R : TextDocumentRegistrationOptions, new() - { - return new R { DocumentSelector = documentSelector }; - } - } - public class MediatorTestsRequestHandlerOfTRequestTResponse { [Fact] diff --git a/test/Lsp.Tests/TestLoggerFactory.cs b/test/Lsp.Tests/TestLoggerFactory.cs index 120032567..b4c6500b0 100644 --- a/test/Lsp.Tests/TestLoggerFactory.cs +++ b/test/Lsp.Tests/TestLoggerFactory.cs @@ -1,8 +1,20 @@ using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using FluentAssertions; using Microsoft.Extensions.Logging; +using NSubstitute; +using OmniSharp.Extensions.JsonRpc; +using OmniSharp.Extensions.LanguageServer; +using OmniSharp.Extensions.LanguageServer.Abstractions; +using OmniSharp.Extensions.LanguageServer.Capabilities.Client; +using OmniSharp.Extensions.LanguageServer.Models; using Serilog; using Serilog.Extensions.Logging; +using Xunit; using Xunit.Abstractions; +using HandlerCollection = OmniSharp.Extensions.LanguageServer.HandlerCollection; using ILogger = Microsoft.Extensions.Logging.ILogger; namespace Lsp.Tests @@ -30,4 +42,118 @@ void ILoggerFactory.AddProvider(ILoggerProvider provider) { } void IDisposable.Dispose() { } } + + public class ClientCapabilityProviderTests + { + private static Type[] TextDocumentCapabilities = { + typeof(CompletionCapability), + typeof(HoverCapability), + typeof(SignatureHelpCapability), + typeof(ReferencesCapability), + typeof(DocumentHighlightCapability), + typeof(DocumentSymbolCapability), + typeof(DocumentFormattingCapability), + typeof(DocumentRangeFormattingCapability), + typeof(DocumentOnTypeFormattingCapability), + typeof(DefinitionCapability), + typeof(CodeActionCapability), + typeof(CodeLensCapability), + typeof(DocumentLinkCapability), + typeof(RenameCapability), + typeof(WorkspaceSymbolCapability), + typeof(ExecuteCommandCapability), + }; + + [Theory, MemberData(nameof(AllowSupportedCapabilities))] + public void Should_AllowSupportedCapabilities(IJsonRpcHandler handler, object instance) + { + var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs")); + + var collection = new HandlerCollection { textDocumentSyncHandler, handler }; + var provider = new ClientCapabilityProvider(collection); + + HasHandler(provider, instance).Should().BeTrue(); + } + + public static IEnumerable AllowSupportedCapabilities() + { + return GetItems(TextDocumentCapabilities, type => { + var handlerType = GetHandlerType(type); + var handler = Substitute.For(new Type[] { handlerType }, new object[0]); + return new[] { handler, Activator.CreateInstance(typeof(Supports<>).MakeGenericType(type), true, Activator.CreateInstance(type)) }; + }); + } + + [Theory, MemberData(nameof(DisallowUnsupportedCapabilities))] + public void Should_DisallowUnsupportedCapabilities(IJsonRpcHandler handler, object instance) + { + var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs")); + + var collection = new HandlerCollection { textDocumentSyncHandler, handler }; + var provider = new ClientCapabilityProvider(collection); + + HasHandler(provider, instance).Should().BeFalse(); + } + + public static IEnumerable DisallowUnsupportedCapabilities() + { + return GetItems(TextDocumentCapabilities, type => { + var handlerType = GetHandlerType(type); + var handler = Substitute.For(new Type[] { handlerType }, new object[0]); + return new[] { handler, Activator.CreateInstance(typeof(Supports<>).MakeGenericType(type), false) }; + }); + } + + [Theory, MemberData(nameof(DisallowNullSupportsCapabilities))] + public void Should_DisallowNullSupportedCapabilities(IJsonRpcHandler handler, object instance) + { + var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs")); + + var collection = new HandlerCollection { textDocumentSyncHandler, handler }; + var provider = new ClientCapabilityProvider(collection); + + HasHandler(provider, instance).Should().BeFalse(); + } + + public static IEnumerable DisallowNullSupportsCapabilities() + { + return GetItems(TextDocumentCapabilities, type => { + var handlerType = GetHandlerType(type); + var handler = Substitute.For(new Type[] { handlerType }, new object[0]); + return new[] { handler, Activator.CreateInstance(typeof(Supports<>).MakeGenericType(type), true) }; + }); + } + + private static bool HasHandler(ClientCapabilityProvider provider, object instance) + { + return (bool)typeof(ClientCapabilityProviderTests).GetTypeInfo() + .GetMethod(nameof(GenericHasHandler), BindingFlags.Static | BindingFlags.NonPublic) + .MakeGenericMethod(instance.GetType().GetTypeInfo().GetGenericArguments()[0]).Invoke(null, new[] { provider, instance }); + } + + private static bool HasHandler(ClientCapabilityProvider provider, Type type) + { + return (bool)typeof(ClientCapabilityProviderTests).GetTypeInfo() + .GetMethod(nameof(GenericHasHandler), BindingFlags.Static | BindingFlags.NonPublic) + .MakeGenericMethod(type).Invoke(null, new object[] { provider, null }); + } + + private static bool GenericHasHandler(ClientCapabilityProvider provider, Supports supports) + where T : DynamicCapability, ConnectedCapability + { + return provider.HasHandler(supports); + } + + private static IEnumerable GetItems(IEnumerable types, Func> func) + { + return types.Select(x => func(x).ToArray()); + } + + private static Type GetHandlerType(Type type) + { + return type.GetTypeInfo().ImplementedInterfaces + .Single(x => x.GetTypeInfo().IsGenericType && x.GetTypeInfo().GetGenericTypeDefinition() == typeof(ConnectedCapability<>)) + .GetTypeInfo().GetGenericArguments()[0]; + } + } } diff --git a/test/Lsp.Tests/TextDocumentSyncHandlerExtensions.cs b/test/Lsp.Tests/TextDocumentSyncHandlerExtensions.cs new file mode 100644 index 000000000..a8cf698f6 --- /dev/null +++ b/test/Lsp.Tests/TextDocumentSyncHandlerExtensions.cs @@ -0,0 +1,44 @@ +using System; +using NSubstitute; +using OmniSharp.Extensions.LanguageServer.Abstractions; +using OmniSharp.Extensions.LanguageServer.Models; +using OmniSharp.Extensions.LanguageServer.Protocol; +using OmniSharp.Extensions.LanguageServer.Protocol.Document; + +namespace Lsp.Tests +{ + static class TextDocumentSyncHandlerExtensions + { + public static ITextDocumentSyncHandler With(DocumentSelector documentSelector) + { + return Substitute.For().With(documentSelector); + } + + public static ITextDocumentSyncHandler With(this ITextDocumentSyncHandler handler, DocumentSelector documentSelector) + { + ((IDidChangeTextDocumentHandler)handler).GetRegistrationOptions().Returns(new TextDocumentChangeRegistrationOptions() { DocumentSelector = documentSelector }); + ((IDidOpenTextDocumentHandler)handler).GetRegistrationOptions().Returns(new TextDocumentRegistrationOptions() { DocumentSelector = documentSelector }); + ((IDidCloseTextDocumentHandler)handler).GetRegistrationOptions().Returns(new TextDocumentRegistrationOptions() { DocumentSelector = documentSelector }); + ((IDidSaveTextDocumentHandler)handler).GetRegistrationOptions().Returns(new TextDocumentSaveRegistrationOptions() { DocumentSelector = documentSelector }); + + handler + .GetTextDocumentAttributes(Arg.Is(x => documentSelector.IsMatch(new TextDocumentAttributes(x, "")))) + .Returns(c => new TextDocumentAttributes(c.Arg(), "")); + + return handler; + } + + private static void For(this ITextDocumentSyncHandler handler, DocumentSelector documentSelector) + where T : class, IRegistration + { + var me = handler as T; + me.GetRegistrationOptions().Returns(GetOptions(me, documentSelector)); + } + + private static TextDocumentRegistrationOptions GetOptions(IRegistration handler, DocumentSelector documentSelector) + where R : TextDocumentRegistrationOptions, new() + { + return new R { DocumentSelector = documentSelector }; + } + } +} \ No newline at end of file From 61ac2ba79faee6dc51fe9db671b51a6083949767 Mon Sep 17 00:00:00 2001 From: David Driscoll Date: Wed, 18 Oct 2017 14:55:50 -0400 Subject: [PATCH 2/4] moved ClientCapabilityProviderTests to it's own file --- .../ClientCapabilityProviderTests.cs | 129 ++++++++++++++++++ test/Lsp.Tests/TestLoggerFactory.cs | 125 ----------------- 2 files changed, 129 insertions(+), 125 deletions(-) create mode 100644 test/Lsp.Tests/ClientCapabilityProviderTests.cs diff --git a/test/Lsp.Tests/ClientCapabilityProviderTests.cs b/test/Lsp.Tests/ClientCapabilityProviderTests.cs new file mode 100644 index 000000000..8391de310 --- /dev/null +++ b/test/Lsp.Tests/ClientCapabilityProviderTests.cs @@ -0,0 +1,129 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using FluentAssertions; +using NSubstitute; +using OmniSharp.Extensions.JsonRpc; +using OmniSharp.Extensions.LanguageServer; +using OmniSharp.Extensions.LanguageServer.Capabilities.Client; +using OmniSharp.Extensions.LanguageServer.Models; +using Xunit; +using HandlerCollection = OmniSharp.Extensions.LanguageServer.HandlerCollection; + +namespace Lsp.Tests +{ + public class ClientCapabilityProviderTests + { + private static readonly Type[] Capabilities = { + typeof(CompletionCapability), + typeof(HoverCapability), + typeof(SignatureHelpCapability), + typeof(ReferencesCapability), + typeof(DocumentHighlightCapability), + typeof(DocumentSymbolCapability), + typeof(DocumentFormattingCapability), + typeof(DocumentRangeFormattingCapability), + typeof(DocumentOnTypeFormattingCapability), + typeof(DefinitionCapability), + typeof(CodeActionCapability), + typeof(CodeLensCapability), + typeof(DocumentLinkCapability), + typeof(RenameCapability), + typeof(WorkspaceSymbolCapability), + typeof(ExecuteCommandCapability), + }; + + [Theory, MemberData(nameof(AllowSupportedCapabilities))] + public void Should_AllowSupportedCapabilities(IJsonRpcHandler handler, object instance) + { + var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs")); + + var collection = new HandlerCollection { textDocumentSyncHandler, handler }; + var provider = new ClientCapabilityProvider(collection); + + HasHandler(provider, instance).Should().BeTrue(); + } + + public static IEnumerable AllowSupportedCapabilities() + { + return GetItems(Capabilities, type => { + var handlerType = GetHandlerType(type); + var handler = Substitute.For(new Type[] { handlerType }, new object[0]); + return new[] { handler, Activator.CreateInstance(typeof(Supports<>).MakeGenericType(type), true, Activator.CreateInstance(type)) }; + }); + } + + [Theory, MemberData(nameof(DisallowUnsupportedCapabilities))] + public void Should_DisallowUnsupportedCapabilities(IJsonRpcHandler handler, object instance) + { + var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs")); + + var collection = new HandlerCollection { textDocumentSyncHandler, handler }; + var provider = new ClientCapabilityProvider(collection); + + HasHandler(provider, instance).Should().BeFalse(); + } + + public static IEnumerable DisallowUnsupportedCapabilities() + { + return GetItems(Capabilities, type => { + var handlerType = GetHandlerType(type); + var handler = Substitute.For(new Type[] { handlerType }, new object[0]); + return new[] { handler, Activator.CreateInstance(typeof(Supports<>).MakeGenericType(type), false) }; + }); + } + + [Theory, MemberData(nameof(DisallowNullSupportsCapabilities))] + public void Should_DisallowNullSupportedCapabilities(IJsonRpcHandler handler, object instance) + { + var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs")); + + var collection = new HandlerCollection { textDocumentSyncHandler, handler }; + var provider = new ClientCapabilityProvider(collection); + + HasHandler(provider, instance).Should().BeFalse(); + } + + public static IEnumerable DisallowNullSupportsCapabilities() + { + return GetItems(Capabilities, type => { + var handlerType = GetHandlerType(type); + var handler = Substitute.For(new Type[] { handlerType }, new object[0]); + return new[] { handler, Activator.CreateInstance(typeof(Supports<>).MakeGenericType(type), true) }; + }); + } + + private static bool HasHandler(ClientCapabilityProvider provider, object instance) + { + return (bool)typeof(ClientCapabilityProviderTests).GetTypeInfo() + .GetMethod(nameof(GenericHasHandler), BindingFlags.Static | BindingFlags.NonPublic) + .MakeGenericMethod(instance.GetType().GetTypeInfo().GetGenericArguments()[0]).Invoke(null, new[] { provider, instance }); + } + + private static bool HasHandler(ClientCapabilityProvider provider, Type type) + { + return (bool)typeof(ClientCapabilityProviderTests).GetTypeInfo() + .GetMethod(nameof(GenericHasHandler), BindingFlags.Static | BindingFlags.NonPublic) + .MakeGenericMethod(type).Invoke(null, new object[] { provider, null }); + } + + private static bool GenericHasHandler(ClientCapabilityProvider provider, Supports supports) + where T : DynamicCapability, ConnectedCapability + { + return provider.HasHandler(supports); + } + + private static IEnumerable GetItems(IEnumerable types, Func> func) + { + return types.Select(x => func(x).ToArray()); + } + + private static Type GetHandlerType(Type type) + { + return type.GetTypeInfo().ImplementedInterfaces + .Single(x => x.GetTypeInfo().IsGenericType && x.GetTypeInfo().GetGenericTypeDefinition() == typeof(ConnectedCapability<>)) + .GetTypeInfo().GetGenericArguments()[0]; + } + } +} diff --git a/test/Lsp.Tests/TestLoggerFactory.cs b/test/Lsp.Tests/TestLoggerFactory.cs index b4c6500b0..5aefbfb57 100644 --- a/test/Lsp.Tests/TestLoggerFactory.cs +++ b/test/Lsp.Tests/TestLoggerFactory.cs @@ -1,20 +1,9 @@ using System; -using System.Collections.Generic; -using System.Linq; -using System.Reflection; -using FluentAssertions; using Microsoft.Extensions.Logging; -using NSubstitute; -using OmniSharp.Extensions.JsonRpc; -using OmniSharp.Extensions.LanguageServer; using OmniSharp.Extensions.LanguageServer.Abstractions; -using OmniSharp.Extensions.LanguageServer.Capabilities.Client; -using OmniSharp.Extensions.LanguageServer.Models; using Serilog; using Serilog.Extensions.Logging; -using Xunit; using Xunit.Abstractions; -using HandlerCollection = OmniSharp.Extensions.LanguageServer.HandlerCollection; using ILogger = Microsoft.Extensions.Logging.ILogger; namespace Lsp.Tests @@ -42,118 +31,4 @@ void ILoggerFactory.AddProvider(ILoggerProvider provider) { } void IDisposable.Dispose() { } } - - public class ClientCapabilityProviderTests - { - private static Type[] TextDocumentCapabilities = { - typeof(CompletionCapability), - typeof(HoverCapability), - typeof(SignatureHelpCapability), - typeof(ReferencesCapability), - typeof(DocumentHighlightCapability), - typeof(DocumentSymbolCapability), - typeof(DocumentFormattingCapability), - typeof(DocumentRangeFormattingCapability), - typeof(DocumentOnTypeFormattingCapability), - typeof(DefinitionCapability), - typeof(CodeActionCapability), - typeof(CodeLensCapability), - typeof(DocumentLinkCapability), - typeof(RenameCapability), - typeof(WorkspaceSymbolCapability), - typeof(ExecuteCommandCapability), - }; - - [Theory, MemberData(nameof(AllowSupportedCapabilities))] - public void Should_AllowSupportedCapabilities(IJsonRpcHandler handler, object instance) - { - var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs")); - - var collection = new HandlerCollection { textDocumentSyncHandler, handler }; - var provider = new ClientCapabilityProvider(collection); - - HasHandler(provider, instance).Should().BeTrue(); - } - - public static IEnumerable AllowSupportedCapabilities() - { - return GetItems(TextDocumentCapabilities, type => { - var handlerType = GetHandlerType(type); - var handler = Substitute.For(new Type[] { handlerType }, new object[0]); - return new[] { handler, Activator.CreateInstance(typeof(Supports<>).MakeGenericType(type), true, Activator.CreateInstance(type)) }; - }); - } - - [Theory, MemberData(nameof(DisallowUnsupportedCapabilities))] - public void Should_DisallowUnsupportedCapabilities(IJsonRpcHandler handler, object instance) - { - var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs")); - - var collection = new HandlerCollection { textDocumentSyncHandler, handler }; - var provider = new ClientCapabilityProvider(collection); - - HasHandler(provider, instance).Should().BeFalse(); - } - - public static IEnumerable DisallowUnsupportedCapabilities() - { - return GetItems(TextDocumentCapabilities, type => { - var handlerType = GetHandlerType(type); - var handler = Substitute.For(new Type[] { handlerType }, new object[0]); - return new[] { handler, Activator.CreateInstance(typeof(Supports<>).MakeGenericType(type), false) }; - }); - } - - [Theory, MemberData(nameof(DisallowNullSupportsCapabilities))] - public void Should_DisallowNullSupportedCapabilities(IJsonRpcHandler handler, object instance) - { - var textDocumentSyncHandler = TextDocumentSyncHandlerExtensions.With(DocumentSelector.ForPattern("**/*.cs")); - - var collection = new HandlerCollection { textDocumentSyncHandler, handler }; - var provider = new ClientCapabilityProvider(collection); - - HasHandler(provider, instance).Should().BeFalse(); - } - - public static IEnumerable DisallowNullSupportsCapabilities() - { - return GetItems(TextDocumentCapabilities, type => { - var handlerType = GetHandlerType(type); - var handler = Substitute.For(new Type[] { handlerType }, new object[0]); - return new[] { handler, Activator.CreateInstance(typeof(Supports<>).MakeGenericType(type), true) }; - }); - } - - private static bool HasHandler(ClientCapabilityProvider provider, object instance) - { - return (bool)typeof(ClientCapabilityProviderTests).GetTypeInfo() - .GetMethod(nameof(GenericHasHandler), BindingFlags.Static | BindingFlags.NonPublic) - .MakeGenericMethod(instance.GetType().GetTypeInfo().GetGenericArguments()[0]).Invoke(null, new[] { provider, instance }); - } - - private static bool HasHandler(ClientCapabilityProvider provider, Type type) - { - return (bool)typeof(ClientCapabilityProviderTests).GetTypeInfo() - .GetMethod(nameof(GenericHasHandler), BindingFlags.Static | BindingFlags.NonPublic) - .MakeGenericMethod(type).Invoke(null, new object[] { provider, null }); - } - - private static bool GenericHasHandler(ClientCapabilityProvider provider, Supports supports) - where T : DynamicCapability, ConnectedCapability - { - return provider.HasHandler(supports); - } - - private static IEnumerable GetItems(IEnumerable types, Func> func) - { - return types.Select(x => func(x).ToArray()); - } - - private static Type GetHandlerType(Type type) - { - return type.GetTypeInfo().ImplementedInterfaces - .Single(x => x.GetTypeInfo().IsGenericType && x.GetTypeInfo().GetGenericTypeDefinition() == typeof(ConnectedCapability<>)) - .GetTypeInfo().GetGenericArguments()[0]; - } - } } From 674805612ef19146af0d4faf844b91752323d4b3 Mon Sep 17 00:00:00 2001 From: David Driscoll Date: Wed, 18 Oct 2017 15:12:55 -0400 Subject: [PATCH 3/4] Updated cake (cache bust!) --- tools/packages.config | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tools/packages.config b/tools/packages.config index e0dd39bd2..747e13e64 100644 --- a/tools/packages.config +++ b/tools/packages.config @@ -1,4 +1,4 @@ - + From a804cf9a413269eec62fcd4c630a9899e58612ce Mon Sep 17 00:00:00 2001 From: David Driscoll Date: Wed, 18 Oct 2017 15:22:20 -0400 Subject: [PATCH 4/4] Fixed fluentassertion build error --- src/Lsp/LanguageServer.cs | 1 - src/Lsp/Lsp.csproj | 5 ----- 2 files changed, 6 deletions(-) diff --git a/src/Lsp/LanguageServer.cs b/src/Lsp/LanguageServer.cs index e51164afe..7f77a8cef 100644 --- a/src/Lsp/LanguageServer.cs +++ b/src/Lsp/LanguageServer.cs @@ -5,7 +5,6 @@ using System.Reflection; using System.Threading; using System.Threading.Tasks; -using FluentAssertions; using OmniSharp.Extensions.LanguageServer.Protocol; using Newtonsoft.Json.Linq; using OmniSharp.Extensions.JsonRpc; diff --git a/src/Lsp/Lsp.csproj b/src/Lsp/Lsp.csproj index f3370a6e6..93a8bbcef 100644 --- a/src/Lsp/Lsp.csproj +++ b/src/Lsp/Lsp.csproj @@ -10,9 +10,4 @@ - - - ..\..\..\..\Users\ddriscoll\.nuget\packages\fluentassertions\4.19.4\lib\net45\FluentAssertions.dll - -